def descr_poll(self, space, timeout=-1.0, maxevents=-1): self.check_closed(space) if timeout < 0: timeout = -1.0 else: timeout *= 1000.0 if maxevents == -1: maxevents = FD_SETSIZE - 1 elif maxevents < 1: raise oefmt(space.w_ValueError, "maxevents must be greater than 0, not %d", maxevents) with lltype.scoped_alloc(rffi.CArray(rffi.UINT), maxevents) as fids: with lltype.scoped_alloc(rffi.CArray(rffi.INT), maxevents) as events: nfds = pypy_epoll_wait(self.epfd, fids, events, maxevents, int(timeout)) if nfds < 0: raise exception_from_saved_errno(space, space.w_IOError) elist_w = [None] * nfds for i in xrange(nfds): elist_w[i] = space.newtuple( [space.newint(fids[i]), space.newint(events[i])]) return space.newlist(elist_w)
def fake_call_impl_any(cif_description, func_addr, exchange_buffer): ofs = 16 for avalue in unroll_avalues: TYPE = rffi.CArray(lltype.typeOf(avalue)) data = rffi.ptradd(exchange_buffer, ofs) got = rffi.cast(lltype.Ptr(TYPE), data)[0] if lltype.typeOf(avalue) is lltype.SingleFloat: got = float(got) avalue = float(avalue) elif (lltype.typeOf(avalue) is rffi.SIGNEDCHAR or lltype.typeOf(avalue) is rffi.UCHAR): got = intmask(got) avalue = intmask(avalue) assert got == avalue ofs += 16 write_to_ofs = 0 if rvalue is not None: write_rvalue = rvalue if BIG_ENDIAN: if (lltype.typeOf(write_rvalue) is rffi.SIGNEDCHAR or lltype.typeOf(write_rvalue) is rffi.UCHAR): # 'write_rvalue' is an int type smaller than Signed write_to_ofs = rffi.sizeof(rffi.LONG) - 1 else: write_rvalue = 12923 # ignored TYPE = rffi.CArray(lltype.typeOf(write_rvalue)) data = rffi.ptradd(exchange_buffer, ofs) rffi.cast(lltype.Ptr(TYPE), data)[write_to_ofs] = write_rvalue
def __init__(self, arena_size, page_size, small_request_threshold): # 'small_request_threshold' is the largest size that we # can ask with self.malloc(). self.arena_size = arena_size self.page_size = page_size self.small_request_threshold = small_request_threshold self.arenas_count = 0 # # 'pageaddr_for_size': for each size N between WORD and # small_request_threshold (included), contains either NULL or # a pointer to a page that has room for at least one more # allocation of the given size. length = small_request_threshold / WORD + 1 self.page_for_size = self._new_page_ptr_list(length) self.full_page_for_size = self._new_page_ptr_list(length) self.old_page_for_size = self._new_page_ptr_list(length) self.old_full_page_for_size = self._new_page_ptr_list(length) self.nblocks_for_size = lltype.malloc(rffi.CArray(lltype.Signed), length, flavor='raw', immortal=True) self.hdrsize = llmemory.raw_malloc_usage(llmemory.sizeof(PAGE_HEADER)) assert page_size > self.hdrsize self.nblocks_for_size[0] = 0 # unused for i in range(1, length): self.nblocks_for_size[i] = (page_size - self.hdrsize) // (WORD * i) # self.max_pages_per_arena = arena_size // page_size self.arenas_lists = lltype.malloc(rffi.CArray(ARENA_PTR), self.max_pages_per_arena, flavor='raw', zero=True, immortal=True) # this is used in mass_free() only self.old_arenas_lists = lltype.malloc(rffi.CArray(ARENA_PTR), self.max_pages_per_arena, flavor='raw', zero=True, immortal=True) # # the arena currently consumed; it must have at least one page # available, or be NULL. The arena object that we point to is # not in any 'arenas_lists'. We will consume all its pages before # we choose a next arena, even if there is a major collection # in-between. self.current_arena = ARENA_NULL # # guarantee that 'arenas_lists[1:min_empty_nfreepages]' are all empty self.min_empty_nfreepages = self.max_pages_per_arena # # part of current_arena might still contain uninitialized pages self.num_uninitialized_pages = 0 # # the total memory used, counting every block in use, without # the additional bookkeeping stuff. self.total_memory_used = r_uint(0) self.peak_memory_used = r_uint(0) self.total_memory_alloced = r_uint(0) self.peak_memory_alloced = r_uint(0)
def setup2(n): lst = rand_list_of(n) arr = lltype.malloc(rffi.CArray(rffi.LONGLONG), n, flavor='raw') for i, k in enumerate(lst): arr[i] = k lst2 = rand_list_of(n) arr2 = lltype.malloc(rffi.CArray(rffi.LONGLONG), n, flavor='raw') for i, k in enumerate(lst2): arr2[i] = k return arr, arr2, 0, n - 1
def test_array_varsized_struct(): dirent = rffi_platform.getstruct( "struct dirent", """ struct dirent /* for this example only, not the exact dirent */ { int d_off; char d_name[1]; }; """, [("d_name", rffi.CArray(rffi.CHAR))]) assert rffi.offsetof(dirent, 'c_d_name') == 4 assert dirent.c_d_name == rffi.CArray(rffi.CHAR)
def unpack_traceback(addr): codemap_raw = find_codemap_at_addr( addr, lltype.nullptr(rffi.CArray(lltype.Signed))) if not codemap_raw: return [] # no codemap for that position storage = lltype.malloc(rffi.CArray(lltype.Signed), 1, flavor='raw') storage[0] = 0 res = [] while True: item = yield_bytecode_at_addr(codemap_raw, addr, storage) if item == -1: break res.append(item) lltype.free(storage, flavor='raw') return res
def _do_call(self, funcsym, ll_args, RESULT): # XXX: check len(args)? ll_result = lltype.nullptr(rffi.CCHARP.TO) if self.restype != types.void: ll_result = lltype.malloc(rffi.CCHARP.TO, intmask(self.restype.c_size), flavor='raw') ffires = c_ffi_call(self.ll_cif, self.funcsym, rffi.cast(rffi.VOIDP, ll_result), rffi.cast(rffi.VOIDPP, ll_args)) if RESULT is not lltype.Void: TP = lltype.Ptr(rffi.CArray(RESULT)) buf = rffi.cast(TP, ll_result) if types.is_struct(self.restype): assert RESULT == rffi.SIGNED # for structs, we directly return the buffer and transfer the # ownership res = rffi.cast(RESULT, buf) else: res = buf[0] else: res = None self._free_buffers(ll_result, ll_args) clibffi.check_fficall_result(ffires, self.flags) return res
def spawn(loop, process, file, args, env, streams): """ The file descriptor list should be a list of streams to wire up to FDs in the child. A None stream is mapped to UV_IGNORE. """ with rffi.scoped_str2charp(file) as rawFile: rawArgs = rffi.liststr2charpp(args) rawEnv = rffi.liststr2charpp(env) with rffi.scoped_str2charp(".") as rawCWD: options = rffi.make(cConfig["process_options_t"], c_file=rawFile, c_args=rawArgs, c_env=rawEnv, c_cwd=rawCWD) with lltype.scoped_alloc(rffi.CArray(stdio_container_t), len(streams)) as rawStreams: for i, stream in enumerate(streams): if stream == lltype.nullptr(stream_t): flags = UV_IGNORE else: flags = UV_CREATE_PIPE if i == 0: flags |= UV_READABLE_PIPE elif i in (1, 2): flags |= UV_WRITABLE_PIPE set_stdio_stream(rawStreams[i], stream) rffi.setintfield(rawStreams[i], "c_flags", flags) options.c_stdio = rawStreams rffi.setintfield(options, "c_stdio_count", len(streams)) add_exit_cb(options, processDiscard) rffi.setintfield(options, "c_flags", UV_PROCESS_WINDOWS_HIDE) rv = uv_spawn(loop, process, options) free(options) rffi.free_charpp(rawEnv) rffi.free_charpp(rawArgs) check("spawn", rv)
def call(self, space, __args__): with handles.using(space, __args__.arguments_w[0]) as h_self: n = len(__args__.arguments_w) - 1 with lltype.scoped_alloc(rffi.CArray(llapi.HPy), n) as args_h: i = 0 while i < n: args_h[i] = handles.new(space, __args__.arguments_w[i + 1]) i += 1 h_kw = 0 if __args__.keywords: w_kw = space.newdict() for i in range(len(__args__.keywords)): key = __args__.keywords[i] w_value = __args__.keywords_w[i] space.setitem_str(w_kw, key, w_value) h_kw = handles.new(space, w_kw) fptr = llapi.cts.cast('HPyFunc_initproc', self.cfuncptr) state = space.fromcache(State) try: result = fptr(state.ctx, h_self, args_h, n, h_kw) finally: if h_kw: handles.close(space, h_kw) for i in range(n): handles.close(space, args_h[i]) if rffi.cast(lltype.Signed, result) < 0: # If we're here, it means no exception was set raise oefmt(space.w_SystemError, "Function returned an error result without setting an exception") return space.w_None
def _do_call(self, funcsym, ll_args, RESULT): # XXX: check len(args)? ll_result = lltype.nullptr(rffi.VOIDP.TO) if self.restype != types.void: size = adjust_return_size(intmask(self.restype.c_size)) ll_result = lltype.malloc(rffi.VOIDP.TO, size, flavor='raw') ffires = c_ffi_call(self.ll_cif, self.funcsym, rffi.cast(rffi.VOIDP, ll_result), rffi.cast(rffi.VOIDPP, ll_args)) if RESULT is not lltype.Void: TP = lltype.Ptr(rffi.CArray(RESULT)) if types.is_struct(self.restype): assert RESULT == rffi.SIGNED # for structs, we directly return the buffer and transfer the # ownership buf = rffi.cast(TP, ll_result) res = rffi.cast(RESULT, buf) else: if _BIG_ENDIAN and types.getkind(self.restype) in ('i','u'): ptr = ll_result n = rffi.sizeof(lltype.Signed) - self.restype.c_size ptr = rffi.ptradd(ptr, n) res = rffi.cast(TP, ptr)[0] else: res = rffi.cast(TP, ll_result)[0] else: res = None self._free_buffers(ll_result, ll_args) clibffi.check_fficall_result(ffires, self.flags) return res
def call_varargs_kw(self, space, h_self, __args__, skip_args, has_keywords): # this function is more or less the equivalent of # ctx_CallRealFunctionFromTrampoline in cpython-universal n = len(__args__.arguments_w) - skip_args # XXX this looks inefficient: ideally, we would like the equivalent of # alloca(): do we have it in RPython? The alternative is to wrap # arguments_w in a tuple, convert to handle and pass it to a C # function whichs calls alloca() and the forwards everything to the # functpr with lltype.scoped_alloc(rffi.CArray(llapi.HPy), n) as args_h: i = 0 while i < n: args_h[i] = handles.new(space, __args__.arguments_w[i + skip_args]) i += 1 if has_keywords: h_result = self.call_keywords(space, h_self, args_h, n, __args__) else: h_result = self.call_varargs(space, h_self, args_h, n) # XXX this should probably be in a try/finally. We should add a # test to check that we don't leak handles for i in range(n): handles.close(space, args_h[i]) return handles.consume(space, h_result)
def init_urandom(): """NOT_RPYTHON Return an array of one HCRYPTPROV, initialized to NULL. It is filled automatically the first time urandom() is called. """ return lltype.malloc(rffi.CArray(HCRYPTPROV), 1, immortal=True, zero=True)
def test_byval_result(self): """ RPY_EXPORTED struct Point make_point(Signed x, Signed y) { struct Point p; p.x = x; p.y = y; return p; } """ libfoo = CDLL(self.libfoo_name) ffi_point_struct = make_struct_ffitype_e( rffi.sizeof(rffi.SIGNED) * 2, 0, [types.signed, types.signed]) ffi_point = ffi_point_struct.ffistruct libfoo = CDLL(self.libfoo_name) make_point = (libfoo, 'make_point', [types.signed, types.signed], ffi_point) # PTR = lltype.Ptr(rffi.CArray(rffi.SIGNED)) p = self.call(make_point, [12, 34], PTR, is_struct=True, jitif=["byval"]) assert p[0] == 12 assert p[1] == 34 lltype.free(p, flavor='raw') lltype.free(ffi_point_struct, flavor='raw')
def test_array_fields(self): POINT = lltype.Struct( "POINT", ("x", lltype.Float), ("y", lltype.Float), ) points = lltype.malloc(rffi.CArray(POINT), 2, flavor="raw") points[0].x = 1.0 points[0].y = 2.0 points[1].x = 3.0 points[1].y = 4.0 points = rffi.cast(rffi.CArrayPtr(lltype.Char), points) assert array_getitem(types.double, 16, points, 0, 0) == 1.0 assert array_getitem(types.double, 16, points, 0, 8) == 2.0 assert array_getitem(types.double, 16, points, 1, 0) == 3.0 assert array_getitem(types.double, 16, points, 1, 8) == 4.0 # array_setitem(types.double, 16, points, 0, 0, 10.0) array_setitem(types.double, 16, points, 0, 8, 20.0) array_setitem(types.double, 16, points, 1, 0, 30.0) array_setitem(types.double, 16, points, 1, 8, 40.0) # assert array_getitem(types.double, 16, points, 0, 0) == 10.0 assert array_getitem(types.double, 16, points, 0, 8) == 20.0 assert array_getitem(types.double, 16, points, 1, 0) == 30.0 assert array_getitem(types.double, 16, points, 1, 8) == 40.0 # lltype.free(points, flavor="raw")
def test_as_ucs4(self, space): w_x = space.wrap(u"ab\u0660") count1 = space.int_w(space.len(w_x)) x_chunk = PyUnicode_AsUCS4Copy(space, w_x) assert x_chunk[0] == ord('a') assert x_chunk[1] == ord('b') assert x_chunk[2] == 0x0660 assert x_chunk[3] == 0 Py_UCS4 = lltype.typeOf(x_chunk).TO.OF lltype.free(x_chunk, flavor='raw', track_allocation=False) target_chunk = lltype.malloc(rffi.CArray(Py_UCS4), 4, flavor='raw') target_chunk[3] = rffi.cast(Py_UCS4, 99999) x_chunk = PyUnicode_AsUCS4(space, w_x, target_chunk, 3, 0) assert x_chunk == target_chunk assert x_chunk[0] == ord('a') assert x_chunk[1] == ord('b') assert x_chunk[2] == 0x0660 assert x_chunk[3] == 99999 x_chunk[2] = rffi.cast(Py_UCS4, 77777) x_chunk = PyUnicode_AsUCS4(space, w_x, target_chunk, 4, 1) assert x_chunk == target_chunk assert x_chunk[0] == ord('a') assert x_chunk[1] == ord('b') assert x_chunk[2] == 0x0660 assert x_chunk[3] == 0 lltype.free(target_chunk, flavor='raw')
def test_byval_argument(self): """ struct Point { Signed x; Signed y; }; RPY_EXPORTED Signed sum_point(struct Point p) { return p.x + p.y; } """ libfoo = CDLL(self.libfoo_name) ffi_point_struct = make_struct_ffitype_e(0, 0, [types.signed, types.signed]) ffi_point = ffi_point_struct.ffistruct sum_point = (libfoo, 'sum_point', [ffi_point], types.signed) # ARRAY = rffi.CArray(rffi.SIGNED) buf = lltype.malloc(ARRAY, 2, flavor='raw') buf[0] = 30 buf[1] = 12 adr = rffi.cast(rffi.VOIDP, buf) res = self.call(sum_point, [('arg_raw', adr)], rffi.SIGNED, jitif=["byval"]) assert res == 42 # check that we still have the ownership on the buffer assert buf[0] == 30 assert buf[1] == 12 lltype.free(buf, flavor='raw') lltype.free(ffi_point_struct, flavor='raw')
def __init__(self): GcCache.__init__(self, False, None) self._generated_functions = [] self.gcrootmap = MockShadowStackRootMap() self.write_barrier_descr = WriteBarrierDescr(self) self.nursery_ptrs = lltype.malloc(rffi.CArray(lltype.Signed), 2, flavor='raw') self._initialize_for_tests() self.frames = [] def malloc_slowpath(size): self._collect() res = self.nursery_ptrs[0] self.nursery_ptrs[0] += size return res self.malloc_slowpath_fnptr = llhelper_args(malloc_slowpath, [lltype.Signed], lltype.Signed) def malloc_array(itemsize, tid, num_elem): import pdb pdb.set_trace() self.malloc_slowpath_array_fnptr = llhelper_args(malloc_array, [lltype.Signed] * 3, lltype.Signed) self.all_nurseries = []
def __init__(self, space, environment, context, retrieveError): self.context = context if retrieveError: if environment.errorHandle: handle = environment.errorHandle handleType = roci.OCI_HTYPE_ERROR else: handle = environment.handle handleType = roci.OCI_HTYPE_ENV codeptr = lltype.malloc(rffi.CArray(roci.sb4), 1, flavor='raw') BUFSIZE = 1024 textbuf, text = rffi.alloc_buffer(BUFSIZE) try: status = roci.OCIErrorGet( handle, 1, lltype.nullptr(roci.oratext.TO), codeptr, textbuf, BUFSIZE, handleType) if status != roci.OCI_SUCCESS: raise OperationError( get(space).w_InternalError, space.wrap("No Oracle error?")) self.code = rffi.cast(lltype.Signed, codeptr[0]) self.w_message = config.w_string(space, textbuf) finally: lltype.free(codeptr, flavor='raw') rffi.keep_buffer_alive_until_here(textbuf, text) if config.WITH_UNICODE: # XXX remove double zeros at the end pass
def _setup_exception_handling_untranslated(self): # for running un-translated only, all exceptions occurring in the # llinterpreter are stored in '_exception_emulator', which is then # read back by the machine code reading at the address given by # pos_exception() and pos_exc_value(). _exception_emulator = lltype.malloc(rffi.CArray(lltype.Signed), 2, zero=True, flavor='raw', immortal=True) self._exception_emulator = _exception_emulator def _store_exception(lle): self._last_exception = lle # keepalive tp_i = rffi.cast(lltype.Signed, lle.args[0]) v_i = rffi.cast(lltype.Signed, lle.args[1]) _exception_emulator[0] = tp_i _exception_emulator[1] = v_i self.debug_ll_interpreter = LLInterpreter(self.rtyper) self.debug_ll_interpreter._store_exception = _store_exception def pos_exception(): return rffi.cast(lltype.Signed, _exception_emulator) def pos_exc_value(): return (rffi.cast(lltype.Signed, _exception_emulator) + rffi.sizeof(lltype.Signed)) self.pos_exception = pos_exception self.pos_exc_value = pos_exc_value self.insert_stack_check = lambda: (0, 0, 0)
def __init__(self, space, w_class, size, depth, display): W_AbstractObjectWithClassReference.__init__(self, space, w_class) self._real_depth_buffer = lltype.malloc(rffi.CArray(rffi.UINT), size, flavor='raw') self.pixelbuffer = display.get_pixelbuffer() self._realsize = size self.display = display self._depth = depth
def init_urandom(): """NOT_RPYTHON Return an array of one int, initialized to 0. It is filled automatically the first time urandom() is called. """ return lltype.malloc(rffi.CArray(lltype.Signed), 1, immortal=True, zero=True)
def push_arg_as_ffiptr(ffitp, arg, ll_buf): # This is for primitive types. Note that the exact type of 'arg' may be # different from the expected 'c_size'. To cope with that, we fall back # to a byte-by-byte copy. TP = lltype.typeOf(arg) TP_P = lltype.Ptr(rffi.CArray(TP)) TP_size = rffi.sizeof(TP) c_size = intmask(ffitp.c_size) # if both types have the same size, we can directly write the # value to the buffer if c_size == TP_size: buf = rffi.cast(TP_P, ll_buf) buf[0] = arg else: # needs byte-by-byte copying. Make sure 'arg' is an integer type. # Note that this won't work for rffi.FLOAT/rffi.DOUBLE. assert TP is not rffi.FLOAT and TP is not rffi.DOUBLE if TP_size <= rffi.sizeof(lltype.Signed): arg = rffi.cast(lltype.Unsigned, arg) else: arg = rffi.cast(lltype.UnsignedLongLong, arg) if _LITTLE_ENDIAN: for i in range(c_size): ll_buf[i] = chr(arg & 0xFF) arg >>= 8 elif _BIG_ENDIAN: for i in range(c_size - 1, -1, -1): ll_buf[i] = chr(arg & 0xFF) arg >>= 8 else: raise AssertionError
def __init__(self, rtyper, stats, opts, translate_support_code=False, gcdescr=None): assert type(opts) is not bool self.opts = opts from rpython.jit.backend.llsupport.gc import get_ll_description AbstractCPU.__init__(self) self.rtyper = rtyper self.stats = stats self.translate_support_code = translate_support_code if translate_support_code and rtyper is not None: translator = rtyper.annotator.translator self.remove_gctypeptr = translator.config.translation.gcremovetypeptr else: translator = None self.gc_ll_descr = get_ll_description(gcdescr, translator, rtyper) # support_guard_gc_type indicates if a gc type of an object can be read. # In some states (boehm or x86 untranslated) the type is not known just yet, # because there are cases where it is not guarded. The precise place where it's not # is while inlining short preamble. self.supports_guard_gc_type = self.gc_ll_descr.supports_guard_gc_type if translator and translator.config.translation.gcremovetypeptr: self.vtable_offset = None else: self.vtable_offset, _ = symbolic.get_field_token( rclass.OBJECT, 'typeptr', translate_support_code) self.subclassrange_min_offset, _ = symbolic.get_field_token( rclass.OBJECT_VTABLE, 'subclassrange_min', translate_support_code) if translate_support_code: self._setup_exception_handling_translated() else: self._setup_exception_handling_untranslated() self.asmmemmgr = asmmemmgr.AsmMemoryManager() if self.HAS_CODEMAP: self.codemap = codemap.CodemapStorage() self._setup_frame_realloc(translate_support_code) ad = self.gc_ll_descr.getframedescrs(self).arraydescr self.signedarraydescr = ad # the same as normal JITFRAME, however with an array of pointers self.refarraydescr = ArrayDescr(ad.basesize, ad.itemsize, ad.lendescr, FLAG_POINTER) if WORD == 4: self.floatarraydescr = ArrayDescr(ad.basesize, ad.itemsize * 2, ad.lendescr, FLAG_FLOAT) else: self.floatarraydescr = ArrayDescr(ad.basesize, ad.itemsize, ad.lendescr, FLAG_FLOAT) self.setup() self._debug_tls_errno_container = lltype.malloc(rffi.CArray( lltype.Signed), 7, flavor='raw', zero=True, track_allocation=False) self._debug_tls_errno_container[1] = 1234 # dummy thread ident
def test_copy_list_to_raw_array(self): ARRAY = rffi.CArray(lltype.Signed) buf = lltype.malloc(ARRAY, 4, flavor='raw') lst = [1, 2, 3, 4] copy_list_to_raw_array(lst, buf) for i in range(4): assert buf[i] == i + 1 lltype.free(buf, flavor='raw')
def _struct_setfield(TYPE, addr, offset, value): """ Write the field of type TYPE at addr+offset. addr is of type rffi.VOIDP, offset is an int. """ addr = rffi.ptradd(addr, offset) PTR_FIELD = lltype.Ptr(rffi.CArray(TYPE)) rffi.cast(PTR_FIELD, addr)[0] = value
def _struct_getfield(TYPE, addr, offset): """ Read the field of type TYPE at addr+offset. addr is of type rffi.VOIDP, offset is an int. """ addr = rffi.ptradd(addr, offset) PTR_FIELD = lltype.Ptr(rffi.CArray(TYPE)) return rffi.cast(PTR_FIELD, addr)[0]
def fake_call_impl_any(cif_description, func_addr, exchange_buffer): ofs = 16 for avalue in unroll_avalues: TYPE = rffi.CArray(lltype.typeOf(avalue)) data = rffi.ptradd(exchange_buffer, ofs) got = rffi.cast(lltype.Ptr(TYPE), data)[0] if lltype.typeOf(avalue) is lltype.SingleFloat: got = float(got) avalue = float(avalue) assert got == avalue ofs += 16 if rvalue is not None: write_rvalue = rvalue else: write_rvalue = 12923 # ignored TYPE = rffi.CArray(lltype.typeOf(write_rvalue)) data = rffi.ptradd(exchange_buffer, ofs) rffi.cast(lltype.Ptr(TYPE), data)[0] = write_rvalue
def __init__(self, space, size, depth): W_AbstractObjectWithIdentityHash.__init__(self) self._squeak_pixel_buffer = lltype.malloc(rffi.CArray(rffi.UINT), size, flavor='raw') self._realsize = size self._depth = depth self._display = space.display() self.relinquish_display()
def __init__(self, space, w_class, size, depth): model.W_AbstractObjectWithClassReference.__init__(self, space, w_class) self._real_depth_buffer = lltype.malloc(rffi.CArray(rffi.UINT), size, flavor='raw') self._realsize = size self._depth = depth self.display = space.display() self.relinquish_display()
def win_perf_counter(): with lltype.scoped_alloc(rffi.CArray(rffi.lltype.SignedLongLong), 1) as a: if state.divisor == 0.0: QueryPerformanceCounter(a) state.counter_start = a[0] QueryPerformanceFrequency(a) state.divisor = float(a[0]) QueryPerformanceCounter(a) diff = a[0] - state.counter_start return float(diff) / state.divisor