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;
}