/*-----------------------------------------------------------------------------------------------------------------------*/
static ERL_NIF_TERM get_data_field(ErlNifEnv* env, int32_t argc, ERL_NIF_TERM const argv[])
{
return make_error(env, FIX_FAILED, "not impemented yet");
}
/**
* \brief Creates and initializes the working data for the plan
* \param [in] plan The struct that holds the plan's data values.
* \return int Error flag value
* \sa parseCBAPlan
* \sa makeCBAPlan
* \sa execCBAPlan
* \sa perfCBAPlan
* \sa killCBAPlan
*/
int initCBAPlan(void *plan){
int ret = make_error(ALLOC,generic_err);
int i;
int nrow, ncol;
Plan *p;
CBA_data *ci = NULL;
p = (Plan *)plan;
#ifdef HAVE_PAPI
int temp_event, k;
int PAPI_Events [NUM_PAPI_EVENTS] = PAPI_COUNTERS;
char *PAPI_units [NUM_PAPI_EVENTS] = PAPI_UNITS;
#endif //HAVE_PAPI
if(p){
ci = (CBA_data *)p->vptr;
p->exec_count = 0;
if(DO_PERF){
perftimer_init(&p->timers, NUM_TIMERS);
#ifdef HAVE_PAPI
/* Initialize plan's PAPI data */
p->PAPI_EventSet = PAPI_NULL;
p->PAPI_Num_Events = 0;
TEST_PAPI(PAPI_create_eventset(&p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME);
//Add the desired events to the Event Set; ensure the dsired counters
// are on the system then add, ignore otherwise
for(k = 0; k < TOTAL_PAPI_EVENTS && k < NUM_PAPI_EVENTS; k++){
temp_event = PAPI_Events[k];
if(PAPI_query_event(temp_event) == PAPI_OK){
p->PAPI_Num_Events++;
TEST_PAPI(PAPI_add_event(p->PAPI_EventSet, temp_event), PAPI_OK, MyRank, 9999, PRINT_SOME);
}
}
PAPIRes_init(p->PAPI_Results, p->PAPI_Times);
PAPI_set_units(p->name, PAPI_units, NUM_PAPI_EVENTS);
TEST_PAPI(PAPI_start(p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME);
#endif //HAVE_PAPI
} //DO_PERF
}
if(ci){
brand_init(&(ci->br), ci->seed);
nrow = ci->nrows;
ncol = ci->ncols;
ci->niter *= 64; /* we'll do iterations in blocks of 64 */
if((ci->ncols % BLOCKSIZE) != 0){
return make_error(0,specific_err);
//fprintf(stderr, "ERROR (plan_cba): BLOCKSIZE (%ld) must divide"
//" ncol (%ld)\n", BLOCKSIZE, ncol);
}
assert ((NITERS % 64) == 0);
ci->work = (uint64_t *)calloc((size_t)((nrow * ncol + PAD + NITERS) * 2),
sizeof(uint64_t));
ret = (ci->work == NULL) ? make_error(ALLOC,generic_err) : ERR_CLEAN;
ci->out = &(ci->work[nrow * ncol + PAD]);
ci->data = &(ci->out[NITERS]);
ci->chk = &(ci->data[nrow * ncol + PAD]);
for(i = 0; i < (nrow * ncol); i++){
ci->data[i] = brand(&(ci->br));
}
blockit (ci->data, nrow, ncol, ci->work);
}
return ret;
} /* initCBAPlan */
struct dccNode* dcc_connect(struct userNode *user, char *address, unsigned short port) {
struct sockaddr_in addr;
struct dccNode *dcc;
unsigned long longip;
#ifdef PLATFORM_WINDOWS
WSADATA wsa;
#endif
dcc = (struct dccNode*)malloc(sizeof(struct dccNode));
if(dcc == NULL) {
make_error("Failed to allocate space for dcc structure.");
return NULL;
}
LL_ADDNODE(dcc, dcc_first, dcc_last);
stats.dcc_count++;
dcc->user = user;
#ifdef PLATFORM_WINDOWS
if(WSAStartup(0x0202, &wsa)) {
WSACleanup();
make_error("Failed to initiat use of WS2_32.DLL for dcc connection.");
return NULL;
}
if(wsa.wVersion != 0x0202) {
WSACleanup();
make_error("Old version of winsock detected, update this pos.");
return NULL;
}
#endif
if((dcc->sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
#ifdef PLATFORM_WINDOWS
WSACleanup();
#endif
freem(dcc);
make_error("Failed to create dcc socket.");
return NULL;
}
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
if((longip = atol(address)))
addr.sin_addr.s_addr = htonl(longip);
else
addr.sin_addr.s_addr = inet_addr(address);
memset(&addr.sin_zero, 0, 8);
xstrcpy(dcc->ip, inet_ntoa(addr.sin_addr), 256);
if(connect(dcc->sock, (struct sockaddr*)&addr, sizeof(struct sockaddr)) == -1) {
#ifdef PLATFORM_WINDOWS
WSACleanup();
#endif
freem(dcc);
make_error("Failed to connect to specified dcc ip or port.");
return NULL;
}
return dcc;
}
/*-----------------------------------------------------------------------------------------------------------------------*/
static ERL_NIF_TERM create(ErlNifEnv* env, int32_t argc, ERL_NIF_TERM const argv[])
{
char path[PATH_MAX] = {};
int32_t res = enif_get_string(env, argv[0], path, sizeof(path), ERL_NIF_LATIN1);
if (res <= 0)
{
return make_error(env, FIX_FAILED, "First paremeter is invalid. Should be string.");
}
FIXParserAttrs attrs = {};
ERL_NIF_TERM head;
ERL_NIF_TERM tail = argv[1];
while(enif_get_list_cell(env, tail, &head, &tail))
{
int32_t arity;
ERL_NIF_TERM const* tuple = NULL;
if (!enif_get_tuple(env, head, &arity, &tuple) || arity != 2)
{
return make_error(env, FIX_FAILED, "Wrong param arity. Should be tuple with arity 2.");
}
char pname[64] = {};
if (!enif_get_atom(env, tuple[0], pname, sizeof(pname), ERL_NIF_LATIN1))
{
return make_error(env, FIX_FAILED, "Wrong param name type. Should be atom.");
}
int32_t val = 0;
if (!enif_get_int(env, tuple[1], &val))
{
return make_error(env, FIX_FAILED, "Wrong param '%s' value. Should be integer.", pname);
}
if (!strcmp("page_size", pname)) { attrs.pageSize = val; }
else if (!strcmp("max_page_size", pname)) { attrs.maxPageSize = val; }
else if (!strcmp("num_pages", pname)) { attrs.numPages = val; }
else if (!strcmp("num_pages", pname)) { attrs.numPages = val; }
else if (!strcmp("max_pages", pname)) { attrs.maxPages = val; }
else if (!strcmp("num_groups", pname)) { attrs.numGroups = val; }
else if (!strcmp("max_groups", pname)) { attrs.maxGroups = val; }
else
{
return make_error(env, FIX_FAILED, "Unsupported parameter name '%s'.", pname);
}
}
tail = argv[2];
int32_t flags = 0;
while(enif_get_list_cell(env, tail, &head, &tail))
{
char flag[64] = {};
enif_get_atom(env, head, flag, sizeof(flag), ERL_NIF_LATIN1);
if (!strcmp(flag, "check_crc")) { flags |= PARSER_FLAG_CHECK_CRC; }
else if (!strcmp(flag, "check_required")) { flags |= PARSER_FLAG_CHECK_REQUIRED; }
else if (!strcmp(flag, "check_value")) { flags |= PARSER_FLAG_CHECK_VALUE; }
else if (!strcmp(flag, "check_unknown_fields")) { flags |= PARSER_FLAG_CHECK_UNKNOWN_FIELDS; }
else if (!strcmp(flag, "check_all")) { flags |= PARSER_FLAG_CHECK_ALL; }
else
{
return make_error(env, FIX_FAILED, "Unsupported flag '%s'.", flag);
}
}
FIXError* error = NULL;
FIXParser* parser = fix_parser_create(path, &attrs, flags, &error);
if (!parser)
{
ERL_NIF_TERM ret = make_parser_error(env, fix_error_get_code(error), fix_error_get_text(error));
fix_error_free(error);
return ret;
}
pthread_rwlockattr_t attr;
pthread_rwlock_t lock;
int err = pthread_rwlockattr_init(&attr);
if (err)
{
fix_parser_free(parser);
return make_error(env, FIX_FAILED, "Unable to init lock attr. Error = %s", strerror(err));
}
err = pthread_rwlock_init(&lock, &attr);
if (err)
{
fix_parser_free(parser);
return make_error(env, FIX_FAILED, "Unable to init mutex. Error = %s", strerror(err));
}
pthread_rwlockattr_destroy(&attr);
ParserRes* pres = (ParserRes*)enif_alloc_resource(parser_res, sizeof(ParserRes));
pres->ptr = parser;
pres->lock = lock;
ERL_NIF_TERM pres_term = enif_make_resource(env, pres);
enif_release_resource(pres);
return enif_make_tuple2(env, ok_atom, enif_make_tuple2(env, parser_atom, pres_term));
}
void Interpreter::disp_error( String msg, const Expr &sf, int off, Scope *sc, bool warn ) {
std::cerr << make_error( msg, sf, off, sc, warn );
}
unsigned int rehashconfig(void) {
char **xlines;
char *conftok = (char*)callocm(CONF_MAX_ITEMLEN, sizeof(char));
unsigned int i = 0, xcount = 0,
acount = 0; /* Don't get this confused with the word "account" */
extern q_maxbytes;
/*X:Line*/
xcount = get_confitem(&xlines, 'X');
if(!xcount) {
make_error("No X:lines in configuration file.");
freem(conftok);
return 0;
}
/*nickname*/ xstrcpy(bot.nick, get_itemtok(conftok, xlines[0], 2), 32);
if(!istrcmp(bot.current_nick, bot.nick))
irc_nick(bot.nick);
/*altnick*/ xstrcpy(bot.altnick, get_itemtok(conftok, xlines[0], 3), 32);
/*S:Lines*/
/*maxretry*/ irc_subconftok(conftok, 'S', "maxretry", 3);
bot.maxretry = atoi(conftok);
/*pingtimeout*/ irc_subconftok(conftok, 'S', "pingtimeout", 3);
bot.ping_timeout = atoi(conftok);
/*antiflood*/ irc_subconftok(conftok, 'S', "antiflood", 5);
bot.floodcheck = (atoi(conftok) ? 1 : 0);
irc_subconftok(conftok, 'S', "antiflood", 3);
q_maxbytes = (unsigned int)atoi(conftok);
/*ctrigger*/ irc_subconftok(conftok, 'S', "ctrigger", 3);
conf_replace_alias(conftok);
bot.ctrigger = conftok[0];
/*ptrigger*/ irc_subconftok(conftok, 'S', "ptrigger", 3);
conf_replace_alias(conftok);
bot.ptrigger = conftok[0];
/*A:Lines*/
if(bot.admin_array != NULL)
free_2d_array(bot.admin_array, bot.admin_lines);
acount = get_confitem(&bot.admin_array, 'A');
bot.admin_lines = acount;
if(acount) {
for(i = 0;i < bot.admin_lines;i++) {
get_itemtok(conftok, bot.admin_array[i], 3);
if((istrcmp(conftok, ";")) || (istrcmp(conftok, "*")))
adm_loginuser(get_itemtok(conftok, bot.admin_array[i], 2),
get_itemtok(conftok, bot.admin_array[i], 4),
atoi(get_itemtok(conftok, bot.admin_array[i], 5)));
}
}
freem(conftok);
free_2d_array(xlines, xcount);
event_call(EVENT_REHASH, 0);
return 1;
}
/* Event handler for tool 'error-support' */
ATerm error_support_handler(int conn, ATerm term)
{
ATerm in, out;
/* We need some temporary variables during matching */
char *s0, *s1;
ATerm t0;
if(ATmatch(term, "rec-eval(make-error(<str>,<term>))", &s0, &t0)) {
return make_error(conn, s0, t0);
}
if(ATmatch(term, "rec-eval(get-area-end-line(<term>))", &t0)) {
return get_area_end_line(conn, t0);
}
if(ATmatch(term, "rec-eval(get-location-filename(<term>))", &t0)) {
return get_location_filename(conn, t0);
}
if(ATmatch(term, "rec-eval(has-location-area(<term>))", &t0)) {
return has_location_area(conn, t0);
}
if(ATmatch(term, "rec-eval(get-summary-id(<term>))", &t0)) {
return get_summary_id(conn, t0);
}
if(ATmatch(term, "rec-eval(get-error-description(<term>))", &t0)) {
return get_error_description(conn, t0);
}
if(ATmatch(term, "rec-do(display-summary(<term>))", &t0)) {
display_summary(conn, t0);
return NULL;
}
if(ATmatch(term, "rec-eval(lower-summary(<term>))", &t0)) {
return lower_summary(conn, t0);
}
if(ATmatch(term, "rec-eval(make-localized-subject(<str>,<term>))", &s0, &t0)) {
return make_localized_subject(conn, s0, t0);
}
if(ATmatch(term, "rec-eval(get-summary-producer(<term>))", &t0)) {
return get_summary_producer(conn, t0);
}
if(ATmatch(term, "rec-eval(get-error-subjects(<term>))", &t0)) {
return get_error_subjects(conn, t0);
}
if(ATmatch(term, "rec-eval(make-subject(<str>))", &s0)) {
return make_subject(conn, s0);
}
if(ATmatch(term, "rec-eval(get-subject-location(<term>))", &t0)) {
return get_subject_location(conn, t0);
}
if(ATmatch(term, "rec-eval(get-area-offset(<term>))", &t0)) {
return get_area_offset(conn, t0);
}
if(ATmatch(term, "rec-eval(get-area-begin-line(<term>))", &t0)) {
return get_area_begin_line(conn, t0);
}
if(ATmatch(term, "rec-eval(add-filename-in-error(<str>,<term>))", &s0, &t0)) {
return add_filename_in_error(conn, s0, t0);
}
if(ATmatch(term, "rec-eval(get-location-area(<term>))", &t0)) {
return get_location_area(conn, t0);
}
if(ATmatch(term, "rec-eval(set-summary-id(<term>,<str>))", &t0, &s0)) {
return set_summary_id(conn, t0, s0);
}
if(ATmatch(term, "rec-eval(has-subject-location(<term>))", &t0)) {
return has_subject_location(conn, t0);
}
if(ATmatch(term, "rec-eval(get-area-end-column(<term>))", &t0)) {
return get_area_end_column(conn, t0);
}
if(ATmatch(term, "rec-eval(make-summary(<str>,<str>,<term>))", &s0, &s1, &t0)) {
return make_summary(conn, s0, s1, t0);
}
if(ATmatch(term, "rec-eval(get-summary-errors(<term>))", &t0)) {
return get_summary_errors(conn, t0);
}
if(ATmatch(term, "rec-eval(get-subject-description(<term>))", &t0)) {
return get_subject_description(conn, t0);
}
if(ATmatch(term, "rec-eval(get-area-length(<term>))", &t0)) {
return get_area_length(conn, t0);
}
if(ATmatch(term, "rec-terminate(<term>)", &t0)) {
rec_terminate(conn, t0);
return NULL;
}
if(ATmatch(term, "rec-eval(get-area-begin-column(<term>))", &t0)) {
return get_area_begin_column(conn, t0);
}
if(ATmatch(term, "rec-do(signature(<term>,<term>))", &in, &out)) {
ATerm result = error_support_checker(conn, in);
if(!ATmatch(result, "[]"))
ATfprintf(stderr, "warning: not in input signature:\n\t%\n\tl\n", result);
return NULL;
}
ATerror("tool error-support cannot handle term %t", term);
return NULL; /* Silence the compiler */
}
boost::system::error_code TestPeerBasics::make_error (errc::errc_t ev, boost::system::error_code& ec) noexcept
{
return ec = make_error (ev);
}
/**
* \brief Creates and initializes the working data for the plan
* \param plan The Plan struct that holds the plan's data values.
* \return Error flag value
*/
int initOPENCL_MEMPlan(void *plan){ // <- Replace YOUR_NAME with the name of your module.
if(!plan){
return make_error(ALLOC, generic_err); // <- This is the error code for one of the malloc fails.
}
Plan *p;
OPENCL_MEM_DATA *d;
p = (Plan *)plan;
#ifdef HAVE_PAPI
int temp_event, i;
int PAPI_Events [NUM_PAPI_EVENTS] = PAPI_COUNTERS;
char *PAPI_units [NUM_PAPI_EVENTS] = PAPI_UNITS;
#endif //HAVE_PAPI
if(p){
d = (OPENCL_MEM_DATA *)p->vptr;
p->exec_count = 0; // Initialize the plan execution count to zero.
perftimer_init(&p->timers, NUM_TIMERS); // Initialize all performance timers to zero.
#ifdef HAVE_PAPI
/* Initialize plan's PAPI data */
p->PAPI_EventSet = PAPI_NULL;
p->PAPI_Num_Events = 0;
TEST_PAPI(PAPI_create_eventset(&p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME);
//Add the desired events to the Event Set; ensure the dsired counters
// are on the system then add, ignore otherwise
for(i = 0; i < TOTAL_PAPI_EVENTS && i < NUM_PAPI_EVENTS; i++){
temp_event = PAPI_Events[i];
if(PAPI_query_event(temp_event) == PAPI_OK){
p->PAPI_Num_Events++;
TEST_PAPI(PAPI_add_event(p->PAPI_EventSet, temp_event), PAPI_OK, MyRank, 9999, PRINT_SOME);
}
}
PAPIRes_init(p->PAPI_Results, p->PAPI_Times);
PAPI_set_units(p->name, PAPI_units, NUM_PAPI_EVENTS);
TEST_PAPI(PAPI_start(p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME);
#endif //HAVE_PAPI
}
if(d){
cl_int error;
pthread_mutex_lock(&opencl_platform_mutex);
error = clGetPlatformIDs(0, NULL,&(d->num_platforms));
pthread_mutex_unlock(&opencl_platform_mutex);
assert(error == CL_SUCCESS);
d->platforms = (cl_platform_id *)malloc(sizeof(cl_platform_id) * d->num_platforms);
pthread_mutex_lock(&opencl_platform_mutex);
error = clGetPlatformIDs(d->num_platforms, d->platforms, NULL);
pthread_mutex_unlock(&opencl_platform_mutex);
assert(error == CL_SUCCESS);
error = clGetDeviceIDs(d->platforms[0],CL_DEVICE_TYPE_ALL, 0, NULL, &(d->num_devices));
assert(error == CL_SUCCESS);
d->devices = (cl_device_id *)malloc(sizeof(cl_device_id) * d->num_devices);
error = clGetDeviceIDs(d->platforms[0],CL_DEVICE_TYPE_ALL, d->num_devices, d->devices, NULL);
assert(error == CL_SUCCESS);
d->context = clCreateContext(NULL, 1, &(d->devices[d->device_id]), NULL, NULL, &error);
assert(error == CL_SUCCESS);
d->opencl_queue = clCreateCommandQueue(d->context, d->devices[d->device_id], 0, &error);
assert(error == CL_SUCCESS);
error = clGetDeviceInfo(d->devices[d->device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(cl_ulong), &(d->device_memory), NULL);
assert(error == CL_SUCCESS);
d->device_memory -= SUB_FACTOR;
d->buffer = clCreateBuffer(d->context, CL_MEM_WRITE_ONLY, d->device_memory, NULL, &error);
assert(error == CL_SUCCESS);
size_t page_size = sysconf(_SC_PAGESIZE);
error = posix_memalign((void **)&(d->return_buffer), page_size, d->device_memory);
assert(error == 0);
d->program = clCreateProgramWithSource(d->context, 1, (const char **)&opencl_program,NULL,&error);
assert(error == CL_SUCCESS);
error = clBuildProgram(d->program,1,&(d->devices[d->device_id]),NULL,NULL,NULL);
assert(error == CL_SUCCESS);
d->kernel = clCreateKernel(d->program, "write_pattern", &error);
assert(error == CL_SUCCESS);
}
return ERR_CLEAN; // <- This indicates a clean run with no errors. Does not need to be changed.
} /* initOPENCL_MEMPlan */
static ERL_NIF_TERM test_make_error(ErlNifEnv* env, int /*argc*/,
const ERL_NIF_TERM /*argv*/[])
{
return make_error(env, "it_is_a_test_error");
}
LispObj *read_from_yybuf(YY_BUFFER_STATE yy_buf)
{
yy_switch_to_buffer(yy_buf);
Token token = get_token();
if (token.str == NULL) /* a NULL pointer = EOF */
return NULL;
switch (token.type) {
case T_INTEGER: {
int x;
sscanf(token.str, "%d", &x);
free(token.str);
return make_int(x);
}
case T_CHAR: {
char c = token.str[2]; /* TODO: name-char reading */
free(token.str);
return make_char(c);
}
case T_STRING: {
int len = strlen(token.str);
/* Take a substring of token.str, skipping the first
* and last chars */
char *str = malloc(sizeof(char) * (len - 2));
strncpy(str, token.str + 1, len - 2);
*(str + (len - 2)) = '\0';
free(token.str);
return make_string(str);
}
case T_SYMBOL: {
return make_symbol(token.str);
}
case T_OPEN_PAREN: {
free(token.str);
LispObj *car = read_from_yybuf(yy_buf);
if (car == NULL) /* Unmatched open parenthesis */
return NULL; /* TODO: Error handling/reporting */
if ((car->type == ERROR) &&
(car->value.l_err == UNMATCHED_CLOSE_PAREN)) {
always_free_lisp_obj(car);
return get_nil();
}
Cons *curr_cons = cons(car, get_nil());
LispObj *list = make_cons(curr_cons);
for (;;) {
car = read_from_yybuf(yy_buf);
if (car == NULL)
return NULL;
if ((car->type == ERROR) &&
(car->value.l_err == UNMATCHED_CLOSE_PAREN)) {
always_free_lisp_obj(car);
break;
}
curr_cons->cdr = make_cons(cons(car, get_nil()));
curr_cons = curr_cons->cdr->value.l_cons;
}
return list;
}
case T_CLOSE_PAREN:
free(token.str);
return make_error(UNMATCHED_CLOSE_PAREN);
}
return NULL;
}
void basp_broker_state::deliver(const node_id& src_nid, actor_id src_aid,
strong_actor_ptr dest, message_id mid,
std::vector<strong_actor_ptr>& stages,
message& msg) {
CAF_LOG_TRACE(CAF_ARG(src_nid) << CAF_ARG(src_aid) << CAF_ARG(dest)
<< CAF_ARG(msg) << CAF_ARG(mid));
auto src = src_nid == this_node() ? system().registry().get(src_aid)
: proxies().get_or_put(src_nid, src_aid);
// Intercept link messages. Forwarding actor proxies signalize linking
// by sending link_atom/unlink_atom message with src = dest.
if (msg.type_token() == make_type_token<atom_value, strong_actor_ptr>()) {
switch (static_cast<uint64_t>(msg.get_as<atom_value>(0))) {
default:
break;
case link_atom::value.uint_value(): {
if (src_nid != this_node()) {
CAF_LOG_WARNING("received link message for an other node");
return;
}
auto ptr = msg.get_as<strong_actor_ptr>(1);
if (!ptr) {
CAF_LOG_WARNING("received link message with invalid target");
return;
}
if (!src) {
CAF_LOG_DEBUG("received link for invalid actor, report error");
anon_send(actor_cast<actor>(ptr),
make_error(sec::remote_linking_failed));
return;
}
static_cast<actor_proxy*>(ptr->get())->local_link_to(src->get());
return;
}
case unlink_atom::value.uint_value(): {
if (src_nid != this_node()) {
CAF_LOG_WARNING("received unlink message for an other node");
return;
}
auto ptr = msg.get_as<strong_actor_ptr>(1);
if (!ptr) {
CAF_LOG_DEBUG("received unlink message with invalid target");
return;
}
if (!src) {
CAF_LOG_DEBUG("received unlink for invalid actor, report error");
return;
}
static_cast<actor_proxy*>(ptr->get())->local_unlink_from(src->get());
return;
}
}
}
if (!dest) {
auto rsn = exit_reason::remote_link_unreachable;
CAF_LOG_INFO("cannot deliver message, destination not found");
self->parent().notify<hook::invalid_message_received>(src_nid, src,
invalid_actor_id,
mid, msg);
if (mid.valid() && src) {
detail::sync_request_bouncer srb{rsn};
srb(src, mid);
}
return;
}
self->parent().notify<hook::message_received>(src_nid, src, dest, mid, msg);
dest->enqueue(make_mailbox_element(std::move(src), mid, std::move(stages),
std::move(msg)),
nullptr);
}
/**
* \brief Creates and initializes the working data for the plan
* \param [in] plan Holds the data and memory for the plan.
* \return int Error flag value
* \sa parseFFT2Plan
* \sa makeFFT2Plan
* \sa execFFT2Plan
* \sa perfFFT2Plan
* \sa killFFT2Plan
*/
int initFFT2Plan(void *plan){
int i,k;
size_t M;
int ret = make_error(ALLOC,generic_err);
Plan *p;
FFTdata *d = NULL;
p = (Plan *)plan;
#ifdef HAVE_PAPI
int temp_event, j;
int PAPI_Events [NUM_PAPI_EVENTS] = PAPI_COUNTERS;
char *PAPI_units [NUM_PAPI_EVENTS] = PAPI_UNITS;
#endif //HAVE_PAPI
if(p){
d = (FFTdata *)p->vptr;
p->exec_count = 0;
if(DO_PERF){
perftimer_init(&p->timers, NUM_TIMERS);
#ifdef HAVE_PAPI
/* Initialize plan's PAPI data */
p->PAPI_EventSet = PAPI_NULL;
p->PAPI_Num_Events = 0;
TEST_PAPI(PAPI_create_eventset(&p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME);
//Add the desired events to the Event Set; ensure the dsired counters
// are on the system then add, ignore otherwise
for(j = 0; j < TOTAL_PAPI_EVENTS && j < NUM_PAPI_EVENTS; j++){
temp_event = PAPI_Events[j];
if(PAPI_query_event(temp_event) == PAPI_OK){
p->PAPI_Num_Events++;
TEST_PAPI(PAPI_add_event(p->PAPI_EventSet, temp_event), PAPI_OK, MyRank, 9999, PRINT_SOME);
}
}
PAPIRes_init(p->PAPI_Results, p->PAPI_Times);
PAPI_set_units(p->name, PAPI_units, NUM_PAPI_EVENTS);
TEST_PAPI(PAPI_start(p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME);
#endif //HAVE_PAPI
} //DO_PERF
}
if(d){
M = d->M;
pthread_rwlock_wrlock(&FFTW_Lock);
d->in_original = (fftw_complex *) fftw_malloc(sizeof(fftw_complex) * M * M);
assert(d->in_original);
d->out = (fftw_complex *) fftw_malloc(sizeof(fftw_complex) * M * M);
assert(d->out);
d->mid = (fftw_complex *) fftw_malloc(sizeof(fftw_complex) * M * M);
assert(d->mid);
if(d->in_original && d->out && d->mid){
ret = make_error(0,specific_err); // Error in getting the plan set
}
d->forward = fftw_plan_dft_2d(M,M,d->in_original,d->mid,FFTW_FORWARD, FFTW_ESTIMATE);
d->backward = fftw_plan_dft_2d(M,M,d->mid,d->out,FFTW_BACKWARD, FFTW_ESTIMATE);
pthread_rwlock_unlock(&FFTW_Lock);
if(d->forward && d->backward){
ret = ERR_CLEAN;
}
srand(0);
for(i = 0; i < M; i++){
for(k = 0; k < M; k++){
d->in_original[i * M + k][0] = rand();
d->in_original[i * M + k][1] = rand();
}
}
}
return ret;
} /* initFFT2Plan */
virtual TInt HandleImmediateError(TInt errCode)
{
(*cb)(userdata, make_error(errCode, "immediate error"));
return 0;
}
int
handle_lua_uri(FCGX_Request *request)
{
char cmd[1024];
char token[1024];
char arg[1024];
enum lua_operation lo;
int id; // token ID, parsed as an int
char *uri = FCGX_GetParam("REQUEST_URI", request->envp) + strlen("/lua/");
parse_lua_uri(uri, cmd, token, arg, sizeof(cmd));
lo = determine_lua_operation(cmd, token, arg);
fprintf(stderr, "Raw URI: %s Command: %s Token: %s Arg: %s Lua Operation: %s\n", uri, cmd, token, arg, op_to_str(lo));
if (lo == LUA_EVAL)
return nlua_eval(request);
else if(lo == LUA_OPEN) {
id = nlua_open(request, token, arg);
if (id < 0)
return make_error(request, "Unable to open LUA environment", -id);
FCGX_FPrintF(request->out, "Content-Type: text/html\r\n"
"\r\n"
"%d\n", id);
}
else if (lo == LUA_CLOSE) {
id = strtoul(token, NULL, 16);
if (id > MAX_THREAD_ID)
return make_error(request, "Invalid thread ID specified", EINVAL);
nlua_close(request, id);
FCGX_FPrintF(request->out, "Content-Type: text/html\r\n"
"\r\n"
"OK\n");
}
else if (lo == LUA_WEBIO) {
id = strtoul(token, NULL, 0);
if (id > MAX_THREAD_ID)
return make_error(request, "Invalid thread ID specified", EINVAL);
if (!nlua_pool_status[id])
return make_error(request, "Thread not running", EINVAL);
return nlua_webio(request, arg, id);
}
else if (lo == LUA_LIST) {
FCGX_FPrintF(request->out, "Content-Type: text/plain\r\n\r\n");
for (id=0; id<MAX_THREAD_ID; id++)
if (nlua_pool_status[id])
FCGX_FPrintF(request->out, "%d\r\n", id);
}
else if (lo == LUA_UNKNOWN)
return make_error(request, "No valid LUA command specified", EINVAL);
return 0;
}
static void level ()
{
char *level_name __attribute__((unused)) = "level name";
make_error ("called from level");
}
static int
nlua_webio(FCGX_Request *request, char *arg, int id)
{
char *method = FCGX_GetParam("REQUEST_METHOD", request->envp);
/* If it's a POST, then write to Lua's stdin */
if (!strcmp(method, "POST")) {
char bfr[8192];
int bytes_read, bytes_written;
int timeout = DEFAULT_WEBIO_TIMEOUT;
if (*arg) {
timeout = strtoul(arg, NULL, 0);
if (timeout < 0 || timeout > MAX_WEBIO_TIMEOUT)
timeout = DEFAULT_WEBIO_TIMEOUT;
}
FCGX_FPrintF(request->out, "Content-Type: text/html\r\n\r\n");
while ( (bytes_read = FCGX_GetStr(bfr, sizeof(bfr), request->in)) > 0) {
char *left = bfr;
/*
if (enc && (!strcmp(enc, "hex") || !strcmp(enc, "hexecho"))) {
char *s = bfr;
int input=0, output=0;
while (input < bytes_read) {
s[output] = (tohex(s[input++])<<4)&0xf0;
if (s[input])
s[output] |= tohex(s[input++])&0x0f;
output++;
}
s[output] = '\0';
bytes_read /= 2;
}
if (!strcmp(enc, "hexecho") || !strcmp(enc, "echo"))
FCGX_PutStr(bfr, bytes_read, request->out);
*/
while (bytes_read > 0) {
bytes_written = write(nlua_states[id].in_fd, left, bytes_read);
if (bytes_written < 0) {
perror("Unable to write file");
return make_error(request, "Unable to write file", errno);
}
left += bytes_written;
bytes_read -= bytes_written;
}
}
}
/* If it's not a POST, then read from stdout / stderr */
else if (!strcmp(method, "GET")) {
fd_set s;
struct timeval t = {DEFAULT_WEBIO_TIMEOUT, 20000};
int i;
int read_fd, handle_id;
int max;
FD_ZERO(&s);
FD_SET(nlua_states[id].out_fd, &s);
max = nlua_states[id].out_fd;
FD_SET(nlua_states[id].err_fd, &s);
if (max < nlua_states[id].err_fd)
max = nlua_states[id].err_fd;
FD_SET(nlua_states[id].out_ctrl, &s);
if (max < nlua_states[id].out_ctrl)
max = nlua_states[id].out_ctrl;
i = select(max+1, &s, NULL, NULL, &t);
if (i > 0) {
char bfr[16384];
if (FD_ISSET(nlua_states[id].out_fd, &s)) {
read_fd = nlua_states[id].out_fd;
handle_id = 1;
}
else if (FD_ISSET(nlua_states[id].err_fd, &s)) {
read_fd = nlua_states[id].err_fd;
handle_id = 2;
}
else {
read_fd = nlua_states[id].out_ctrl;
handle_id = 3;
}
i = read(read_fd, bfr, sizeof(bfr));
if (i == -1 && (errno == EINTR || errno == EAGAIN)) {
/* Interrupted, but try again */
FCGX_FPrintF(request->out, "Content-Type: text/html\r\n"
"X-Handle: %d\r\n"
"\r\n",
handle_id);
return 0;
}
else if (i == -1) {
/* Unrecoverable error */
kill(nlua_states[id].pid, SIGKILL);
kill(nlua_states[id].pid, SIGTERM);
close(nlua_states[id].out_fd);
close(nlua_states[id].err_fd);
close(nlua_states[id].out_ctrl);
nlua_states[id].out_fd = -1;
nlua_states[id].err_fd = -1;
nlua_states[id].out_ctrl = -1;
nlua_pool_status[id] = 0;
return make_error(request, "Unable to read from handle", errno);
}
/* The handle control fd requires special care */
else if (handle_id == 3)
return handle_ctrl(request, bfr, i);
else if (i == 0) {
/* Connection closed */
close(nlua_states[id].out_fd);
close(nlua_states[id].err_fd);
close(nlua_states[id].out_ctrl);
nlua_states[id].out_fd = -1;
nlua_states[id].err_fd = -1;
nlua_states[id].out_ctrl = -1;
nlua_pool_status[id] = 0;
FCGX_FPrintF(request->out, "Content-Type: text/plain\r\n"
"Status: 204\r\n"
"X-Handle: %d\r\n"
"\r\n",
handle_id);
}
else {
FCGX_FPrintF(request->out, "Content-Type: text/plain\r\n"
"X-Handle: %d\r\n"
"\r\n",
handle_id);
FCGX_PutStr(bfr, i, request->out);
}
}
else if (!i || (i == -1 && (errno == EINTR || errno == EAGAIN))) {
/* No data to read */
FCGX_FPrintF(request->out, "Content-Type: text/html\r\n\r\n");
}
else {
/* Error occurred */
kill(nlua_states[id].pid, SIGKILL);
kill(nlua_states[id].pid, SIGTERM);
close(nlua_states[id].out_fd);
close(nlua_states[id].err_fd);
close(nlua_states[id].out_ctrl);
nlua_states[id].out_fd = -1;
nlua_states[id].err_fd = -1;
nlua_states[id].out_ctrl = -1;
nlua_pool_status[id] = 0;
return make_error(request, "Unable to read from stdout", errno);
}
}
else {
return make_error(request, "Unrecognized http method", 0);
}
return 0;
}
ERL_NIF_TERM
enc_error(Encoder* e, const char* msg)
{
//assert(0 && msg);
return make_error(e->atoms, e->env, msg);
}
static int
nlua_eval(FCGX_Request *request)
{
return make_error(request, "Unimplemented", ENOSYS);
#if 0
char *program;
int prog_ptr = 0;
lua_State *lua;
int streamer[2];
int in, out;
int content_length;
char *tmp = FCGX_GetParam("CONTENT_LENGTH", request->envp);
close(0);
content_length = strtoul(content_length, 0, NULL);
/* If there's no program, there's nothing to do */
if (content_length <= 0) {
FCGX_FPrintF(request, "Content-Type: text/plain\r\n\r\n");
return 0;
}
program = malloc(con->request.content_length+1);
if (!program)
return make_error(request, "Program size to large", ENOMEM);
program[content_length] = '\0';
/* there is content to eval */
for (c = cq->first; c; c = cq->first) {
int r = 0;
/* copy all chunks */
switch(c->type) {
case FILE_CHUNK:
if (c->file.mmap.start == MAP_FAILED) {
if (-1 == c->file.fd && /* open the file if not already open */
-1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
//log_error_write(srv, __FILE__, __LINE__, "ss", "open failed: ", strerror(errno));
free(program);
return -1;
}
c->file.mmap.length = c->file.length;
if (MAP_FAILED == (c->file.mmap.start = mmap(0, c->file.mmap.length, PROT_READ, MAP_SHARED, c->file.fd, 0))) {
//log_error_write(srv, __FILE__, __LINE__, "ssbd", "mmap failed: ", strerror(errno), c->file.name, c->file.fd);
free(program);
return -1;
}
close(c->file.fd);
c->file.fd = -1;
/* chunk_reset() or chunk_free() will cleanup for us */
}
memcpy(program+prog_ptr, c->file.mmap.start+c->offset,
c->file.length - c->offset);
r = c->file.length - c->offset;
break;
case MEM_CHUNK:
memcpy(program+prog_ptr,
c->mem->ptr + c->offset,
c->mem->used - c->offset - 1);
r = c->mem->used - c->offset - 1;
break;
case UNUSED_CHUNK:
break;
}
c->offset += r;
cq->bytes_out += r;
prog_ptr += r;
chunkqueue_remove_finished_chunks(cq);
}
lua = lua_open();
if (!lua)
return make_error(con, "Unable to open lua", errno);
luaL_openlibs(lua);
pipe(streamer);
out = dup2(streamer[1], 0);
in = streamer[0];
if (streamer[1] != out)
close(streamer[1]);
if (luaL_dostring(lua, program)) {
char errmsg[2048];
snprintf(errmsg, sizeof(errmsg)-1,
"LUA program \"%s\" encountered an error: %s", program, lua_tostring(lua, 1));
make_error(con, errmsg, 1);
con->http_status = 200;
}
else {
char data[4096];
int len;
bzero(data, sizeof(data));
len = read(in, data, sizeof(data));
b = chunkqueue_get_append_buffer(con->write_queue);
buffer_copy_string_len(b, data, len);
con->http_status = 200;
}
lua_close(lua);
free(program);
close(streamer[1]);
close(streamer[0]);
close(out);
close(in);
return HANDLER_FINISHED;
#endif
}
/* This function should not be called more than once */
unsigned int init(void) {
char **xlines, **clines;
char *conftok = (char*)callocm(CONF_MAX_ITEMLEN, sizeof(char));
unsigned int i = 0, xcount = 0, ccount = 0,
acount = 0; /* Don't get this confused with the word "account" */
extern q_maxbytes, q_maxqueue;
/* For making sure when these variables
are tested, they are set to NULL first. */
init_handle(&q_first);
init_handle(&q_last);
init_handle(&event_first);
init_handle(&event_last);
init_handle(&chan_first);
init_handle(&chan_last);
init_handle(&user_first);
init_handle(&user_last);
init_handle(&me);
init_handle(&bc_first);
init_handle(&bc_last);
init_handle(&dcc_first);
init_handle(&dcc_last);
eventloop_running = 0;
bot.cid = 0;
bot.connected = 0;
xstrcpy(bot.config, XION_CONFIG, 260);
bot.admin_current_count = 0;
bot.current_try = 1;
q_first = NULL;
/*X:Line*/
xcount = get_confitem(&xlines, 'X');
if(!xcount) {
make_error("No X:lines in configuration file.");
freem(conftok);
return 0;
}
/*nickname*/ xstrcpy(bot.nick, get_itemtok(conftok, xlines[0], 2), 32);
/*altnick*/ xstrcpy(bot.altnick, get_itemtok(conftok, xlines[0], 3), 32);
/*username*/ xstrcpy(bot.username, get_itemtok(conftok, xlines[0], 4), 12);
/*fullname*/ xstrcpy(bot.info, get_itemtok(conftok, xlines[0], 5), 256);
xstrcpy(bot.info, conf_replace_alias(conftok), 256);
/*C:Line*/
ccount = get_confitem(&clines, 'C');
if(!ccount) {
make_error("No C:lines in configuration file.");
freem(conftok);
free_2d_array(xlines, xcount);
return 0;
}
/*servaddr*/ xstrcpy(bot.servaddr, get_itemtok(conftok, clines[0], 2), 256);
/*servport*/ bot.servport = atoi(get_itemtok(conftok, clines[0], 3));
/*servpass*/ xstrcpy(bot.servpass, get_itemtok(conftok, clines[0], 4), 256);
/*S:Lines*/
/*maxretry*/ irc_subconftok(conftok, 'S', "maxretry", 3);
bot.maxretry = atoi(conftok);
/*pingtimeout*/ irc_subconftok(conftok, 'S', "pingtimeout", 3);
bot.ping_timeout = atoi(conftok);
/*freshlog*/ irc_subconftok(conftok, 'S', "freshlog", 3);
bot.fresh_log = (atoi(conftok) ? 1 : 0);
/*antiflood*/ irc_subconftok(conftok, 'S', "antiflood", 5);
bot.floodcheck = (atoi(conftok) ? 1 : 0);
irc_subconftok(conftok, 'S', "antiflood", 3);
q_maxbytes = (unsigned int)atoi(conftok);
irc_subconftok(conftok, 'S', "antiflood", 4);
q_maxqueue = (unsigned int)atoi(conftok);
/*ctrigger*/ irc_subconftok(conftok, 'S', "ctrigger", 3);
conf_replace_alias(conftok);
bot.ctrigger = conftok[0];
/*ptrigger*/ irc_subconftok(conftok, 'S', "ptrigger", 3);
conf_replace_alias(conftok);
bot.ptrigger = conftok[0];
/*A:Lines*/
if(bot.admin_array != NULL)
free_2d_array(bot.admin_array, bot.admin_lines);
acount = get_confitem(&bot.admin_array, 'A');
bot.admin_lines = acount;
if(acount) {
for(i = 0;i < bot.admin_lines;i++) {
get_itemtok(conftok, bot.admin_array[i], 3);
if((istrcmp(conftok, ";")) || (istrcmp(conftok, "*")))
adm_loginuser(get_itemtok(conftok, bot.admin_array[i], 2),
get_itemtok(conftok, bot.admin_array[i], 4),
atoi(get_itemtok(conftok, bot.admin_array[i], 5)));
}
}
/* URL Module: mod-weburlcache.c */
urlmod_init();
freem(conftok);
free_2d_array(xlines, xcount);
free_2d_array(clines, ccount);
event_call(EVENT_INIT, 0);
return 1;
}
/*-----------------------------------------------------------------------------------------------------------------------*/
static ERL_NIF_TERM get_parser_msg_group(
ErlNifEnv* env, ERL_NIF_TERM ref,
ERL_NIF_TERM* pres, ERL_NIF_TERM* mres, ERL_NIF_TERM* gres,
ParserRes** parser, FIXMsg** msg, FIXGroup** group)
{
int32_t arity;
ERL_NIF_TERM const* tuple = NULL;
if (!enif_get_tuple(env, ref, &arity, &tuple) || (arity != 2 && arity != 3))
{
return make_error(env, FIX_FAILED, "Wrong msg reference1.");
}
if (enif_compare(tuple[0], msg_atom) && enif_compare(tuple[0], group_atom))
{
return make_error(env, FIX_FAILED, "Wrong msg reference2.");
}
ERL_NIF_TERM const* data = NULL;
if (arity == 3) // this is a message
{
if (!enif_get_tuple(env, tuple[2], &arity, &data) || arity != 2)
{
return make_error(env, FIX_FAILED, "Wrong msg reference3.");
}
}
else // this is a group
{
if (!enif_get_tuple(env, tuple[1], &arity, &data) || arity != 3)
{
return make_error(env, FIX_FAILED, "Wrong msg reference4.");
}
}
*pres = data[0];
*mres = data[1];
if (arity == 3) // group exists
{
*gres = data[2];
}
void* res = NULL;
if (!enif_get_resource(env, *pres, parser_res, &res))
{
return make_error(env, FIX_FAILED, "Wrong parser resource.");
}
*parser = (ParserRes*)res;
if (!enif_get_resource(env, *mres, message_res, &res))
{
return make_error(env, FIX_FAILED, "Wrong message resource.");
}
*msg = ((MsgRes*)res)->msg;
if (arity == 3) // group exists
{
if (!enif_get_resource(env, *gres, group_res, &res))
{
return make_error(env, FIX_FAILED, "Wrong group resource.");
}
*group = *(FIXGroup**)res;
}
else
{
*group = NULL;
}
return ok_atom;
}
int main(int argc, char *argv[]) {
char console[MAX_LEN];
unsigned int err = 0;
extern unsigned long alloc_calls;
extern unsigned long free_calls;
handle_first = (struct handle_list*)mallocm(sizeof(struct handle_list));
if(handle_first == NULL) {
make_error("Failed to allocate memory for internal handle list!");
getchar();
return 1;
}
handle_first->next = NULL;
handle_first->handle = (void*)&handle_first;
handle_last = handle_first;
dispsplash();
printf("Initializing... ");
stats.start_time = (long)time(NULL);
if(!init()) {
make_error("Initialization failed (init() is 0).");
free_xion_memory();
getchar();
return 1;
}
bot_cmd_init();
printf("Done.\n");
if(!log_clean())
make_warning("Failed to clear log file.");
log_write("*** Program started. Executed as: %s", argv[0]);
printf("Connecting to %s:%d... ", bot.servaddr, bot.servport);
if((err = irc_connect(bot.servaddr, bot.servport)) != 0) {
printf("Failed to connect. ERROR %d\n\n", err);
log_write("Connecting failed with code: %d", err);
printf("Press Enter key to continue.");
getchar();
return 0;
}
printf("Connected.\n");
signal(SIGINT, extern_exit);
while(1) {
fgets(console, 512, stdin);
if(console[0] == '\n') break;
strrtok(console, "\r\n");
if(istrcmp(console, "exit")) break;
else if(istrcmp(console, "rehash")) {
printf("\nRehashing configuration...\n");
if(!rehashconfig())
printf("Failed.");
else
printf("Done.");
}
else irc_send(console, 1);
}
irc_quit(NULL);
free_xion_memory();
event_call(EVENT_EXIT, 0);
log_write("*** Program ended successfully. Allocation Calls: %d Free Calls: %d", stats.alloc_calls, stats.free_calls);
return 0;
}
/**
* \brief Creates and initializes the working data for the plan
* \param plan The Plan struct that holds the plan's data values.
* \return Error flag value
*/
int initDOPENACCGEMMPlan(void *plan){ // <- Replace YOUR_NAME with the name of your module.
if(!plan){
return make_error(ALLOC, generic_err); // <- This is the error code for one of the malloc fails.
}
Plan *p;
DOPENACCGEMM_DATA *d;
p = (Plan *)plan;
#ifdef HAVE_PAPI
int temp_event, i;
int PAPI_Events [NUM_PAPI_EVENTS] = PAPI_COUNTERS;
char *PAPI_units [NUM_PAPI_EVENTS] = PAPI_UNITS;
#endif //HAVE_PAPI
if(p){
d = (DOPENACCGEMM_DATA *)p->vptr;
p->exec_count = 0; // Initialize the plan execution count to zero.
perftimer_init(&p->timers, NUM_TIMERS); // Initialize all performance timers to zero.
#ifdef HAVE_PAPI
/* Initialize plan's PAPI data */
p->PAPI_EventSet = PAPI_NULL;
p->PAPI_Num_Events = 0;
TEST_PAPI(PAPI_create_eventset(&p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME);
//Add the desired events to the Event Set; ensure the dsired counters
// are on the system then add, ignore otherwise
for(i = 0; i < TOTAL_PAPI_EVENTS && i < NUM_PAPI_EVENTS; i++){
temp_event = PAPI_Events[i];
if(PAPI_query_event(temp_event) == PAPI_OK){
p->PAPI_Num_Events++;
TEST_PAPI(PAPI_add_event(p->PAPI_EventSet, temp_event), PAPI_OK, MyRank, 9999, PRINT_SOME);
}
}
PAPIRes_init(p->PAPI_Results, p->PAPI_Times);
PAPI_set_units(p->name, PAPI_units, NUM_PAPI_EVENTS);
TEST_PAPI(PAPI_start(p->PAPI_EventSet), PAPI_OK, MyRank, 9999, PRINT_SOME);
#endif //HAVE_PAPI
}
if(d){
int error;
acc_device_t my_device = acc_get_device_type();
acc_set_device_num(d->device_id, my_device);
//When OpenACC can report back on accelerator size, these two lines should be enabled
//d->device_memory = system_burn_accelerator_memory(d->device_id);
//d->device_memory -= SUB_FACTOR;
d->M = ((int)sqrt(d->device_memory/sizeof(double))) / 3;
size_t page_size = sysconf(_SC_PAGESIZE);
error = posix_memalign((void **)&(d->A_buffer),page_size,d->M*d->M*sizeof(double));
assert(error==0);
error = posix_memalign((void **)&(d->B_buffer),page_size,d->M*d->M*sizeof(double));
assert(error==0);
error = posix_memalign((void **)&(d->C_buffer),page_size,d->M*d->M*sizeof(double));
assert(error==0);
for(size_t idx=0; idx < d->M*d->M; idx++) {
d->A_buffer[idx] = (double)4.5;
d->B_buffer[idx] = (double)2.0;
d->C_buffer[idx] = (double)0.0;
}
}
return ERR_CLEAN; // <- This indicates a clean run with no errors. Does not need to be changed.
} /* initDOPENACCGEMMPlan */
