ERL_NIF_TERM parse_histogram_option(ErlNifEnv* env, ERL_NIF_TERM item,
histogram_handle& handle)
{
int arity;
const ERL_NIF_TERM* option;
if (enif_get_tuple(env, item, &arity, &option))
{
if (option[0] == ATOM_SIZE)
{
unsigned long sample_size;
if (enif_get_ulong(env, option[1], &sample_size))
{
handle.size = sample_size;
}
}
if (option[0] == ATOM_WINDOW_WIDTH)
{
unsigned long window_width;
if (enif_get_ulong(env, option[1], &window_width))
{
handle.width = window_width;
}
}
}
return ATOM_OK;
}
//pteracuda_nifs:gemv(Ctx, _m, _n, _alpha, A, X, _betha, Y),
ERL_NIF_TERM pteracuda_nifs_gemv(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
PCudaContextRef *ctxRef;
PCudaBufferRef *ref_A, *ref_X, *ref_Y;
unsigned long transpose;
unsigned long m, n;
double alpha, beta;
if (argc != 9 ||
!enif_get_resource(env, argv[0], pteracuda_context_resource, (void **) &ctxRef) ||
!enif_get_ulong(env, argv[1], &transpose)||
!enif_get_ulong(env, argv[2], &m)||
!enif_get_ulong(env, argv[3], &n)||
!enif_get_double(env, argv[4], &alpha)||
!enif_get_resource(env, argv[5], pteracuda_buffer_resource, (void **) &ref_A) ||
!enif_get_resource(env, argv[6], pteracuda_buffer_resource, (void **) &ref_X)||
!enif_get_double(env, argv[7], &beta)||
!enif_get_resource(env, argv[8], pteracuda_buffer_resource, (void **) &ref_Y)) {
return enif_make_badarg(env);
}
if(((PCudaMatrixFloatBuffer*)ref_A->buffer)->rows() != m || ((PCudaMatrixFloatBuffer*)ref_A->buffer)->cols() != n){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix A dimensions do not match m,n parameters"));
}
cuCtxSetCurrent(ctxRef->ctx);
pcuda_gemv(transpose, m, n, alpha, ((PCudaMatrixFloatBuffer *)ref_A->buffer)->get_data(), ((PCudaFloatBuffer *)ref_X->buffer)->get_data(), beta, ((PCudaFloatBuffer *)ref_Y->buffer)->get_data());
return ATOM_OK;
}
ERL_NIF_TERM pteracuda_ml_gd_learn(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
PCudaContextRef *ctxRef;
PCudaBufferRef *ref_Theta, *ref_X, *ref_Y;
unsigned long num_features;
unsigned long num_samples;
unsigned long iterations;
double learning_rate;
if (argc != 8 || !enif_get_resource(env, argv[0], pteracuda_context_resource, (void **) &ctxRef) ||
!enif_get_resource(env, argv[1], pteracuda_buffer_resource, (void **) &ref_Theta) ||
!enif_get_resource(env, argv[2], pteracuda_buffer_resource, (void **) &ref_X) ||
!enif_get_resource(env, argv[3], pteracuda_buffer_resource, (void **) &ref_Y) ||
!enif_get_ulong(env, argv[4], &num_features) ||
!enif_get_ulong(env, argv[5], &num_samples) ||
!enif_get_double(env, argv[6], &learning_rate) ||
!enif_get_ulong(env, argv[7], &iterations)
) {
return enif_make_badarg(env);
}
cuCtxSetCurrent(ctxRef->ctx);
pcuda_gd_learn(((PCudaFloatBuffer*)ref_Theta->buffer)->get_data(), ((PCudaFloatBuffer*)ref_X->buffer)->get_data(), ((PCudaFloatBuffer*)ref_Y->buffer)->get_data(), num_features, num_samples, (float)learning_rate, iterations);
return ATOM_OK;
}
///////////////////Matrix operations
// C(m,n) = A(m,k) * B(k,n)
//gemm(_Ctx, _transpose_op_A, _transpose_op_B, _m, _n, _k, _alpha, _A, _B, _beta, _C )
ERL_NIF_TERM pteracuda_nifs_gemm(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
PCudaContextRef *ctxRef;
PCudaBufferRef *ref_A, *ref_B, *ref_C;
unsigned long transpose_a, transpose_b;
unsigned long m, n, k;
double alpha, beta;
if (argc != 11 || !enif_get_resource(env, argv[0], pteracuda_context_resource, (void **) &ctxRef) ||
!enif_get_ulong(env, argv[1], &transpose_a)||
!enif_get_ulong(env, argv[2], &transpose_b)||
!enif_get_ulong(env, argv[3], &m)||
!enif_get_ulong(env, argv[4], &n)||
!enif_get_ulong(env, argv[5], &k)||
!enif_get_double(env, argv[6], &alpha)||
!enif_get_resource(env, argv[7], pteracuda_buffer_resource, (void **) &ref_A) ||
!enif_get_resource(env, argv[8], pteracuda_buffer_resource, (void **) &ref_B)||
!enif_get_double(env, argv[9], &beta)||
!enif_get_resource(env, argv[10], pteracuda_buffer_resource, (void **) &ref_C)
) {
return enif_make_badarg(env);
}
if(transpose_a == CUBLAS_OP_N){
if(((PCudaMatrixFloatBuffer*)ref_A->buffer)->rows() != m || ((PCudaMatrixFloatBuffer*)ref_A->buffer)->cols() != k){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix A dimensions do not match m,k parameters"));
}
}else{
if(((PCudaMatrixFloatBuffer*)ref_A->buffer)->rows() != k || ((PCudaMatrixFloatBuffer*)ref_A->buffer)->cols() != n){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix A dimensions do not match m,k parameters"));
}
}
if(transpose_b == CUBLAS_OP_N){
if(((PCudaMatrixFloatBuffer*)ref_B->buffer)->rows() != k || ((PCudaMatrixFloatBuffer*)ref_B->buffer)->cols() != n){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix B dimensions do not match k,n parameters"));
}
}else{
if(((PCudaMatrixFloatBuffer*)ref_B->buffer)->rows() != n || ((PCudaMatrixFloatBuffer*)ref_B->buffer)->cols() != k){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix B dimensions do not match k,n parameters"));
}
}
if(((PCudaMatrixFloatBuffer*)ref_C->buffer)->rows() != m || ((PCudaMatrixFloatBuffer*)ref_C->buffer)->cols() != n){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix C dimensions do not match m,n parameters"));
}
cuCtxSetCurrent(ctxRef->ctx);
//pcuda_mmul(((PCudaMatrixFloatBuffer*)ref_A->buffer)->get_data(), ((PCudaMatrixFloatBuffer*)ref_B->buffer)->get_data(), ((PCudaMatrixFloatBuffer*)ref_C->buffer)->get_data(), m, k, n);
pcuda_gemm(transpose_a, transpose_b, m, n, k, alpha, ((PCudaMatrixFloatBuffer*)ref_A->buffer)->get_data(), ((PCudaMatrixFloatBuffer*)ref_B->buffer)->get_data(), beta, ((PCudaMatrixFloatBuffer*)ref_C->buffer)->get_data());
return ATOM_OK;
}
static ERL_NIF_TERM emmap_pread(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
unsigned long pos, bytes;
mhandle *handle;
if (argc==3
&& enif_get_resource(env, argv[0], MMAP_RESOURCE, (void**)&handle)
&& enif_get_ulong(env, argv[1], &pos)
&& enif_get_ulong(env, argv[2], &bytes)
&& pos >= 0
&& bytes >= 0
&& (pos + bytes) <= handle->len
)
{
ErlNifBinary bin;
if ((handle->prot & PROT_READ) == 0) {
return make_error_tuple(env, EACCES);
}
// if this mmap is direct, use a resource binary
if (handle->direct) {
ERL_NIF_TERM res = enif_make_resource_binary
(env, handle, (void*) (((char*)handle->mem) + pos), bytes);
return enif_make_tuple2(env, ATOM_OK, res);
} else {
// When it is non-direct, we have to allocate the binary
if (!enif_alloc_binary((size_t) bytes, &bin)) {
return make_error_tuple(env, ENOMEM);
}
R_LOCK;
if (handle->closed) {
R_UNLOCK;
return enif_make_badarg(env);
}
memcpy(bin.data, (void*) (((char*)handle->mem) + pos), bytes);
R_UNLOCK;
ERL_NIF_TERM res = enif_make_binary(env, &bin);
return enif_make_tuple2(env, ATOM_OK, res);
}
}
else
{
return enif_make_badarg(env);
}
}
/* 0: socket, 1: length, 2: flags, 3: struct sockaddr length */
static ERL_NIF_TERM
nif_recvfrom(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int sockfd = -1;
unsigned long len = 0;
unsigned long salen = 0;
int flags = 0;
ErlNifBinary buf = {0};
ErlNifBinary sa = {0};
ssize_t bufsz = 0;
if (!enif_get_int(env, argv[0], &sockfd))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &len))
return enif_make_badarg(env);
if (!enif_get_int(env, argv[2], &flags))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[3], &salen))
return enif_make_badarg(env);
if (!enif_alloc_binary(len, &buf))
return error_tuple(env, ENOMEM);
if (!enif_alloc_binary(salen, &sa))
return error_tuple(env, ENOMEM);
if ( (bufsz = recvfrom(sockfd, buf.data, buf.size, flags,
(sa.size == 0 ? NULL : (struct sockaddr *)sa.data),
(socklen_t *)&salen)) == -1) {
enif_release_binary(&buf);
enif_release_binary(&sa);
switch (errno) {
case EAGAIN:
case EINTR:
return enif_make_tuple2(env, atom_error, atom_eagain);
default:
return error_tuple(env, errno);
}
}
PROCKET_REALLOC(buf, bufsz);
PROCKET_REALLOC(sa, salen);
return enif_make_tuple3(env, atom_ok, enif_make_binary(env, &buf),
enif_make_binary(env, &sa));
}
static ERL_NIF_TERM emmap_pwrite(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
unsigned long pos;
mhandle *handle;
if (argc==3
&& enif_get_resource(env, argv[0], MMAP_RESOURCE, (void**)&handle)
&& enif_get_ulong(env, argv[1], &pos)
&& enif_inspect_binary(env, argv[2], &bin)
&& pos >= 0
&& (pos + bin.size) <= handle->len
)
{
if ((handle->prot & PROT_WRITE) == 0) {
return make_error_tuple(env, EACCES);
}
RW_LOCK;
if (handle->closed) {
RW_UNLOCK;
return enif_make_badarg(env);
} else {
memcpy((void*) (((char*)handle->mem) + pos), bin.data, bin.size);
RW_UNLOCK;
}
return ATOM_OK;
}
else
{
return enif_make_badarg(env);
}
}
static ERL_NIF_TERM
nif_read(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
SRLY_STATE *sp = NULL;
unsigned long len = 0;
ErlNifBinary buf = {0};
ssize_t bufsz = 0;
if (!enif_get_resource(env, argv[0], SRLY_STATE_RESOURCE, (void **)&sp))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &len))
return enif_make_badarg(env);
if (!enif_alloc_binary(len, &buf))
return error_tuple(env, ENOMEM);
if ( (bufsz = read(sp->fd, buf.data, buf.size)) < 0) {
int err = errno;
enif_release_binary(&buf);
return error_tuple(env, err);
}
if (bufsz < buf.size && !enif_realloc_binary(&buf, bufsz)) {
enif_release_binary(&buf);
return error_tuple(env, ENOMEM);
}
return enif_make_tuple2(env, atom_ok, enif_make_binary(env, &buf));
}
static ERL_NIF_TERM
nif_ioctl(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
SRLY_STATE *sp = NULL;
unsigned long req = 0;
ErlNifBinary arg = {0};
if (!enif_get_resource(env, argv[0], SRLY_STATE_RESOURCE, (void **)&sp))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &req))
return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[2], &arg))
return enif_make_badarg(env);
/* Make the binary mutable for in/out args */
if (!enif_realloc_binary(&arg, arg.size))
return error_tuple(env, ENOMEM);
if (ioctl(sp->fd, req, arg.data) < 0)
return error_tuple(env, errno);
return enif_make_tuple2(env,
atom_ok,
enif_make_binary(env, &arg));
}
/* 0: socket, 1: length */
static ERL_NIF_TERM
nif_read(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int fd = -1;
unsigned long len = 0;
ErlNifBinary buf = {0};
ssize_t bufsz = 0;
if (!enif_get_int(env, argv[0], &fd))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &len))
return enif_make_badarg(env);
if (!enif_alloc_binary(len, &buf))
return error_tuple(env, ENOMEM);
if ( (bufsz = read(fd, buf.data, buf.size)) == -1) {
int err = errno;
enif_release_binary(&buf);
switch (err) {
case EAGAIN:
case EINTR:
return enif_make_tuple2(env, atom_error, atom_eagain);
default:
return error_tuple(env, err);
}
}
PROCKET_REALLOC(buf, bufsz);
return enif_make_tuple2(env, atom_ok, enif_make_binary(env, &buf));
}
static ERL_NIF_TERM bf_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary state;
char key[1024];
char salt[1024];
uint8_t key_len;
unsigned long key_len_arg;
uint8_t salt_len;
if (argc != 3 || !enif_get_string(env, argv[0], key, sizeof(key), ERL_NIF_LATIN1) ||
!enif_get_ulong(env, argv[1], &key_len_arg) ||
!enif_get_string(env, argv[2], salt, sizeof(salt), ERL_NIF_LATIN1))
return enif_make_badarg(env);
key_len = key_len_arg;
salt_len = BCRYPT_MAXSALT;
if (!enif_alloc_binary(sizeof(blf_ctx), &state))
return enif_make_badarg(env);
Blowfish_initstate((blf_ctx *) state.data);
Blowfish_expandstate((blf_ctx *) state.data, (uint8_t *) salt,
salt_len, (uint8_t *) key, key_len);
return enif_make_binary(env, &state);
}
static ERL_NIF_TERM trace_garbage_collection(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
lttng_decl_procbuf(pid);
ERL_NIF_TERM gci, tup;
const ERL_NIF_TERM *vals;
int arity;
unsigned long ohbsz, nhbsz, size;
ASSERT(argc == 6);
/* Assume gc info order does not change */
gci = argv[3];
/* get reclaimed or need */
enif_get_list_cell(env, gci, &tup, &gci);
enif_get_tuple(env, tup, &arity, &vals);
ASSERT(arity == 2);
enif_get_ulong(env, vals[1], &size);
/* get old heap block size */
enif_get_list_cell(env, gci, &tup, &gci);
enif_get_tuple(env, tup, &arity, &vals);
ASSERT(arity == 2);
ASSERT(vals[0] == atom_old_heap_block_size);
enif_get_ulong(env, vals[1], &ohbsz);
/* get new heap block size */
enif_get_list_cell(env, gci, &tup, &gci);
enif_get_tuple(env, tup, &arity, &vals);
ASSERT(arity == 2);
ASSERT(vals[0] == atom_heap_block_size);
enif_get_ulong(env, vals[1], &nhbsz);
lttng_pid_to_str(argv[2], pid);
if (argv[0] == atom_gc_minor_start) {
LTTNG4(gc_minor_start, pid, size, nhbsz, ohbsz);
} else if (argv[0] == atom_gc_minor_end) {
LTTNG4(gc_minor_end, pid, size, nhbsz, ohbsz);
} else if (argv[0] == atom_gc_major_start) {
LTTNG4(gc_major_start, pid, size, nhbsz, ohbsz);
} else if (argv[0] == atom_gc_major_end) {
LTTNG4(gc_major_end, pid, size, nhbsz, ohbsz);
}
return atom_ok;
}
static
ERL_NIF_TERM exmagick_crop (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
Image* cropped_image;
RectangleInfo rect;
exm_resource_t *resource;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
if (resource->image == NULL)
{ EXM_FAIL(ehandler, "image not loaded"); }
/* build rectangle */
if (0 == enif_get_long(env, argv[1], &rect.x))
{ EXM_FAIL(ehandler, "x0: bad argument"); }
if (0 == enif_get_long(env, argv[2], &rect.y))
{ EXM_FAIL(ehandler, "y0: bad argument"); }
if (0 == enif_get_ulong(env, argv[3], &rect.width))
{ EXM_FAIL(ehandler, "width: bad argument"); }
if (0 == enif_get_ulong(env, argv[4], &rect.height))
{ EXM_FAIL(ehandler, "height: bad argument"); }
/* actually crops image */
cropped_image = CropImage(resource->image, &rect, &resource->e_info);
if (cropped_image == NULL)
{
CatchException(&resource->e_info);
EXM_FAIL(ehandler, resource->e_info.reason);
}
DestroyImage(resource->image);
resource->image = cropped_image;
return(enif_make_tuple2(env, enif_make_atom(env, "ok"), argv[0]));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
static int test_ulong(ErlNifEnv* env, unsigned long i1)
{
unsigned long i2 = 0;
ERL_NIF_TERM int_term = enif_make_ulong(env, i1);
if (!enif_get_ulong(env,int_term, &i2) || i1 != i2) {
fprintf(stderr, "test_ulong(%lu) ...FAILED i2=%lu\r\n", i1, i2);
return 0;
}
return 1;
}
static ERL_NIF_TERM setup_2(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
unsigned int channel;
unsigned long speed;
int error;
if (argc != 2 || !enif_is_number(env, argv[0]) || !enif_is_number(env, argv[1])) {
return enif_make_badarg(env);
}
if (!enif_get_uint(env, argv[0], &channel)) {
return enif_make_badarg(env);
}
if (!enif_get_ulong(env, argv[1], &speed)) {
return enif_make_badarg(env);
}
if (speed < 500000 || speed > 32000000) {
return enif_make_badarg(env);
}
switch (channel) {
case 0:
if (state0.fd != 0) {
return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "channel already opened", ERL_NIF_LATIN1));
}
else {
state0.env = env;
state0.fd = wiringPiSPISetup(channel, speed);
if (state0.fd == 0) {
error = errno;
return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, error));
}
else {
return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_int(env, channel));
}
}
break;
case 1:
if (state1.fd != 0) {
return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "channel already opened", ERL_NIF_LATIN1));
}
else {
state1.env = env;
state1.fd = wiringPiSPISetup(channel, speed);
if (state1.fd == 0) {
error = errno;
return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, error));
}
else {
return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_int(env, channel));
}
}
break;
default:
return enif_make_badarg(env);
}
}
//invalid vector<T> subscript Check the matrix dimensions.
ERL_NIF_TERM pteracuda_nifs_buffer_delete(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
PCudaBufferRef *ref;
unsigned long position;
if (argc != 2 || !enif_get_resource(env, argv[0], pteracuda_buffer_resource, (void **) &ref) ||
!enif_get_ulong(env, argv[1], &position)) {
return enif_make_badarg(env);
}
if (position > ref->buffer->size()) {
return ATOM_ERROR;
}
ref->buffer->delete_at(position);
return ATOM_OK;
}
static ERL_NIF_TERM
mmap_pread(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
ERL_NIF_TERM sub;
unsigned long offset, size;
if(!enif_inspect_binary(env, argv[0], &bin)) {
return enif_make_badarg(env);
}
if(!enif_get_ulong(env, argv[1], &offset)) {
return enif_make_badarg(env);
}
if(!enif_get_ulong(env, argv[2], &size)) {
return enif_make_badarg(env);
}
if((sub = enif_make_sub_binary(env, argv[0], offset, size))) {
return enif_make_tuple2(env, enif_make_atom(env, "ok"), sub);
}
return enif_make_ulong(env, 42);
}
static ERL_NIF_TERM hold_nif_mod_priv_data(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
PrivData* data = (PrivData*) enif_priv_data(env);
unsigned long ptr_as_ulong;
if (!enif_get_ulong(env,argv[0],&ptr_as_ulong)) {
return enif_make_badarg(env);
}
if (data->nif_mod != NULL) {
NifModPrivData_release(data->nif_mod);
}
data->nif_mod = (NifModPrivData*) ptr_as_ulong;
return enif_make_int(env,++(data->nif_mod->ref_cnt));
}
unsigned long
fetch_ulong(ErlNifEnv* env, ERL_NIF_TERM* items) {
ERL_NIF_TERM head;
// Fetch head if possible
if (! enif_get_list_cell(env, *items, &head, items)) return 0;
unsigned long i;
double d;
if(enif_get_ulong(env, head, &i)) return i;
if(enif_get_double(env, head, &d)) return (unsigned long) abs(d);
return 0;
};
static ERL_NIF_TERM cpool_new(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
ERL_NIF_TERM result;
unsigned long schedulers = 0;
if (enif_get_ulong(env, argv[0], &schedulers) == 0) {
return enif_make_badarg(env);
}
cpool_handle* handle = (cpool_handle*)enif_alloc_resource(cpool_RESOURCE, sizeof(cpool_handle));
handle->pool = new CPool(schedulers);
result = enif_make_resource(env, handle);
enif_release_resource(handle);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), result);
}
static ERL_NIF_TERM emmap_read(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
mhandle *handle;
unsigned long bytes;
if (enif_get_resource(env, argv[0], MMAP_RESOURCE, (void**)&handle)
&& enif_get_ulong(env, argv[1], &bytes)) {
RW_LOCK;
if (handle->position == handle->len) {
RW_UNLOCK;
return ATOM_EOF;
}
unsigned long new_pos = handle->position + bytes;
if (new_pos > handle->len) { new_pos = handle->len; }
long size = new_pos - handle->position;
long start = handle->position;
handle->position = new_pos;
RW_UNLOCK;
if (handle->direct) {
ERL_NIF_TERM res = enif_make_resource_binary
(env, handle, (void*) (((char*)handle->mem) + start), size);
return enif_make_tuple2(env, ATOM_OK, res);
} else {
ErlNifBinary bin;
// When it is non-direct, we have to allocate the binary
if (!enif_alloc_binary((size_t) size, &bin)) {
return make_error_tuple(env, ENOMEM);
}
memcpy(bin.data, (void*) (((char*)handle->mem) + start), size);
ERL_NIF_TERM res = enif_make_binary(env, &bin);
return enif_make_tuple2(env, ATOM_OK, res);
}
} else {
return enif_make_badarg(env);
}
}
ERL_NIF_TERM meter_update(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
meter_handle* handle;
unsigned long sample;
if (enif_get_resource(env,argv[0],meter_RESOURCE,(void**)&handle) &&
enif_get_ulong(env, argv[1], &sample))
{
pthread_mutex_lock(&(handle->m));
handle->p->mark(sample);
pthread_mutex_unlock(&(handle->m));
return ATOM_OK;
}
else
{
return enif_make_badarg(env);
}
}
ERL_NIF_TERM parse_meter_option(ErlNifEnv* env, ERL_NIF_TERM item,
meter_handle& handle)
{
int arity;
const ERL_NIF_TERM* option;
if (enif_get_tuple(env, item, &arity, &option))
{
if (option[0] == ATOM_TICK_INTERVAL)
{
unsigned long tick_interval;
if (enif_get_ulong(env, option[1], &tick_interval))
{
handle.tick_interval = tick_interval;
}
}
}
return ATOM_OK;
}
static ERL_NIF_TERM cpool_next(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
ERL_NIF_TERM result;
cpool_handle* handle = NULL;
unsigned long iterator;
if (enif_get_resource(env, argv[0], cpool_RESOURCE, (void**)&handle) == 0) {
return enif_make_badarg(env);
}
if (enif_get_ulong(env, argv[1], &iterator) == 0) {
return enif_make_badarg(env);
}
// Reduce iterator to account for zero indice
--iterator;
result = handle->pool->Next(env, iterator);
return result;
}
ERL_NIF_TERM
geef_index_nth(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
size_t nth;
geef_index *index;
const git_index_entry *entry;
if (!enif_get_resource(env, argv[0], geef_index_type, (void **) &index))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &nth))
return enif_make_badarg(env);
entry = git_index_get_byindex(index->index, nth);
if (entry == NULL)
return geef_error(env);
return entry_to_term(env, entry);
}
static inline int push_nif_number(lua_State* lua, ERL_NIF_TERM message, ErlNifEnv* env)
{
const int top = lua_gettop(lua);
int result = 0;
int intval;
unsigned int uintval;
long longval;
unsigned long ulongval;
double doubleval;
luaL_checkstack(lua, 1, ERROR_STACK_MESSAGE);
if(enif_get_int(env, message, &intval))
{
lua_pushnumber(lua, (double) intval);
result = 1;
}
else if(enif_get_uint(env, message, &uintval))
{
lua_pushnumber(lua, (double) uintval);
result = 1;
}
else if(enif_get_long(env, message, &longval))
{
lua_pushnumber(lua, (double) longval);
result = 1;
}
else if(enif_get_ulong(env, message, &ulongval))
{
lua_pushnumber(lua, (double) ulongval);
result = 1;
}
else if(enif_get_double(env, message, &doubleval))
{
lua_pushnumber(lua, (double) doubleval);
result = 1;
}
assert(lua_gettop(lua) == top+result);
return result;
}
/* 0: (int)socket descriptor, 1: (int)device dependent request,
* 2: (char *)argp, pointer to structure | int
*/
static ERL_NIF_TERM
nif_ioctl(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int s = -1;
unsigned long req = 0;
ErlNifBinary arg = {0};
int n = 0;
if (!enif_get_int(env, argv[0], &s))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &req))
return enif_make_badarg(env);
if (enif_inspect_binary(env, argv[2], &arg)) {
/* Make the binary mutable */
if (!enif_realloc_binary(&arg, arg.size))
return error_tuple(env, ENOMEM);
if (ioctl(s, req, arg.data) < 0)
return error_tuple(env, errno);
}
else if (enif_get_int(env, argv[2], &n)) {
/* XXX integer args allow the caller to
* XXX pass in arbitrary pointers */
if (ioctl(s, req, n) < 0)
return error_tuple(env, errno);
/* return an empty binary */
if (!enif_alloc_binary(0, &arg))
return error_tuple(env, ENOMEM);
}
else
return enif_make_badarg(env);
return enif_make_tuple2(env,
atom_ok,
enif_make_binary(env, &arg));
}
/* 0: socket, 1: struct sockaddr length */
static ERL_NIF_TERM
nif_accept(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int l = -1;
int s = -1;
unsigned long salen = 0;
ErlNifBinary sa = {0};
int flags = 0;
if (!enif_get_int(env, argv[0], &l))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &salen))
return enif_make_badarg(env);
if (!enif_alloc_binary(salen, &sa))
return error_tuple(env, ENOMEM);
s = accept(l, (sa.size == 0 ? NULL : (struct sockaddr *)sa.data), (socklen_t *)&salen);
if (s < 0)
return error_tuple(env, errno);
flags = fcntl(s, F_GETFL, 0);
if (flags < 0)
return error_tuple(env, errno);
if (fcntl(s, F_SETFL, flags|O_NONBLOCK) < 0)
return error_tuple(env, errno);
PROCKET_REALLOC(sa, salen);
return enif_make_tuple3(env,
atom_ok,
enif_make_int(env, s),
enif_make_binary(env, &sa));
}
ERL_NIF_TERM pteracuda_nifs_new_float_buffer(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
unsigned long size;
PCudaBufferRef *ref = (PCudaBufferRef *) enif_alloc_resource(pteracuda_buffer_resource, sizeof(PCudaBufferRef));
if (!ref) {
return OOM_ERROR;
}
if (argc == 1){
if(enif_get_ulong(env, argv[0], &size)) {
ref->buffer = new PCudaFloatBuffer(size);
}else{
return enif_make_badarg(env);
}
}else{
ref->buffer = new PCudaFloatBuffer();
}
ref->destroyed = false;
ERL_NIF_TERM res = enif_make_resource(env, ref);
enif_release_resource(ref);
return enif_make_tuple2(env, ATOM_OK, res);
}
static ERL_NIF_TERM erl_encode_salt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary csalt, bin;
unsigned long log_rounds;
if (!enif_inspect_binary(env, argv[0], &csalt) || 16 != csalt.size) {
return enif_make_badarg(env);
}
if (!enif_get_ulong(env, argv[1], &log_rounds)) {
enif_release_binary(env, &csalt);
return enif_make_badarg(env);
}
if (!enif_alloc_binary(env, 64, &bin)) {
enif_release_binary(env, &csalt);
return enif_make_badarg(env);
}
encode_salt((char *)bin.data, (u_int8_t*)csalt.data, csalt.size, log_rounds);
enif_release_binary(env, &csalt);
return enif_make_string(env, (char *)bin.data, ERL_NIF_LATIN1);
}
