自学教程：C++ DBG_LOG函数代码示例

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

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

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

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 */voidnknexecd_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 */intengine_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;}