You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
263 lines
8.2 KiB
263 lines
8.2 KiB
#include <string.h>
|
|
#include "erl_nif.h"
|
|
#include "concurrentqueue.h"
|
|
#include <vector>
|
|
|
|
struct NifTraits : public moodycamel::ConcurrentQueueDefaultTraits {
|
|
static const size_t BLOCK_SIZE = 16;
|
|
static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = 16;
|
|
static const size_t EXPLICIT_INITIAL_INDEX_SIZE = 8;
|
|
static const size_t IMPLICIT_INITIAL_INDEX_SIZE = 8;
|
|
static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = 16;
|
|
static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = 256;
|
|
|
|
static inline void *malloc(std::size_t size) { return enif_alloc(size); }
|
|
|
|
static inline void free(void *ptr) { enif_free(ptr); }
|
|
};
|
|
|
|
using lfqIns = moodycamel::ConcurrentQueue<ErlNifBinary, NifTraits> *;
|
|
|
|
const size_t BulkDelCnt = 200;
|
|
|
|
ERL_NIF_TERM atomOk;
|
|
ERL_NIF_TERM atomError;
|
|
ERL_NIF_TERM atomNewErr;
|
|
ERL_NIF_TERM atomTrue;
|
|
ERL_NIF_TERM atomFalse;
|
|
ERL_NIF_TERM atomEmpty;
|
|
|
|
void eLfqFree(ErlNifEnv *, void *obj) {
|
|
lfqIns *ObjIns = static_cast<lfqIns *>(obj);
|
|
|
|
if (NULL != ObjIns && NULL != *ObjIns) {
|
|
std::vector <ErlNifBinary> TermBinList(BulkDelCnt);
|
|
size_t OutSize;
|
|
do{
|
|
OutSize = (*ObjIns)->try_dequeue_bulk(TermBinList.begin(), TermBinList.size());
|
|
for (int i = OutSize - 1; i >= 0; --i) {
|
|
enif_release_binary(&TermBinList[i]);
|
|
}
|
|
}while(OutSize >= BulkDelCnt);
|
|
|
|
delete (*ObjIns);
|
|
*ObjIns = NULL;
|
|
}
|
|
}
|
|
|
|
int nifLoad(ErlNifEnv *env, void **priv_data, ERL_NIF_TERM) {
|
|
ErlNifResourceFlags flags = static_cast<ErlNifResourceFlags>(ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER);
|
|
ErlNifResourceType *ResIns = NULL;
|
|
ResIns = enif_open_resource_type(env, NULL, "eLfqRes", eLfqFree, flags, NULL);
|
|
if (NULL == ResIns)
|
|
return -1;
|
|
|
|
*priv_data = ResIns;
|
|
atomOk = enif_make_atom(env, "ok");
|
|
atomTrue = enif_make_atom(env, "true");
|
|
atomFalse = enif_make_atom(env, "false");
|
|
atomError = enif_make_atom(env, "lfq_error");
|
|
atomEmpty = enif_make_atom(env, "lfq_empty");
|
|
atomNewErr = enif_make_atom(env, "error");
|
|
return 0;
|
|
}
|
|
|
|
int nifUpgrade(ErlNifEnv *env, void **priv_data, void **, ERL_NIF_TERM) {
|
|
ErlNifResourceFlags flags = static_cast<ErlNifResourceFlags>(ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER);
|
|
ErlNifResourceType *ResIns = NULL;
|
|
ResIns = enif_open_resource_type(env, NULL, "eLfqRes", eLfqFree, flags, NULL);
|
|
if (NULL == ResIns)
|
|
return -1;
|
|
|
|
*priv_data = ResIns;
|
|
return 0;
|
|
}
|
|
|
|
void nifUnload(ErlNifEnv *, void *priv_data) {
|
|
}
|
|
|
|
ERL_NIF_TERM nifNew(ErlNifEnv *env, int, const ERL_NIF_TERM *) {
|
|
ErlNifResourceType *ResIns = static_cast<ErlNifResourceType *>(enif_priv_data(env));
|
|
|
|
lfqIns *ObjIns = static_cast<lfqIns *>(enif_alloc_resource(ResIns, sizeof(lfqIns)));
|
|
if (ObjIns == NULL)
|
|
return atomNewErr;
|
|
|
|
*ObjIns = new moodycamel::ConcurrentQueue<ErlNifBinary, NifTraits>;
|
|
if (*ObjIns == NULL)
|
|
return atomNewErr;
|
|
|
|
ERL_NIF_TERM RefTerm = enif_make_resource(env, ObjIns);
|
|
enif_release_resource(ObjIns);
|
|
return enif_make_tuple2(env, atomOk, RefTerm);
|
|
}
|
|
|
|
ERL_NIF_TERM nifDel1(ErlNifEnv *env, int, const ERL_NIF_TERM argv[]) {
|
|
ErlNifResourceType *ResIns = static_cast<ErlNifResourceType *>(enif_priv_data(env));
|
|
|
|
lfqIns *ObjIns = NULL;
|
|
|
|
if (!enif_get_resource(env, argv[0], ResIns, (void **) &ObjIns)) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
if (NULL != ObjIns && NULL != *ObjIns) {
|
|
std::vector <ErlNifBinary> TermBinList(BulkDelCnt);
|
|
size_t OutSize;
|
|
do{
|
|
OutSize = (*ObjIns)->try_dequeue_bulk(TermBinList.begin(), TermBinList.size());
|
|
for (int i = OutSize - 1; i >= 0; --i) {
|
|
enif_release_binary(&TermBinList[i]);
|
|
}
|
|
}while(OutSize >= BulkDelCnt);
|
|
|
|
delete (*ObjIns);
|
|
*ObjIns = NULL;
|
|
}
|
|
|
|
return atomOk;
|
|
}
|
|
|
|
ERL_NIF_TERM nifIn2(ErlNifEnv *env, int, const ERL_NIF_TERM argv[]) {
|
|
ErlNifResourceType *ResIns = static_cast<ErlNifResourceType *>(enif_priv_data(env));
|
|
|
|
lfqIns *ObjIns = NULL;
|
|
|
|
if (!enif_get_resource(env, argv[0], ResIns, (void **) &ObjIns) || NULL == *ObjIns) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
ErlNifBinary TermBin;
|
|
if (!enif_term_to_binary(env, argv[1], &TermBin))
|
|
return enif_make_badarg(env);
|
|
|
|
if ((*ObjIns)->enqueue(TermBin)) {
|
|
return atomTrue;
|
|
} else {
|
|
enif_release_binary(&TermBin);
|
|
return atomFalse;
|
|
}
|
|
}
|
|
|
|
ERL_NIF_TERM nifIns2(ErlNifEnv *env, int, const ERL_NIF_TERM argv[]) {
|
|
ErlNifResourceType *ResIns = static_cast<ErlNifResourceType *>(enif_priv_data(env));
|
|
|
|
lfqIns *ObjIns = NULL;
|
|
|
|
if (!enif_get_resource(env, argv[0], ResIns, (void **) &ObjIns) || NULL == *ObjIns) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
ERL_NIF_TERM List;
|
|
ERL_NIF_TERM Head;
|
|
|
|
List = argv[1];
|
|
if (!enif_is_list(env, List)) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
unsigned ListLen;
|
|
enif_get_list_length(env, List, &ListLen);
|
|
|
|
std::vector <ErlNifBinary> TermBinList;
|
|
|
|
ErlNifBinary TermBin;
|
|
while (enif_get_list_cell(env, List, &Head, &List)) {
|
|
if (!enif_term_to_binary(env, Head, &TermBin)) {
|
|
for (auto it = TermBinList.begin(); it != TermBinList.end(); ++it) {
|
|
enif_release_binary(&(*it));
|
|
}
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
TermBinList.push_back(TermBin);
|
|
}
|
|
|
|
if ((*ObjIns)->enqueue_bulk(TermBinList.cbegin(), TermBinList.size())) {
|
|
return atomTrue;
|
|
} else {
|
|
for (auto it = TermBinList.begin(); it != TermBinList.end(); ++it) {
|
|
enif_release_binary(&(*it));
|
|
}
|
|
return atomFalse;
|
|
}
|
|
}
|
|
|
|
ERL_NIF_TERM nifTryOut1(ErlNifEnv *env, int, const ERL_NIF_TERM argv[]) {
|
|
ErlNifResourceType *ResIns = static_cast<ErlNifResourceType *>(enif_priv_data(env));
|
|
lfqIns *ObjIns = NULL;
|
|
|
|
if (!enif_get_resource(env, argv[0], ResIns, (void **) &ObjIns) || NULL == *ObjIns) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
ErlNifBinary TermBin;
|
|
|
|
if ((*ObjIns)->try_dequeue(TermBin)) {
|
|
ERL_NIF_TERM OutTerm;
|
|
if (enif_binary_to_term(env, TermBin.data, TermBin.size, &OutTerm, 0) == 0) {
|
|
enif_release_binary(&TermBin);
|
|
return atomError;
|
|
} else {
|
|
enif_release_binary(&TermBin);
|
|
return OutTerm;
|
|
}
|
|
} else {
|
|
return atomEmpty;
|
|
}
|
|
}
|
|
|
|
ERL_NIF_TERM nifTryOuts2(ErlNifEnv *env, int, const ERL_NIF_TERM argv[]) {
|
|
ErlNifResourceType *ResIns = static_cast<ErlNifResourceType *>(enif_priv_data(env));
|
|
lfqIns *ObjIns = NULL;
|
|
|
|
if (!enif_get_resource(env, argv[0], ResIns, (void **) &ObjIns) || NULL == *ObjIns) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
unsigned int OutLen;
|
|
if (!enif_get_uint(env, argv[1], &OutLen)) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
std::vector <ErlNifBinary> TermBinList(OutLen);
|
|
size_t OutSize = (*ObjIns)->try_dequeue_bulk(TermBinList.begin(), TermBinList.size());
|
|
|
|
ERL_NIF_TERM RetList = enif_make_list(env, 0);
|
|
|
|
ERL_NIF_TERM OutTerm;
|
|
for (int i = OutSize - 1; i >= 0; --i) {
|
|
if (enif_binary_to_term(env, TermBinList[i].data, TermBinList[i].size, &OutTerm, 0) == 0) {
|
|
enif_release_binary(&TermBinList[i]);
|
|
} else {
|
|
enif_release_binary(&TermBinList[i]);
|
|
RetList = enif_make_list_cell(env, OutTerm, RetList);
|
|
}
|
|
}
|
|
return RetList;
|
|
}
|
|
|
|
ERL_NIF_TERM nifSize1(ErlNifEnv *env, int, const ERL_NIF_TERM argv[]) {
|
|
ErlNifResourceType *ResIns = static_cast<ErlNifResourceType *>(enif_priv_data(env));
|
|
lfqIns *ObjIns = NULL;
|
|
|
|
if (!enif_get_resource(env, argv[0], ResIns, (void **) &ObjIns) || NULL == *ObjIns) {
|
|
return enif_make_badarg(env);
|
|
}
|
|
|
|
size_t LfqSize = (*ObjIns)->size_approx();
|
|
return enif_make_long(env, (long int) LfqSize);
|
|
}
|
|
|
|
static ErlNifFunc nifFuncs[] =
|
|
{
|
|
{"new", 0, nifNew},
|
|
{"del", 1, nifDel1},
|
|
{"in", 2, nifIn2},
|
|
{"ins", 2, nifIns2},
|
|
{"tryOut", 1, nifTryOut1},
|
|
{"tryOuts", 2, nifTryOuts2},
|
|
{"size", 1, nifSize1}
|
|
};
|
|
|
|
ERL_NIF_INIT(eLfq, nifFuncs, nifLoad, NULL, nifUpgrade, nifUnload)
|