void mac_init(void)
{
#ifdef NODE_TYPE_DETECTOR
lora_init(UART_4, 9600);
#endif
#ifdef NODE_TYPE_GATEWAY
lora_init(UART_1, 9600);
#endif
portBASE_TYPE res = pdTRUE;
res = xTaskCreate(mac_task, //*< task body
"MacTask", //*< task name
200, //*< task heap
NULL, //*< tasK handle param
configMAX_PRIORITIES - 2, //*< task prio
NULL); //*< task pointer
if (res != pdTRUE)
{
DBG_LOG(DBG_LEVEL_ERROR, "mac task init failed\r\n");
}
mac_queue = xQueueCreate(10, sizeof(osel_event_t));
if (mac_queue == NULL)
{
DBG_LOG(DBG_LEVEL_ERROR, "mac_queue init failed\r\n");
}
mac_sent = xSemaphoreCreateBinary();
if (mac_sent == NULL)
{
DBG_LOG(DBG_LEVEL_ERROR, "mac_set init failed\r\n");
}
}
struct append_entries_output_t *get_append_entries_output(struct data_t *append_entries_response) {
struct append_entries_output_t *r = (struct append_entries_output_t *)malloc(
sizeof(struct append_entries_output_t));
if(!r) {
return NULL;
}
if(append_entries_response->length != APPEND_ENTRIES_RES_COUNT) {
free(r);
DBG_LOG(LOG_ERROR, "incorrect number of parameter in RPC response, expected = %d, got = %d",
APPEND_ENTRIES_RES_COUNT, append_entries_response->length);
return NULL;
}
for(int i = 0; i < APPEND_ENTRIES_RES_COUNT; i++) {
if(!append_entries_response->child[i]
|| append_entries_response->child[i]->type != RPC_INT
|| !append_entries_response->child[i]->value) {
free(r);
if(append_entries_response->child[i]) {
DBG_LOG(LOG_ERROR, "incorrect value in param in RPC, expected = %d, got = %d",
RPC_INT, append_entries_response->child[i]->type);
}
return NULL;
}
}
r->term = *(json_int_t *)append_entries_response->child[0]->value;
r->success = *(json_int_t *)append_entries_response->child[1]->value;
return r;
}
void _binpachilti_sink_connect_intern(binpac_sink* sink, const hlt_type_info* type, void** pobj, binpac_parser* parser, hlt_bytes* mtype, hlt_exception** excpt, hlt_execution_context* ctx)
{
__parser_state* state = hlt_malloc(sizeof(__parser_state));
state->parser = parser;
GC_CCTOR(state->parser, hlt_BinPACHilti_Parser, ctx);
state->pobj = *pobj;
GC_CCTOR_GENERIC(&state->pobj, type, ctx);
state->data = 0;
state->resume = 0;
state->disconnected = 0;
state->next = sink->head;
sink->head = state;
#ifdef DEBUG
if ( mtype ) {
hlt_string s = hlt_string_decode(mtype, Hilti_Charset_ASCII, excpt, ctx);
char* r1 = hlt_string_to_native(s, excpt, ctx);
char* r2 = hlt_string_to_native(parser->name, excpt, ctx);
DBG_LOG("binpac-sinks", "connected parser %s [%p] to sink %p for MIME type %s", r2, *pobj, sink, r1);
hlt_free(r1);
hlt_free(r2);
}
else {
char* p = hlt_string_to_native(parser->name, excpt, ctx);
DBG_LOG("binpac-sinks", "connected parser %s [%p] to sink %p", p, *pobj, sink);
hlt_free(p);
}
#endif
}
/*******************************************************************************
Function
*******************************************************************************/
static void autolink_mcu_parse_radio_savereq(uint8* data,uint32 len)
{
sint32 freq = byte_to_int(0,0,data[2],data[3]);
switch(data[0])
{
case MCU_RADIO_DATA1_ALREADY_SAVEFREQ_BAND_FM:
mcu_info_data.radio.save.band = RADIO_BAND_FM;
mcu_info_data.radio.save.freq = (float)freq/100;
DBG_LOG("GET:save freq FM %f\n",mcu_info_data.radio.save.freq);
break;
case MCU_RADIO_DATA1_ALREADY_SAVEFREQ_BAND_AM:
mcu_info_data.radio.save.band = RADIO_BAND_AM;
mcu_info_data.radio.save.freq = freq;
DBG_LOG("GET:save freq AM %d\n",mcu_info_data.radio.save.freq);
break;
default:
ERR_LOG("GET:save freq unkown\n");
return;
}
mcu_info_data.radio.save.freq_position = data[1];
DBG_LOG("GET:save freq radio position %d\n",mcu_info_data.radio.save.freq_position);
autolink_emit_mcu_state(TYPE_RADIO_SAVEFREQ,mcu_info_data);
return;
}
void binpac_dbg_reassembler_buffer(binpac_sink* sink, const char* msg, hlt_exception** excpt, hlt_execution_context* ctx)
{
#ifdef DEBUG
if ( ! sink->first_chunk ) {
DBG_LOG("binpac-sinks", "reassembler/%p: no data buffered", sink);
return;
}
char buffer[128];
int i = 0;
uint64_t initial_seq; // Initial sequence number.
uint64_t cur_rseq; // Sequence of last delivered byte + 1 (i.e., seq of next)
uint64_t last_reassem_rseq; // Sequence of last byte reassembled and delivered + 1.
uint64_t trim_rseq; // Sequence of last byte trimmed so far + 1.
__chunk* first_chunk; // First not yet reassembled chunk. Has ownership.
__chunk* last_chunk; // Last not yet reassembled chunk.
DBG_LOG("binpac-sinks", "reassembler/%p: %s ("
"cur_rseq=%" PRIu64 " "
"last_reassem_rseq=%" PRIu64 " "
"trim_rseq=%" PRIu64 ")",
sink, msg, sink->cur_rseq, sink->last_reassem_rseq, sink->trim_rseq);
for ( __chunk* c = sink->first_chunk; c; c = c->next ) {
snprintf(buffer, sizeof(buffer), "* chunk %d:", i);
binpac_dbg_reassembler(sink, buffer, c->data, c->rseq, (c->rupper - c->rseq), excpt, ctx);
i++;
}
#endif
}
struct data_t *make_request_vote_rpc_response(struct request_vote_output_t *output) {
struct data_t *res = (struct data_t *)malloc(sizeof(struct data_t));
if(!res){
DBG_LOG(LOG_FATAL, "memory allocation failed");
return NULL;
}
res->type = RPC_VECTOR;
res->length = REQUEST_VOTE_RES_COUNT;
res->child = (struct data_t **)malloc(
sizeof(struct data_t *)*REQUEST_VOTE_RES_COUNT);
if(!res->child) {
free(res);
DBG_LOG(LOG_FATAL, "memory allocation failed");
return NULL;
}
res->child[0] = uint64_to_data_t(output->term);
res->child[1] = uint32_to_data_t(output->vote_granted);
for(int i = 0; i < REQUEST_VOTE_RES_COUNT; i++) {
if(!res->child[i]) {
res->length = i;
free_data_t(res);
DBG_LOG(LOG_FATAL, "memory allocation failed");
return NULL;
}
}
return res;
}
struct method_t *make_request_vote_rpc_method(struct request_vote_input_t *input) {
struct data_t **params = (struct data_t **)malloc(
sizeof(struct data_t *)*REQUEST_VOTE_PARAM_COUNT);
if(!params) {
DBG_LOG(LOG_FATAL, "memory allocation failed");
return NULL;
}
params[0] = uint64_to_data_t(input->term);
params[1] = uint32_to_data_t(input->candidate_id);
params[2] = uint64_to_data_t(input->last_log_index);
params[3] = uint64_to_data_t(input->last_log_term);
char *method_name = private_strdup(REQUEST_VOTE_RPC);
struct method_t *request_vote =
(struct method_t *)malloc(sizeof(struct method_t));
if(!request_vote) {
DBG_LOG(LOG_FATAL, "memory allocation failed");
if(method_name) free(method_name);
for(int i = 0; i < REQUEST_VOTE_PARAM_COUNT; i++) {
if(params[i]) {
free_data_t(params[i]);
}
}
free(params);
return NULL;
}
request_vote->name = method_name;
request_vote->params = params;
request_vote->nparams = REQUEST_VOTE_PARAM_COUNT;
return request_vote;
}
int16_t Z_OSCMessage::setZ_OSCAddress(const char *_address){
oscAdrSize=(uint16_t)strlen(_address);
if( oscAdrSize > kMaxZ_OSCAdrCharactor ){
DBG_LOGLN("set Z_OSC max Z_OSC Adr err");
flush();
return 1;
}
if(oscAddress!=NULL) free(oscAddress);
oscAddress=(char*)calloc(1,oscAdrSize+1);
strcpy(oscAddress,_address);
oscAdrPacSize=getPackSize(oscAdrSize);
DBG_LOG("set Z_OSC Adr:");
DBG_LOG(oscAddress);
DBG_LOG(" size:");
DBG_LOG(oscAdrSize);
DBG_LOG(" packsize:");
DBG_LOGLN(oscAdrPacSize);
return 0;
}
int16_t Z_OSCMessage::setTypeTags(const char *_tags ){
uint8_t maxErr=0;
argsNum=(uint16_t)strlen(_tags);
if(argsNum > kMaxAugument){
DBG_LOGLN("set tags max arg err");
flush();
return 1;
}
typeTagSize = argsNum+1;
if(typeTag!=NULL) free(typeTag);
typeTag=(char*)calloc(1,argsNum+1);
strcpy(typeTag,_tags);
typeTagPacSize=getPackSize(typeTagSize);
argsNum=typeTagSize;
DBG_LOG("set TypeTag:");
DBG_LOG(typeTag);
DBG_LOG(" size:");
DBG_LOG(typeTagSize);
DBG_LOG(" packsize:");
DBG_LOGLN(typeTagPacSize);
return 0;
}
struct data_t *make_append_entries_rpc_response(struct append_entries_output_t *output) {
struct data_t *res = (struct data_t *)malloc(sizeof(struct data_t));
if(!res){
DBG_LOG(LOG_FATAL, "memory allocation failed");
return NULL;
}
res->type = RPC_VECTOR;
res->length = APPEND_ENTRIES_RES_COUNT;
res->child = (struct data_t **)malloc(
sizeof(struct data_t *)*APPEND_ENTRIES_RES_COUNT);
if(!res->child) {
free(res);
DBG_LOG(LOG_FATAL, "memory allocation failed");
return NULL;
}
res->child[0] = uint64_to_data_t(output->term);
res->child[1] = uint32_to_data_t(output->success);
for(int i = 0; i < REQUEST_VOTE_RES_COUNT; i++) {
if(!res->child[i]) {
res->length = i;
free_data_t(res);
DBG_LOG(LOG_FATAL, "memory allocation failed");
return NULL;
}
}
return res;
}
static int pxy_http_epollin(int fd, void * private_data)
{
con_t * con = (con_t *)private_data;
int rlen;
int ret;
rlen = MAX_CB_BUF - con->cb_totlen;
ret = recv(fd, &con->cb_buf[con->cb_totlen], rlen, 0);
if(ret <= 0) {
DBG_LOG(MSG, MOD_PROXYD, "[closing fd:%d]recv returned %d." , fd, ret) ;
close_conn(fd);
return TRUE;
}
con->cb_totlen += ret;
if (CHECK_CON_FLAG(con, CONF_CLIENT_SIDE)) {
glob_pxy_tot_size_from_client += ret;
} else {
glob_pxy_tot_size_from_origin_svr += ret;
}
DBG_LOG(MSG, MOD_PROXYD,
"[fd:%d]recv returned %d., fwding data to peer" ,
fd, ret) ;
forward_data_to_peer(con);
return TRUE;
}
/*******************************************************************************
Function Definition
*******************************************************************************/
static void autolink_mcu_packet_parse(uint8 cmd1,uint8* data, sint8 len)
{
DBG_LOG("NEW MSG\n");
DBG_LOG("CMD1=%X\n",cmd1);
switch(cmd1)
{
case MCU_CMD_SYSTEM:
autolink_mcu_parse_system(data,len);
break;
case MCU_CMD_KEY:
autolink_mcu_parse_key(data,len);
break;
case MCU_CMD_RADIO:
autolink_mcu_parse_radio(data,len);
break;
case MCU_CMD_SETTING:
autolink_mcu_parse_setting(data,len);
break;
case MCU_CMD_MEDIA:
autolink_mcu_parse_media(data,len);
break;
case MCU_CMD_UPDATE:
autolink_mcu_parse_update(data,len);
break;
case MCU_CMD_CAN:
autolink_mcu_parse_can(data,len);
break;
default:
ERR_LOG("UNKOWN MSG\n");
break;
}
return ;
}
struct request_vote_input_t *get_request_vote_input_params(struct data_t *params[], int nparams) {
struct request_vote_input_t *r = (struct request_vote_input_t *)malloc(sizeof(struct request_vote_input_t));
if(!r) {
return NULL;
}
if(nparams != REQUEST_VOTE_PARAM_COUNT) {
free(r);
DBG_LOG(LOG_ERROR, "incorrect number of parameter in RPC, expected = %d, got = %d",
REQUEST_VOTE_PARAM_COUNT, nparams);
return NULL;
}
for(int i = 0; i < REQUEST_VOTE_PARAM_COUNT; i++) {
if(!params[i]
|| params[i]->type != RPC_INT
|| !params[i]->value) {
free(r);
if(params[i]) {
DBG_LOG(LOG_ERROR, "incorrect value in %dth param in RPC, expected = %d, got = %d, value = %x",
(i+1), RPC_INT, params[i]->type, params[i]->value);
}
return NULL;
}
}
r->term = *(json_int_t *)params[0]->value;
r->candidate_id = *(json_int_t *)params[1]->value;
r->last_log_index = *(json_int_t *)params[2]->value;
r->last_log_term = *(json_int_t *)params[3]->value;
return r;
}
UILayoutHandle* UILayoutFactory::Load(const char* url)
{
int url_hash = StringHelper::Hash(url);
// Texture already loaded?
if (m_loaded_layouts.Contains(url_hash))
{
DBG_LOG("Loaded layout from cache: %s", url);
return m_loaded_layouts.Get(url_hash);
}
// Try and load texture!
UILayout* layout = Load_Without_Handle(url);
if (layout != NULL)
{
UILayoutHandle* handle = new UILayoutHandle(url, layout);
m_loaded_layouts.Set(url_hash, handle);
DBG_LOG("Loaded UI layout: %s", url);
return handle;
}
else
{
DBG_LOG("Failed to load UI layout: %s", url);
}
return NULL;
}
int VPEMGR_init(void)
{
int rv;
pthread_attr_t attr;
int stacksize = 128 * KiBYTES;
LIST_INIT( &vpemgr_req_head );
rv = pthread_attr_init(&attr);
if (rv) {
DBG_LOG(MSG, MOD_VPEMGR, "pthread_attr_init() failed, rv=%d", rv);
return 0;
}
rv = pthread_attr_setstacksize(&attr, stacksize);
if (rv) {
DBG_LOG(MSG, MOD_VPEMGR,
"pthread_attr_setstacksize() failed, rv=%d", rv);
return 0;
}
if( pthread_create(&vpemgr_req_thread_id, &attr, vpemgr_req_func, NULL)) {
DBG_LOG(MSG, MOD_VPEMGR, "Failed to create thread %s VPEMGR Initialization unsuccessful", "");
return 0;
}
glob_vpemgr_tot_reqs=0;
glob_vpemgr_err_dropped=0;
return 1;
}
struct request_vote_output_t *get_request_vote_output(struct data_t *request_vote_response) {
struct request_vote_output_t *r = (struct request_vote_output_t *)malloc(
sizeof(struct request_vote_output_t));
if(!r) {
return NULL;
}
if(request_vote_response->length != REQUEST_VOTE_RES_COUNT) {
free(r);
DBG_LOG(LOG_ERROR, "incorrect number of parameter in RPC response, expected = %d, got = %d",
REQUEST_VOTE_RES_COUNT, request_vote_response->length);
return NULL;
}
for(int i = 0; i < REQUEST_VOTE_RES_COUNT; i++) {
if(!request_vote_response->child[i]
|| request_vote_response->child[i]->type != RPC_INT
|| !request_vote_response->child[i]->value) {
free(r);
if(request_vote_response->child[i]) {
DBG_LOG(LOG_ERROR, "incorrect value in %dth param in RPC, expected = %d, got = %d",
(i+1), RPC_INT, request_vote_response->child[i]->type);
}
return NULL;
}
}
r->term = *(json_int_t *)request_vote_response->child[0]->value;
r->vote_granted = *(json_int_t *)request_vote_response->child[1]->value;
return r;
}
static void __trim(binpac_sink* sink, uint64_t rseq, void* user, hlt_exception** excpt, hlt_execution_context* ctx)
{
#ifdef DEBUG
if ( rseq != UINT64_MAX ) {
DBG_LOG("binpac-sinks", "trimming sink %p to rseq %" PRIu64, sink, rseq);
}
else {
DBG_LOG("binpac-sinks", "trimming sink %p to eod", sink);
}
#endif
__chunk* c = sink->first_chunk;
while ( c ) {
if ( c->rupper > rseq )
break;
if ( c->rupper < sink->cur_rseq && c->data )
__report_undelivered(sink, c->rseq, c->data, user, excpt, ctx);
__chunk* n = c->next;
__unlink_chunk(sink, c, excpt, ctx);
__delete_chunk(c, excpt, ctx);
c = n;
}
sink->trim_rseq = rseq;
}
Atlas* AtlasResourceCompiler::Load_Compiled()
{
std::string compiled_path = Get_Compiled_Path();
Platform* platform = Platform::Get();
// Compile time.
DBG_LOG("Loading atlas resource '%s'.", compiled_path.c_str());
// Load configuration settings.
ConfigFile config;
if (!config.Load(compiled_path.c_str()))
{
DBG_LOG("Failed to load atlas, config file could not be found: '%s'", compiled_path.c_str());
return NULL;
}
// Load the compile atlas file.
Atlas* atlas = new Atlas();
if (!atlas->Load_Compiled_Config(&config))
{
return NULL;
}
DBG_LOG("Finished loading compiled atlas from '%s'.", compiled_path.c_str());
return atlas;
}
GLuint CreateProgram(PP_Resource context, PPB_OpenGLES2* gl, const char* vs, const char* ps)
{
GLuint shaders[2];
GLuint program;
GLint status = 0;
shaders[0] = gl->CreateShader(context, GL_VERTEX_SHADER);
gl->ShaderSource(context, shaders[0], 1, &vs, 0);
gl->CompileShader(context, shaders[0]);
gl->GetShaderiv(context, shaders[0], GL_COMPILE_STATUS, &status);
if(!status)
{
char aszMessage[300];
char aszShaderLog[256];
gl->GetShaderInfoLog(context, shaders[0], 256, 0, aszShaderLog);
sprintf(aszMessage, DBG_LOG_PREFIX"Failed to vertex compile shader\n%s\n", aszShaderLog);
DBG_LOG(aszMessage);
}
shaders[1] = gl->CreateShader(context, GL_FRAGMENT_SHADER);
gl->ShaderSource(context, shaders[1], 1, &ps, 0);
gl->CompileShader(context, shaders[1]);
gl->GetShaderiv(context, shaders[1], GL_COMPILE_STATUS, &status);
if(!status)
{
char aszMessage[300];
char aszShaderLog[256];
gl->GetShaderInfoLog(context, shaders[1], 256, 0, aszShaderLog);
sprintf(aszMessage, DBG_LOG_PREFIX"Failed to pixel compile shader\n%s\n", aszShaderLog);
DBG_LOG(aszMessage);
}
program = gl->CreateProgram(context);
gl->AttachShader(context, program, shaders[0]);
gl->AttachShader(context, program, shaders[1]);
gl->BindAttribLocation(context, program, VA_POSITION_INDEX, "Position");
gl->BindAttribLocation(context, program, VA_TEXCOORD_INDEX, "TexCoords0");
gl->BindAttribLocation(context, program, VA_NORMAL_INDEX, "Normal");
gl->LinkProgram(context, program);
gl->GetProgramiv(context, program, GL_LINK_STATUS, &status);
if(!status)
{
DBG_LOG(DBG_LOG_PREFIX"Failed to link program\n");
}
return program;
}
/*******************************************************************************
Function
*******************************************************************************/
extern sint32 autolink_send_mcu_radio_set_freq(autolink_radio_st radio)
{
uint8 cmd;
uint8 msg_data[DATA_LEN_MAX];
uint8 len = 0;
cmd = MCU_CMD_RADIO;
msg_data[0] = MCU_RADIO_DATA0_ARMSET_FREQ;
DBG_LOG("SEND:set band %d\n",radio.set.band);
switch(radio.set.band)
{
case RADIO_BAND_FM:
msg_data[1] = MCU_RADIO_DATA1_ARMSET_BAND_FM;
break;
case RADIO_BAND_AM:
msg_data[1] = MCU_RADIO_DATA1_ARMSET_BAND_AM;
break;
default:
ERR_LOG("UNKOWN MSG\n");
return -1;
}
DBG_LOG("SEND:set freq_position %d\n",radio.set.freq_position);
msg_data[2] = radio.set.freq_position;
DBG_LOG("SEND:set type %d\n",radio.set_type);
switch(radio.set_type)
{
case RADIO_SET_SELECT:
msg_data[3] = MCU_RADIO_DATA1_ARMSET_SELECT;
break;
case RADIO_SET_SAVE:
msg_data[3] = MCU_RADIO_DATA1_ARMSET_SAVE;
break;
default:
ERR_LOG("UNKOWN MSG\n");
return -1;
}
DBG_LOG("SEND:set freq %f\n",radio.set.freq);
switch(radio.set.band)
{
case RADIO_BAND_AM:
int_to_byte(radio.set.freq,NULL,NULL,&msg_data[4],&msg_data[5]);
break;
case RADIO_BAND_FM:
int_to_byte(radio.set.freq*100,NULL,NULL,&msg_data[4],&msg_data[5]);
break;
default:
ERR_LOG("UNKOWN MSG\n");
return -1;
}
len = 6;
return autolink_mcu_send_msg(1,cmd,msg_data,len);
}
int start_server(struct server_context_t *s, int clientport) {
DBG_LOG(LOG_INFO, "[%s][%d] starting client handler at port = %d", ss[s->state], s->current_term, clientport);
start_client_handler(s, clientport);
DBG_LOG(LOG_INFO, "[%s][%d] starting server's event loop", ss[s->state], s->current_term);
return event_base_dispatch(s->base);
}
int unset_process_local_rank()
{
FILE *flock = NULL;
FILE *fcounter = NULL;
int expired = 0;
int process_id;
if (latency_model.max_local_processe_ranks < 2) {
return E_SUCCESS;
}
DBG_LOG(DEBUG, "Unsetting process local rank\n");
while (expired < MAX_LOCKED_RETRIES) {
// open lock file on Exclusive mode
flock = fopen(EMUL_LOCK_FILE, "wx");
if (flock == NULL) {
// DBG_LOG(DEBUG, "failed to create lock file\n");
usleep(LOCKED_WAIT_US);
expired++;
}
if (flock) break;
}
if (expired >= MAX_LOCKED_RETRIES) {
DBG_LOG(ERROR, "failed to unset process local rank\n");
return E_ERROR;
}
// lock acquired, read process counter file
if (access(EMUL_PROCESS_LOCAL_RANK_FILE, R_OK | W_OK) == 0) {
// if rank file does not exist, nothing to be done
// file exists, read the current value and decrement it
fcounter = fopen(EMUL_PROCESS_LOCAL_RANK_FILE, "r+");
if (fread(&process_id, sizeof(int), 1, fcounter) == 0) {
abort();
}
DBG_LOG(DEBUG, "Exiting process and reading current rank max %d\n", process_id);
if (process_id > 0) process_id--;
{
char hname[64];
gethostname(hname, sizeof(hname));
DBG_LOG(DEBUG, "Exiting process and writing new rank max %d on %s\n", process_id, hname);
}
rewind(fcounter);
fwrite(&process_id, sizeof(int), 1, fcounter);
fclose(fcounter);
}
// close and delete lock file
fclose(flock);
remove(EMUL_LOCK_FILE);
return E_SUCCESS;
}
void binpac_dbg_reassembler(binpac_sink* sink, const char* msg, hlt_bytes* data, uint64_t seq, int64_t len, hlt_exception** excpt, hlt_execution_context* ctx)
{
#ifdef DEBUG
// Log data with non-printable characters escaped and output trimmed if
// too long.
const char* dots = 0;
int8_t buffer[50];
buffer[0] = '\0';
hlt_bytes_size dlen = 0;
if ( data ) {
int i = 0;
hlt_iterator_bytes p = hlt_bytes_begin(data, excpt, ctx);
hlt_iterator_bytes end = hlt_bytes_end(data, excpt, ctx);
while ( ! hlt_iterator_bytes_eq(p, end, excpt, ctx) ) {
int8_t c = hlt_iterator_bytes_deref(p, excpt, ctx);
if ( isprint(c) )
buffer[i++] = c;
else {
if ( i < sizeof(buffer) - 5 )
i += snprintf((char*)(buffer + i), 5, "\\x%02x", c);
else
break;
}
if ( i >= sizeof(buffer) - 1 )
break;
p = hlt_iterator_bytes_incr(p, excpt, ctx);
}
buffer[i] = '\0';
dlen = hlt_bytes_len(data, excpt, ctx);
dots = hlt_iterator_bytes_eq(p, end, excpt, ctx) ? "" : " ...";
}
if ( data ) {
if ( len >= 0 )
DBG_LOG("binpac-sinks", "reassembler/%p: %s seq=% " PRIu64 " upper=%" PRIu64 " |%s%s| (%" PRIu64 " bytes)", sink, msg, seq, seq + len, buffer, dots, dlen);
else
DBG_LOG("binpac-sinks", "reassembler/%p: %s seq=% " PRIu64 " |%s%s| (%" PRIu64 " bytes)", sink, msg, seq, buffer, dots, dlen);
}
else {
if ( len >= 0 )
DBG_LOG("binpac-sinks", "reassembler/%p: %s seq=%" PRIu64 " upper=%" PRIu64 " <GAP>", sink, msg, seq, seq + len);
else
DBG_LOG("binpac-sinks", "reassembler/%p: %s seq=%" PRIu64 " <GAP>", sink, msg, seq);
}
#endif
}
/*
* method to print nknexecd_retval_t
*/
void
nknexecd_print_retval(nknexecd_retval_t *retval)
{
DBG_LOG(MSG, MOD_NKNEXECD, "in nknexecd_print_retval");
DBG_LOG(MSG, MOD_NKNEXECD, "retval.retval_reply_code is %d",
retval->retval_reply_code);
DBG_LOG(MSG, MOD_NKNEXECD, "retval->stdoutfile is %s",
retval->retval_stdoutfile);
DBG_LOG(MSG, MOD_NKNEXECD, "retval->stderrfile is %s",
retval->retval_stderrfile);
} /* nknexecd_print_retval */
int load_sparse_matrix_coo(mat_file_ctx_t *ctx,
int *row_indeces,
int *col_indeces,
double *values)
{
int ret = 0;
int i = 0;
ssize_t read;
size_t len = 0;
if (!MAT_FILE_CTX_INITED(ctx))
{
return -1;
}
/* First line with data is stored in ctx->cur_line.
* This line was read during parsing preamble */
do
{
int row_idx, col_idx;
double value;
sscanf(ctx->cur_line, "%d %d %lf\n", &row_idx, &col_idx, &value);
if ((row_idx > ctx->preamble.rows_cnt) || (col_idx > ctx->preamble.cols_cnt))
{
DBG_LOG("Element index is out of range, ctx->cur_line %d\n", ctx->cur_line_no);
ret = -1;
}
else
{
row_indeces[i] = row_idx - 1;
col_indeces[i] = col_idx - 1;
values[i] = value;
}
read = getline(&ctx->cur_line, &len, ctx->f);
if (read != -1)
{
ctx->cur_line_no++;
}
else
{
DBG_LOG("Error: too few rows in file\n");
ret = -1;
}
i++;
}
while ((i < ctx->preamble.nnz) && (ret == 0));
return ret;
}
/* load a texture from a file to currently bound texture */
int
engine_texture_loadfile(const char *filename)
{
SDL_Surface *surf;
GLint format;
const GLint bgra_swizzle[] = {GL_BLUE, GL_GREEN, GL_RED, GL_ALPHA};
const GLint bgr_swizzle[] = {GL_BLUE, GL_GREEN, GL_RED, GL_ONE };
const GLint red_swizzle[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
// TODO: support other file types ...
surf = SDL_LoadBMP(filename);
if (!surf) {
DBG_LOG("ERROR:%s:%s", filename, SDL_GetError());
return -1;
}
DBG_LOG("image \"%s\" %dx%d,%d (pitch %d)", filename,
surf->w, surf->h, surf->format->BitsPerPixel, surf->pitch);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
switch (surf->format->BytesPerPixel) {
case 4:
format = GL_RGBA;
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, bgra_swizzle);
break;
case 3:
format = GL_RGB;
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, bgr_swizzle);
break;
case 1:
/* one channel / intensity - shader will have to deal with palette */
format = GL_RED;
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, red_swizzle);
memset(surf->pixels, 255, surf->h * surf->pitch); // Hack in some pixels
break;
default:
DBG_LOG("ERROR:%s:unsupported image depth %d",
filename, surf->format->BytesPerPixel);
SDL_FreeSurface(surf);
return -1;
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, surf->w, surf->h, 0, format,
GL_UNSIGNED_BYTE, surf->pixels);
log_gl_error();
SDL_FreeSurface(surf);
return 0;
}
static int add_to_bucket(net_timer_data_t *nd, int interval_msecs)
{
int64_t msecs;
int bucket;
int rv;
clock_gettime(CLOCK_MONOTONIC, &nd->deadline_ts);
pthread_mutex_lock(&hrt_thread_mutex);
msecs = timespec_diff_msecs(&HRT_BASE_BUCKET_TS, &nd->deadline_ts);
if (msecs < 0) {
msecs = 0;
}
msecs += interval_msecs;
timespec_add_msecs(&nd->deadline_ts, interval_msecs);
if (msecs > MAX_INT_INTERVAL_MSECS) {
/*
* HRT thread has not run in greater than MAX_INT_INTERVAL_MSECS,
* signal it to process requests and return a retry indication.
*/
rv = pthread_cond_signal(&hrt_thread_cv);
if (rv) {
glob_hrt_cond_signal_failed++;
DBG_LOG(SEVERE, MOD_HRT, "CV signal failed, rv=%d", rv);
DBG_ERR(SEVERE, "CV signal failed, rv=%d", rv);
}
pthread_mutex_unlock(&hrt_thread_mutex);
glob_hrt_invalid_interval++;
return -1; // Retry
}
bucket = MSECS_TO_BUCKET(msecs);
bucket = (HRT_BASE_BUCKET + bucket) % TIMER_BUCKETS;
NTD_LINK_TAIL(&timer_bucket[bucket], nd, active_timer_data);
TRACE_BUCKET(bucket);
if (HRT_THREAD_SLEEPING &&
(timespec_cmp(&nd->deadline_ts, &HRT_THREAD_TS) < 0)) {
/*
* HRT Thread is sleeping beyond this request's timeout, signal it
* to recompute the sleep interval.
*/
rv = pthread_cond_signal(&hrt_thread_cv);
if (rv) {
glob_hrt_cond_signal_failed++;
DBG_LOG(SEVERE, MOD_HRT, "CV(2) signal failed, rv=%d", rv);
DBG_ERR(SEVERE, "CV(2) signal failed, rv=%d", rv);
}
}
pthread_mutex_unlock(&hrt_thread_mutex);
return 0; // Success
}
/**@brief Proximity Application initialization
* start the device scanning process
*/
static void pxp_app_init(void)
{
at_ble_status_t scan_status;
/* Initialize the scanning procedure */
scan_status = gap_dev_scan();
/* Check for scan status */
if (scan_status == AT_BLE_INVALID_PARAM) {
DBG_LOG("Scan parameters are invalid");
} else if (scan_status == AT_BLE_FAILURE) {
DBG_LOG("Scanning Failed Generic error");
}
}
int main(int argc, char *argv[]) {
if(argc < 2) {
printf("Usage: raftd <id> <basedir>\n");
return 1;
}
base64_init();
int id = atoi(argv[1]);
if(id < 1 || id > 3) {
printf("Usage: raftd <id>\n");
printf("provided <id> > 0 && <id> <= 3\n");
return 1;
}
srandom(id);
verbosity = LOG_DEBUG;
struct server_context_t *s = init_raft_server(id, argv[2],
"0.0.0.0", ports[id - 1], HTTP, 1000000l, 500000l);
int peers[2];
int peer_ports[2];
for(int i = 1, j = 0; i <= 3; i++) {
if(id != i) {
peers[j] = i;
peer_ports[j] = ports[i - 1];
j++;
}
}
printf("Server port = %d\n", ports[id - 1]);
printf("Peer ports = %d %d\n", peer_ports[0], peer_ports[1]);
const char *hosts[] = { "0.0.0.0", "0.0.0.0" };
if(s) {
if(add_pairs(s, 2, peers, hosts, peer_ports)) {
DBG_LOG(LOG_FATAL, "[%s][%d] Error while adding peers to server", ss[s->state], s->current_term);
deinit_raft_server(s);
return 1;
}
} else {
DBG_LOG(LOG_FATAL, "[?][?] Error while creating server instance");
exit(1);
}
int clientport = ports[id - 1] + 10;
printf("Client port = %d\n", clientport);
start_server(s, clientport);
deinit_raft_server(s);
base64_cleanup();
return 0;
}
int logi_dma_open(struct drvr_mem* mem_dev, dma_addr_t *physbuf)
{
#ifdef USE_DMA_ENGINE
struct dma_slave_config conf;
dma_cap_mask_t mask;
#endif
/* Allocate DMA buffer */
mem_dev->dma.buf = dma_alloc_coherent(NULL, MAX_DMA_TRANSFER_IN_BYTES,
&dmaphysbuf, 0);
if (!mem_dev->dma.buf) {
DBG_LOG("failed to allocate DMA buffer\n");
return -ENOMEM;
}
*physbuf = dmaphysbuf;
#ifdef USE_DMA_ENGINE
/* Allocate DMA channel */
dma_cap_zero(mask);
dma_cap_set(DMA_MEMCPY, mask);
mem_dev->dma.chan = dma_request_channel(mask, NULL, NULL);
if (!mem_dev->dma.chan)
return -ENODEV;
/* Configure DMA channel */
conf.direction = DMA_MEM_TO_MEM;
/*conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;*/
dmaengine_slave_config(mem_dev->dma.chan, &conf);
DBG_LOG("Using Linux DMA Engine API");
#else
mem_dev->dma.dma_chan = edma_alloc_channel(EDMA_CHANNEL_ANY, dma_callback,
NULL, EVENTQ_0);
if (mem_dev->dma.dma_chan < 0) {
DBG_LOG("edma_alloc_channel failed for dma_ch, error: %d\n",
mem_dev->dma.dma_chan);
return mem_dev->dma.dma_chan;
}
DBG_LOG("Using EDMA/DMA Engine");
#endif /* USE_DMA_ENGINE */
DBG_LOG("EDMA channel %d reserved\n", mem_dev->dma.dma_chan);
return 0;
}
