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