void panda_assembler_unref( PandaAssembler assembler) { size_t count; if (assembler == NULL) return; #ifdef HAVE_PTHREAD pthread_mutex_lock(&assembler->mutex); #endif count = --(assembler->refcnt); #ifdef HAVE_PTHREAD pthread_mutex_unlock(&assembler->mutex); #endif if (count == 0) { #ifdef HAVE_PTHREAD pthread_mutex_destroy(&assembler->mutex); #endif free(assembler->kmerseen); module_destroy(assembler); DESTROY_MEMBER(assembler, next); DESTROY_MEMBER(assembler, noalgn); panda_algorithm_unref(assembler->algo); panda_log_proxy_unref(assembler->logger); free(assembler); } }
void free_module(void *data) { if (data) { module_t *module = (module_t*)data; module_destroy(module); } }
int main(int argc, char **argv) { if (argc < 2) { printf("Need .beam file\n"); return EXIT_FAILURE; } MappedFile *mapped_file = mapped_file_open_beam(argv[1]); if (IS_NULL_PTR(mapped_file)) { return EXIT_FAILURE; } GlobalContext *glb = globalcontext_new(); const void *startup_beam; uint32_t startup_beam_size; const char *startup_module_name = argv[1]; if (avmpack_is_valid(mapped_file->mapped, mapped_file->size)) { glb->avmpack_data = mapped_file->mapped; glb->avmpack_platform_data = mapped_file; if (!avmpack_find_section_by_flag(mapped_file->mapped, 1, &startup_beam, &startup_beam_size, &startup_module_name)) { fprintf(stderr, "%s cannot be started.\n", argv[1]); mapped_file_close(mapped_file); return EXIT_FAILURE; } } else if (iff_is_valid_beam(mapped_file->mapped)) { glb->avmpack_data = NULL; glb->avmpack_platform_data = NULL; startup_beam = mapped_file->mapped; startup_beam_size = mapped_file->size; } else { fprintf(stderr, "%s is not a BEAM file.\n", argv[1]); mapped_file_close(mapped_file); return EXIT_FAILURE; } Module *mod = module_new_from_iff_binary(glb, startup_beam, startup_beam_size); if (IS_NULL_PTR(mod)) { fprintf(stderr, "Cannot load startup module: %s\n", startup_module_name); return EXIT_FAILURE; } globalcontext_insert_module_with_filename(glb, mod, startup_module_name); mod->module_platform_data = NULL; Context *ctx = context_new(glb); ctx->leader = 1; context_execute_loop(ctx, mod, "start", 0); printf("Return value: %lx\n", ctx->x[0]); context_destroy(ctx); globalcontext_destroy(glb); module_destroy(mod); mapped_file_close(mapped_file); return EXIT_SUCCESS; }
celix_status_t bundle_destroy(bundle_pt bundle) { array_list_iterator_pt iter = arrayListIterator_create(bundle->modules); while (arrayListIterator_hasNext(iter)) { module_pt module = arrayListIterator_next(iter); module_destroy(module); } arrayListIterator_destroy(iter); arrayList_destroy(bundle->modules); celixThreadMutex_destroy(&bundle->lock); free(bundle); return CELIX_SUCCESS; }
static module_t *module_create (const char *path, char *argz, size_t argz_len) { module_t *m = xzmalloc (sizeof (*m)); struct stat sb; char **av = NULL; if (stat (path, &sb) < 0 || !(m->name = flux_modname (path, NULL, NULL)) || !(m->digest = digest (path))) { module_destroy (m); errno = ESRCH; return NULL; } m->size = sb.st_size; m->dso = dlopen (path, RTLD_NOW | RTLD_LOCAL); if (!m->dso || !(m->main = dlsym (m->dso, "mod_main"))) { module_destroy (m); errno = EINVAL; return NULL; } av = xzmalloc (sizeof (av[0]) * (argz_count (argz, argz_len) + 1)); argz_extract (argz, argz_len, av); if (m->main (NULL, argz_count (argz, argz_len), av) < 0) { module_destroy (m); errno = EINVAL; return NULL; } if (zhash_lookup (modules, m->name)) { module_destroy (m); errno = EEXIST; return NULL; } zhash_update (modules, m->name, m); zhash_freefn (modules, m->name, (zhash_free_fn *)module_destroy); if (av) free (av); return m; }
static module_t *module_create (const char *name, int size, const char *digest, int idle, uint32_t nodeid) { module_t *m = xzmalloc (sizeof (*m)); m->name = xstrdup (name); m->size = size; m->digest = xstrdup (digest); m->idle = idle; if (!(m->nodeset = nodeset_new_rank (nodeid))) { module_destroy (m); errno = EPROTO; return NULL; } return m; }
int test_modules_execution() { struct Test *test = tests; if (chdir("erlang_tests")) { return EXIT_FAILURE; } do { printf("-- EXECUTING TEST: %s\n", test->test_file); MappedFile *beam_file = mapped_file_open_beam(test->test_file); assert(beam_file != NULL); GlobalContext *glb = globalcontext_new(); glb->avmpack_data = NULL; glb->avmpack_platform_data = NULL; Module *mod = module_new_from_iff_binary(glb, beam_file->mapped, beam_file->size); if (IS_NULL_PTR(mod)) { fprintf(stderr, "Cannot load startup module: %s\n", test->test_file); test++; continue; } globalcontext_insert_module_with_filename(glb, mod, test->test_file); Context *ctx = context_new(glb); ctx->leader = 1; context_execute_loop(ctx, mod, "start", 0); int32_t value = term_to_int32(ctx->x[0]); if (value != test->expected_value) { fprintf(stderr, "\x1b[1;31mFailed test module %s, got value: %i\x1b[0m\n", test->test_file, value); } context_destroy(ctx); globalcontext_destroy(glb); module_destroy(mod); mapped_file_close(beam_file); test++; } while (test->test_file); return EXIT_SUCCESS; }
int main(int argc, char* argv[]) { if (argc != 3) { printf("%s module function\n", argv[0]); return 0; } Module* module = module_create(argv[1], 0); if (module != NULL) { void* func = module_sym(module, argv[2]); printf("func=%p\n", func); module_destroy(module); } else { printf("load %s failed\n", argv[1]); } return 0; }