ERL_NIF_TERM x_cluster_stat(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { const char * func_name = "x_cluster_stat()"; uint64_t id; if (!enif_get_uint64(env, argv[0], &id)) { logger.error(MOD_NAME, func_name, "enif get params failed"); return enif_make_badarg(env); } logger.debug(MOD_NAME, func_name, "cluster : %ld", id); rados_t cluster = map_cluster_get(id); if (cluster == NULL) { logger.error(MOD_NAME, func_name, "cluster non-existing : %ld", id); return enif_make_badarg(env); } rados_cluster_stat_t stat; int err = rados_cluster_stat(cluster, &stat); if (err < 0) { logger.error(MOD_NAME, func_name, "failed to get stat for %ld: %s", id, strerror(-err)); return make_error_tuple(env, -err); } ERL_NIF_TERM term_list = enif_make_list(env, 0); ERL_NIF_TERM t = enif_make_uint64(env, stat.num_objects); term_list = enif_make_list_cell(env, enif_make_tuple2(env, enif_make_atom(env, "num_objects"), t), term_list); t = enif_make_uint64(env, stat.kb_avail); term_list = enif_make_list_cell(env, enif_make_tuple2(env, enif_make_atom(env, "kb_avail"), t), term_list); t = enif_make_uint64(env, stat.kb_used); term_list = enif_make_list_cell(env, enif_make_tuple2(env, enif_make_atom(env, "kb_used"), t), term_list); t = enif_make_uint64(env, stat.kb); term_list = enif_make_list_cell(env, enif_make_tuple2(env, enif_make_atom(env, "kb"), t), term_list); return enif_make_tuple2(env, enif_make_atom(env, "ok"), term_list); }
static ERL_NIF_TERM read_info_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { posix_errno_t posix_errno; efile_fileinfo_t info = {0}; efile_path_t path; int follow_links; if(argc != 2 || !enif_get_int(env, argv[1], &follow_links)) { return enif_make_badarg(env); } if((posix_errno = efile_marshal_path(env, argv[0], &path))) { return posix_error_to_tuple(env, posix_errno); } else if((posix_errno = efile_read_info(&path, follow_links, &info))) { return posix_error_to_tuple(env, posix_errno); } /* #file_info as declared in file.hrl */ return enif_make_tuple(env, 14, am_file_info, enif_make_uint64(env, info.size), efile_filetype_to_atom(info.type), efile_access_to_atom(info.access), enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info.a_time)), enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info.m_time)), enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info.c_time)), enif_make_uint(env, info.mode), enif_make_uint(env, info.links), enif_make_uint(env, info.major_device), enif_make_uint(env, info.minor_device), enif_make_uint(env, info.inode), enif_make_uint(env, info.uid), enif_make_uint(env, info.gid) ); }
static ERL_NIF_TERM seek_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { Sint64 new_position, offset; enum efile_seek_t seek; ASSERT(argc == 2); if(!enif_get_int64(env, argv[1], &offset)) { return enif_make_badarg(env); } if(enif_is_identical(argv[0], am_bof)) { seek = EFILE_SEEK_BOF; } else if(enif_is_identical(argv[0], am_cur)) { seek = EFILE_SEEK_CUR; } else if(enif_is_identical(argv[0], am_eof)) { seek = EFILE_SEEK_EOF; } else { return enif_make_badarg(env); } if(!efile_seek(d, seek, offset, &new_position)) { return posix_error_to_tuple(env, d->posix_errno); } return enif_make_tuple2(env, am_ok, enif_make_uint64(env, new_position)); }
ERL_NIF_TERM x_create_with_user(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { const char * func_name = "x_create_with_user()"; logger.debug(MOD_NAME, func_name, "Entered"); char name[MAX_NAME_LEN]; memset(name, 0, MAX_NAME_LEN); if (!enif_get_string(env, argv[0], name, MAX_NAME_LEN, ERL_NIF_LATIN1)) { logger.error(MOD_NAME, func_name, "enif get params failed"); return enif_make_badarg(env); } rados_t cluster; int err = rados_create(&cluster, name); if (err < 0) { logger.error(MOD_NAME, func_name, "Unable to create cluster handle with name: %s", name); return make_error_tuple(env, -err); } uint64_t id = new_id(); map_cluster_add(id, cluster); logger.debug(MOD_NAME, func_name, "cluster : %ld", id); return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_uint64(env, id)); }
ERL_NIF_TERM x_get_instance_id(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { const char * func_name = "x_get_instance_id()"; uint64_t id; if (!enif_get_uint64(env, argv[0], &id)) { logger.error(MOD_NAME, func_name, "enif get params failed"); return enif_make_badarg(env); } logger.debug(MOD_NAME, func_name, "cluster : %ld", id); rados_t cluster = map_cluster_get(id); if (cluster == NULL) { logger.error(MOD_NAME, func_name, "cluster non-existing : %ld", id); return enif_make_badarg(env); } uint64_t inst_id = rados_get_instance_id(cluster); return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_uint64(env, inst_id)); }
ERL_NIF_TERM x_create(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { const char * func_name = "x_create()"; logger.debug(MOD_NAME, func_name, "Entered"); logger.flush(); rados_t cluster; int err = rados_create(&cluster, NULL); if (err < 0) { logger.error(MOD_NAME, func_name, "Unable to create cluster handle"); return make_error_tuple(env, -err); } logger.debug(MOD_NAME, func_name, "cluster created"); logger.flush(); uint64_t id = new_id(); map_cluster_add(id, cluster); logger.debug(MOD_NAME, func_name, "cluster added to local map: %ld", id); logger.flush(); return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_uint64(env, id)); }
static ERL_NIF_TERM stats(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM atom; ERL_NIF_TERM ret, q1s, q2s, incrs, wakeups, duds; struct cache *c; if (!enif_is_atom(env, argv[0])) return enif_make_badarg(env); atom = argv[0]; if ((c = get_cache(atom))) { enif_rwlock_rlock(c->cache_lock); q1s = enif_make_uint64(env, c->q1.size); q2s = enif_make_uint64(env, c->q2.size); incrs = enif_make_uint64(env, __sync_fetch_and_add(&(c->incr_count), 0)); wakeups = enif_make_uint64(env, __sync_fetch_and_add(&(c->wakeups), 0)); duds = enif_make_uint64(env, __sync_fetch_and_add(&(c->dud_wakeups), 0)); enif_rwlock_runlock(c->cache_lock); ret = enif_make_tuple7(env, enif_make_uint64(env, c->hit), enif_make_uint64(env, c->miss), q1s, q2s, incrs, wakeups, duds); enif_consume_timeslice(env, 10); return ret; } else { return enif_make_atom(env, "notfound"); } }
static int test_uint64(ErlNifEnv* env, ErlNifUInt64 i1) { ErlNifUInt64 i2 = 0; ERL_NIF_TERM int_term = enif_make_uint64(env, i1); if (!enif_get_uint64(env,int_term, &i2) || i1 != i2) { fprintf(stderr, "test_ulong(%lu) ...FAILED i2=%lu\r\n", (unsigned long)i1, (unsigned long)i2); return 0; } return 1; }
ERL_NIF_TERM erlang_murmurhash64b_1_impl(ErlNifEnv* env, int, const ERL_NIF_TERM argv[]) { ErlNifBinary bin; uint64_t h; if (!check_and_unpack_data(env, argv[0], &bin)) { return enif_make_badarg(env); } h = MurmurHash64B(bin.data, bin.size, 0); return enif_make_uint64(env, h); }
static ERL_NIF_TERM diff_timestamp(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { unsigned long start = 0; unsigned long end = 0; enif_get_uint64(env, argv[0], &end); enif_get_uint64(env, argv[1], &start); uint64_t elapsed = end - start; mach_timebase_info_data_t info; uint64_t nanosecs = 0; if (mach_timebase_info (&info) == KERN_SUCCESS) { nanosecs = elapsed * info.numer / info.denom; } return enif_make_uint64(env, nanosecs); }
/** * Retrieve total of objects */ static ERL_NIF_TERM leo_mcerl_nif_items(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { lcu_cache* cache; ErlNifResourceType* pert; ErlNifUInt64 len; if (argc < 1) { return enif_make_badarg(env); } pert = (ErlNifResourceType*)enif_priv_data(env); if (!enif_get_resource(env, argv[0], pert, (void**)&cache)) { return enif_make_badarg(env); } len = (ErlNifUInt64)lcu_cache_item_size(cache); return enif_make_tuple2(env, atom_ok, enif_make_uint64(env, len)); }
ERL_NIF_TERM _hh_get_total_count(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { hh_ctx_t* ctx = NULL; ErlNifResourceType* ctx_type = get_hh_ctx_type(env); if (ctx_type == NULL || !enif_get_resource(env, argv[0], ctx_type, (void **)&ctx) || ctx->data == NULL) { return enif_make_badarg(env); } if (ctx != NULL) { return enif_make_uint64(env,ctx->data->total_count); } return make_error(env, "bad_hdr_histogram_nif_impl"); }
ERL_NIF_TERM erlang_murmurhash64a_2_impl(ErlNifEnv* env, int, const ERL_NIF_TERM argv[]) { ErlNifBinary bin; uint64_t h; uint64_t seed; if (!check_and_unpack_data(env, argv[0], &bin)) { return enif_make_badarg(env); } if (!enif_get_uint64(env, argv[1], &seed)) { return enif_make_badarg(env); } h = MurmurHash64A(bin.data, bin.size, seed); return enif_make_uint64(env, h); }
void *capture_thread(void *data) { AudioCapture *capture = (AudioCapture *)data; // enif_keep_resource(capture); detect_pcm(capture); set_volume(capture, 100); snd_pcm_open(&capture->handle, capture->pcm_name, SND_PCM_STREAM_CAPTURE, 0); if(!capture->handle) { fprintf(stderr, "No PCM!!\r\n"); exit(1); } snd_pcm_hw_params_t *hw_params; snd_pcm_hw_params_malloc(&hw_params); if(!hw_params) { fprintf(stderr, "Damn!! No hw_params\r\n"); exit(1); } snd_pcm_hw_params_any(capture->handle, hw_params); snd_pcm_hw_params_set_access(capture->handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED); snd_pcm_hw_params_set_format(capture->handle, hw_params, SND_PCM_FORMAT_S16_LE); snd_pcm_hw_params_set_rate_near(capture->handle, hw_params, &capture->sample_rate, 0); snd_pcm_hw_params_set_channels(capture->handle, hw_params, capture->channels); // int buffer_size = 16384; // int period_time = 32000; // int period_size = 1024; // snd_pcm_hw_params_set_period_time_near(capture->handle, hw_params, &period_time, 0); // snd_pcm_hw_params_set_period_size_near(capture->handle, hw_params, &period_size, 0); // snd_pcm_hw_params_set_buffer_size_near(capture->handle, hw_params, &buffer_size); // capture->last_dts = 0; fprintf(stderr, "Setting params: %p, %p\r\n", capture->handle, hw_params); snd_pcm_hw_params(capture->handle, hw_params); snd_pcm_hw_params_free(hw_params); snd_pcm_prepare(capture->handle); snd_output_t *log; snd_output_stdio_attach(&log, stderr, 0); snd_pcm_hw_params_dump(hw_params, log); fprintf(stderr, "Started capture\r\n"); char *buffer = (char *)malloc(8192); // char *ptr = buffer; int size = 0; while(capture->thread_started) { int r = snd_pcm_readi(capture->handle, buffer + size, 1024); size += r*2*capture->channels; if(size < capture->frame_size) { continue; } ErlNifEnv* env = enif_alloc_env(); ErlNifBinary frame; enif_alloc_binary(capture->frame_size, &frame); memmove(frame.data, buffer, frame.size); size -= frame.size; memmove(buffer, buffer + frame.size, size); ErlNifUInt64 dts = (uint64_t)capture->counter*1024ULL*1000 / capture->sample_rate; // fprintf(stderr, "A: %d -> %d\r\n", capture->counter, dts); if(capture->last_dts > dts) { fprintf(stderr, "Achtung! ALSA audio jump: %u, %u, %u\r\n", (unsigned)capture->counter, (unsigned)capture->last_dts, (unsigned)dts); } capture->last_dts = dts; enif_send(NULL, &capture->owner_pid, env, enif_make_tuple4(env, enif_make_atom(env, "alsa"), enif_make_resource(env, capture), enif_make_uint64(env, dts), enif_make_binary(env, &frame) ) ); enif_release_binary(&frame); enif_free_env(env); capture->counter++; } fprintf(stderr, "Capture thread stopping\r\n"); // enif_release_resource(capture); snd_pcm_close(capture->handle); return 0; }
ERL_NIF_TERM cb_mget(ErlNifEnv* env, handle_t* handle, void* obj) { mget_args_t* args = (mget_args_t*)obj; struct libcouchbase_callback_m cb; lcb_error_t ret; ERL_NIF_TERM* results; ERL_NIF_TERM returnValue; ErlNifBinary databin; ErlNifBinary key_binary; unsigned int numkeys = args->numkeys; void** keys = args->keys; size_t* nkeys = args->nkeys; int exp = args->exp; int lock = args->lock; int i = 0; cb.currKey = 0; cb.ret = malloc(sizeof(struct libcouchbase_callback*) * numkeys); const lcb_get_cmd_t* commands[numkeys]; i = 0; for (; i < numkeys; i++) { lcb_get_cmd_t *get = calloc(1, sizeof(*get)); get->version = 0; get->v.v0.key = keys[i]; get->v.v0.nkey = nkeys[i]; get->v.v0.exptime = exp; get->v.v0.lock = lock; commands[i] = get; } ret = lcb_get(handle->instance, &cb, numkeys, commands); if (ret != LCB_SUCCESS) { return return_lcb_error(env, ret); } lcb_wait(handle->instance); results = malloc(sizeof(ERL_NIF_TERM) * numkeys); i = 0; for(; i < numkeys; i++) { enif_alloc_binary(cb.ret[i]->nkey, &key_binary); memcpy(key_binary.data, cb.ret[i]->key, cb.ret[i]->nkey); if (cb.ret[i]->error == LCB_SUCCESS) { enif_alloc_binary(cb.ret[i]->size, &databin); memcpy(databin.data, cb.ret[i]->data, cb.ret[i]->size); results[i] = enif_make_tuple4(env, enif_make_uint64(env, cb.ret[i]->cas), enif_make_int(env, cb.ret[i]->flag), enif_make_binary(env, &key_binary), enif_make_binary(env, &databin)); free(cb.ret[i]->data); } else { results[i] = enif_make_tuple2(env, enif_make_binary(env, &key_binary), return_lcb_error(env, cb.ret[i]->error)); } free(cb.ret[i]->key); free(cb.ret[i]); free(keys[i]); free((lcb_get_cmd_t*) commands[i]); } returnValue = enif_make_list_from_array(env, results, numkeys); free(results); free(cb.ret); free(keys); free(nkeys); return enif_make_tuple2(env, A_OK(env), returnValue); }
// 1. Figure out actor index, create one if it does not exist // 2. check info for evnum/evterm data int sqlite3WalOpen(sqlite3_vfs *pVfs, sqlite3_file *pDbFd, const char *zWalName,int bNoShm, i64 mxWalSize, Wal **ppWal) { MDB_val key, data; int rc; #if ATOMIC db_thread *thr = g_tsd_thread; db_connection *conn = g_tsd_conn; #else db_thread* thr = enif_tsd_get(g_tsd_thread); db_connection* conn = enif_tsd_get(g_tsd_conn); #endif mdbinf * const mdb = &thr->mdb; Wal *pWal = &conn->wal; MDB_dbi actorsdb, infodb; MDB_txn *txn = mdb->txn; int offset = 0, cutoff = 0, nmLen = 0; actorsdb = mdb->actorsdb; infodb = mdb->infodb; if (zWalName[0] == '/') offset = 1; nmLen = strlen(zWalName+offset); if (zWalName[offset+nmLen-1] == 'l' && zWalName[offset+nmLen-2] == 'a' && zWalName[offset+nmLen-3] == 'w' && zWalName[offset+nmLen-4] == '-') cutoff = 4; DBG("Wal name=%s %lld",zWalName,(i64)txn); // shorten size to ignore "-wal" at the end key.mv_size = nmLen-cutoff; key.mv_data = (void*)(zWalName+offset);//thr->curConn->dbpath; rc = mdb_get(txn,actorsdb,&key,&data); // This is new actor, assign an index if (rc == MDB_NOTFOUND) { i64 index = 0; // MDB_val key1 = {1,(void*)"?"}; #ifndef _TESTAPP_ qitem *item; db_command *cmd; item = command_create(conn->wthreadind,-1,g_pd); cmd = (db_command*)item->cmd; cmd->type = cmd_actorsdb_add; #if ATOMIC index = atomic_fetch_add_explicit(&g_pd->actorIndexes[thr->nEnv], 1, memory_order_relaxed); #else enif_mutex_lock(g_pd->actorIndexesMtx[thr->nEnv]); index = g_pd->actorIndexes[thr->nEnv]++; enif_mutex_unlock(g_pd->actorIndexesMtx[thr->nEnv]); #endif pWal->index = index; cmd->arg = enif_make_string(item->env,zWalName,ERL_NIF_LATIN1); cmd->arg1 = enif_make_uint64(item->env, index); push_command(conn->wthreadind, -1, g_pd, item); #else if (thr->isreadonly) { return SQLITE_ERROR; } else { #if ATOMIC char filename[MAX_PATHNAME]; sprintf(filename,"%.*s",(int)(nmLen-cutoff),zWalName+offset); index = atomic_fetch_add_explicit(&g_pd->actorIndexes[thr->nEnv], 1, memory_order_relaxed); pWal->index = index; if (register_actor(index, filename) != SQLITE_OK) return SQLITE_ERROR; #else return SQLITE_ERROR; #endif } #endif } // Actor exists, read evnum/evterm info else if (rc == MDB_SUCCESS) { // data contains index key = data; pWal->index = *(i64*)data.mv_data; DBG("Actor at index %lld",pWal->index); rc = mdb_get(txn,infodb,&key,&data); if (rc == MDB_SUCCESS) { if (*(u8*)data.mv_data != 1) { return SQLITE_ERROR; } memcpy(&pWal->firstCompleteTerm, ((u8*)data.mv_data)+1, sizeof(u64)); memcpy(&pWal->firstCompleteEvnum,((u8*)data.mv_data)+1+sizeof(u64), sizeof(u64)); memcpy(&pWal->lastCompleteTerm, ((u8*)data.mv_data)+1+sizeof(u64)*2, sizeof(u64)); memcpy(&pWal->lastCompleteEvnum, ((u8*)data.mv_data)+1+sizeof(u64)*3, sizeof(u64)); memcpy(&pWal->inProgressTerm, ((u8*)data.mv_data)+1+sizeof(u64)*4, sizeof(u64)); memcpy(&pWal->inProgressEvnum, ((u8*)data.mv_data)+1+sizeof(u64)*5, sizeof(u64)); memcpy(&pWal->mxPage, ((u8*)data.mv_data)+1+sizeof(u64)*6, sizeof(u32)); memcpy(&pWal->allPages, ((u8*)data.mv_data)+1+sizeof(u64)*6+sizeof(u32),sizeof(u32)); pWal->readSafeTerm = pWal->lastCompleteTerm; pWal->readSafeEvnum = pWal->lastCompleteEvnum; pWal->readSafeMxPage = pWal->mxPage; // if (pWal->inProgressTerm != 0) // { // doundo(pWal,NULL,NULL,1); // } } else if (rc == MDB_NOTFOUND) { // DBG("Info for actor not found")); } } else { DBG("Error open=%d",rc); thr->forceCommit = 2; return SQLITE_ERROR; } conn->changed = 1; if (ppWal != NULL) (*ppWal) = pWal; return SQLITE_OK; }
static ERL_NIF_TERM get_priv_data_ptr(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ADD_CALL("get_priv_data_ptr"); return enif_make_uint64(env, (ErlNifUInt64)priv_data(env)); }
static ERL_NIF_TERM timestamp(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { unsigned long now = (unsigned long) mach_absolute_time(); return enif_make_uint64(env, now); }