def test_new_handle(self): ffi = FFI(backend=self.Backend()) o = [2, 3, 4] p = ffi.new_handle(o) assert ffi.typeof(p) == ffi.typeof("void *") assert ffi.from_handle(p) is o assert ffi.from_handle(ffi.cast("char *", p)) is o py.test.raises(RuntimeError, ffi.from_handle, ffi.NULL)
def test_new_handle(self): ffi = FFI(backend=self.Backend()) o = [2, 3, 4] p = ffi.new_handle(o) assert ffi.typeof(p) == ffi.typeof("void *") assert ffi.from_handle(p) is o assert ffi.from_handle(ffi.cast("char *", p)) is o py.test.raises(RuntimeError, ffi.from_handle, ffi.NULL)
class CTC(object): """ """ def __init__(self, on_device='cpu', blank_label=0): libpath = get_ctc_lib() self.ffi = FFI() self.ffi.cdef(ctc_header()) self.ctclib = self.ffi.dlopen(libpath) supported_devices = ['cpu', 'gpu'] if on_device not in supported_devices: print("the requested device {} is not supported".format(on_device), file=sys.stderr) sys.exit(1) assign_device = 0 if on_device is 'cpu' else 1 self.options = self.ffi.new('ctcOptions*', { "loc": assign_device, "blank_label": blank_label })[0] self.size_in_bytes = self.ffi.new("size_t*") self.nout = None self.bsz = None def get_buf_size(self, ptr_to_buf): return self.ffi.sizeof( self.ffi.getctype(self.ffi.typeof(ptr_to_buf).item)) def buf_ref_from_array(self, arr): return self.ffi.from_buffer( self.ffi.buffer(self.ffi.cast('void*', arr.ptr), arr.nbytes)) def buf_ref_from_ptr(self, ptr, size): return self.ffi.from_buffer(self.ffi.buffer(ptr, size)) def get_gpu_workspace_size(self, lbl_lens, utt_lens, nout, bsz): self.nout = nout self.bsz = bsz _lbl_lens = self.ffi.cast("int*", lbl_lens.ravel().ctypes.data) _utt_lens = self.ffi.cast("int*", utt_lens.ravel().ctypes.data) status = self.ctclib.get_workspace_size(_lbl_lens, _utt_lens, self.nout, self.bsz, self.options, self.size_in_bytes) assert status is 0, "get_workspace_size() in warp-ctc failed" return self.size_in_bytes[0] def bind_to_gpu(self, acts, grads, lbls, lbl_lens, utt_lens, costs, workspace, scratch_size, stream): if stream is None: stream_ptr = self.ffi.cast('void*', 0) stream_buf_size = self.ffi.sizeof(self.ffi.new_handle(stream)) stream_buf = self.buf_ref_from_ptr(stream_ptr, stream_buf_size) else: stream_buf = self.ffi.cast("void*", stream.handle) self.options.stream = stream_buf flat_dims = np.prod(acts.shape) assert np.prod(grads.shape) == flat_dims acts_buf = self.ffi.cast("float*", self.buf_ref_from_array(acts)) grads_buf = self.ffi.cast("float*", self.buf_ref_from_array(grads)) costs_buf = self.ffi.cast("float*", self.buf_ref_from_array(costs)) warp_grads_buf_size = flat_dims * self.get_buf_size(grads_buf) warp_costs_buf_size = self.bsz * self.get_buf_size(costs_buf) warp_labels = self.ffi.cast("int*", lbls.ravel().ctypes.data) warp_label_lens = self.ffi.cast("int*", lbl_lens.ravel().ctypes.data) warp_input_lens = self.ffi.cast("int*", utt_lens.ravel().ctypes.data) workspace_buf = self.buf_ref_from_ptr( self.ffi.cast('void*', workspace), int(scratch_size)) ctc_status = self.ctclib.compute_ctc_loss(acts_buf, grads_buf, warp_labels, warp_label_lens, warp_input_lens, self.nout, self.bsz, costs_buf, workspace_buf, self.options) assert ctc_status is 0, "warp-ctc run failed" def bind_to_cpu(self, acts, lbls, utt_lens, lbl_lens, grads, costs, n_threads=1): self.options.num_threads = n_threads _, self.bsz, self.nout = acts.shape flat_dims = np.prod(acts.shape) assert np.prod(grads.shape) == flat_dims acts_buf = self.ffi.cast("float*", acts.ctypes.data) grads_buf = self.ffi.cast("float*", grads.ctypes.data) costs_buf = self.ffi.cast("float*", costs.ctypes.data) warp_grads_buf_size = flat_dims * self.get_buf_size(grads_buf) warp_costs_buf_size = self.bsz * self.get_buf_size(costs_buf) warp_labels = self.ffi.cast("int*", lbls.ravel().ctypes.data) warp_label_lens = self.ffi.cast("int*", lbl_lens.ravel().ctypes.data) warp_input_lens = self.ffi.cast("int*", utt_lens.ravel().ctypes.data) status = self.ctclib.get_workspace_size(warp_label_lens, warp_input_lens, self.nout, self.bsz, self.options, self.size_in_bytes) assert status is 0, "get_workspace_size() in warp-ctc failed" # TODO: workspace is a variable size buffer whose size is # determined during each call, so we can't initialize ahead # of time. Can we avoid this? workspace = self.ffi.new("char[]", self.size_in_bytes[0]) ctc_status = self.ctclib.compute_ctc_loss(acts_buf, grads_buf, warp_labels, warp_label_lens, warp_input_lens, self.nout, self.bsz, costs_buf, workspace, self.options) # transfer grads and costs back without copying self.ffi.memmove(grads, grads_buf, warp_grads_buf_size) grads = grads.reshape((acts.shape)) self.ffi.memmove(costs, costs_buf, warp_costs_buf_size) assert ctc_status is 0, "warp-ctc run failed"
class LibGraphqlParser: def __init__(self): self._ffi = FFI() self._ffi.cdef(CDEFS_LIBGRAPHQL) # TODO do a conf of this ? try: self._lib = self._ffi.dlopen("/usr/local/lib/libgraphqlparser.so") except OSError: self._lib = self._ffi.dlopen("/usr/local/lib/libgraphqlparser.dylib") self._lib_callbacks = self._ffi.new( "struct GraphQLAstVisitorCallbacks *" ) self._errors = self._ffi.new("char **") self._callbacks = [] self._interested_by = {} self._default_visitor_cls = Visitor self._creates_callbacks() def _create_visitor_element(self, libgraphql_type, element): try: return _LIBGRAPHQL_TYPE_TO_CLASS[libgraphql_type]( self._lib, self._ffi, element) except KeyError: pass return _VisitorElement(self._lib, self._ffi, libgraphql_type, element) def _callback_enter(self, libgraphql_type, element, udata): context = self._ffi.from_handle(udata) context.update( Visitor.IN, self._create_visitor_element(libgraphql_type, element) ) return context.continue_child def _callback_exit(self, libgraphql_type, element, udata): context = self._ffi.from_handle(udata) if context.continue_child: context.update( Visitor.OUT, self._create_visitor_element(libgraphql_type, element) ) return None def _set_callback(self, proto, func, attr): c_func = self._ffi.callback(proto)(func) # Keep the callbacks alive in this list # to keep the underlying cdata alive. # because we do it with reflexion and # not with decoration self._callbacks.append(c_func) setattr(self._lib_callbacks, attr, c_func) def _set_exit_callback(self, typee): self._set_callback( "void(struct GraphQLAst%s *, void *)" % typee[0], partial(self._callback_exit, typee[0]), "end_visit_%s" % typee[1] ) def _set_enter_callback(self, typee): self._set_callback( "int(struct GraphQLAst%s *, void *)" % typee[0], partial(self._callback_enter, typee[0]), "visit_%s" % typee[1] ) def _creates_callbacks(self): for typee in TYPES_LIBGRAPHQL: if typee[0] not in ["Name"]: self._set_enter_callback(typee) self._set_exit_callback(typee) def _parse(self, query): if isinstance(query, str): # TODO don't replace here. query = query.replace("\n", " ").encode("UTF-8") c_query = self._ffi.new("char[]", query) parsed_data = _ParsedData( self._lib.graphql_parse_string(c_query, self._errors), self._lib.graphql_node_free ) if self._errors[0] != self._ffi.NULL: # TODO specialize Exception here e = Exception( self._ffi.string(self._errors[0]).decode('UTF-8', 'replace') ) self._lib.graphql_error_free(self._errors[0]) raise e return parsed_data def parse_and_visit(self, query, ctx=None): if not ctx: ctx = self._default_visitor_cls() with self._parse(query) as parsed: self._lib.graphql_node_visit( parsed, self._lib_callbacks, self._ffi.new_handle(ctx) ) def parse_and_jsonify(self, query): with self._parse(query) as parsed: return self._ffi.string(self._lib.graphql_ast_to_json(parsed))
# -*- coding: utf-8 -*- # TODO: this does not works. from cffi import FFI ffi = FFI() ffi.cdef(""" void print_address(void *obj); """) c_lib = ffi.dlopen("./libsample2.so") class Foo(object): def __init__(self, address): self.address = address def get_address(self): return self.address print_address = c_lib.print_address instance = Foo("Foo Bar") _instance = ffi.new_handle(instance) print_address(instance)