/* init_driver - optional function - called every time the driver is loaded. */ status_t init_driver (void){ int i; status_t status = B_OK; load_setting(); create_log(); TRACE_FUNCALLS("init_driver\n"); if((status = get_module(B_USB_MODULE_NAME, (module_info **)&usb)) == B_OK){ if(usb){ for(i = 0; i < DEVICES_COUNT; i++) usb_vision_devices[i] = 0; usb_vision_names[0] = NULL; (*usb->register_driver)(DRIVER_NAME, supported_devices, SIZEOF(supported_devices), DRIVER_NAME); (*usb->install_notify)(DRIVER_NAME, ¬ify_hooks); usb_vision_lock = create_sem(1, DRIVER_NAME"_devices_table_lock"); }else{ status = B_ERROR; TRACE_ALWAYS("init_driver failed: usb:%08x", usb); } }else TRACE_ALWAYS("init_driver failed:%lx cannot get a module %s", status, B_USB_MODULE_NAME); TRACE_FUNCRET("init_driver returns:%08x\n", status); return status; }
int main() { init_log_system(); log_t l = create_log("log.log"); int i = 0; uint32_t tick = GetSystemMs(); for( ;i < 20000000; ++i) { //buffer_t b = buffer_create_and_acquire(0,NULL,16); //buffer_t c = buffer_acquire(NULL,b); //buffer_release(&b); //buffer_release(&c); //int size = GetSize_of_pow2(16); //wpacket_t w = wpacket_create(0,NULL,4096,0); //wpacket_destroy(&w); //void *ptr = malloc(512); //free(ptr); log_write(l,"hello kenny",0); } //log_write(l,"hello kenny",0); /*log_write(l,"hello kennyhello kennyhello kennyhello kennyhello kennyhello kenny" "hello kennyhello kennyhello kennyhello kennyhello kennyhello kennyhello kenny" "hello kennyhello kennyhello kennyhello kennyhello kennyhello kennyhello kenny" "hello kennyhello kennyhello kennyhello kennyhello kennyhello kennyhello kenny" "hello kennyhello kennyhello kennyhello kennyhello kennyhello kennyhello kenny" "hello kennyhello kennyhello kennyhello kennyhello kennyhello kennyhello kenny" "hello kennyhello kennyvhello kennyhello kennyhello kennyhello kennyhello kenny",0);*/ printf("write finish:%u\n",GetSystemMs()-tick); getchar(); close_log_system(); };
void load_settings() { void *handle = load_driver_settings(DRIVER_NAME); if (handle == 0) return; gTraceOn = get_driver_boolean_parameter(handle, "trace", gTraceOn, true); gTraceState = get_driver_boolean_parameter(handle, "trace_state", gTraceState, true); gTraceRX = get_driver_boolean_parameter(handle, "trace_rx", gTraceRX, true); gTraceTX = get_driver_boolean_parameter(handle, "trace_tx", gTraceTX, true); gTraceStats = get_driver_boolean_parameter(handle, "trace_stats", gTraceStats, true); gTruncateLogFile = get_driver_boolean_parameter(handle, "reset_logfile", gTruncateLogFile, true); gAddTimeStamp = get_driver_boolean_parameter(handle, "add_timestamp", gAddTimeStamp, true); const char * logFilePath = get_driver_parameter(handle, "logfile", NULL, "/var/log/" DRIVER_NAME ".log"); if (logFilePath != NULL) { gLogFilePath = strdup(logFilePath); } unload_driver_settings(handle); create_log(); }
void create_db(const char *dir) { emkdir(dir); create_log(path(dir, "log")); //create_bag(dir, "bag"); create_mtree(path(dir, "mtree")); }
void test_calc_bad(void) { CALC_ELEMENT *t1, *t2; /* division by zero, simple */ t1 = create_number(9.0); t2 = create_number(0.0); t1 = create_bin_op('/', t1, t2); CU_ASSERT_NOT_EQUAL(calculate(&t1), 0); CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DIV_BY_ZERO, STATUS_CALC_DIV_BY_ZERO); free_calc_element(t1); /* division by zero, complex */ t1 = create_bin_op('/', create_number(4.0), create_bin_op('-', create_number(2.0), create_number(2.0))); CU_ASSERT_NOT_EQUAL(calculate(&t1), 0); CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DIV_BY_ZERO, STATUS_CALC_DIV_BY_ZERO); free_calc_element(t1); /* log zero */ t1 = create_log(create_number(0.0)); CU_ASSERT_NOT_EQUAL(calculate(&t1), 0); CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DOMAIN, STATUS_CALC_DOMAIN); free_calc_element(t1); /* log less than zero */ t1 = create_log(create_number(-3.0)); CU_ASSERT_NOT_EQUAL(calculate(&t1), 0); CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DOMAIN, STATUS_CALC_DOMAIN); free_calc_element(t1); /* log zero, complex */ t1 = create_log(create_bin_op ('*', create_number(0.0), create_number(28.0))); CU_ASSERT_NOT_EQUAL(calculate(&t1), 0); CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DOMAIN, STATUS_CALC_DOMAIN); free_calc_element(t1); /* x in the expression, simple */ t1 = create_x(); CU_ASSERT_NOT_EQUAL(calculate(&t1), 0); CU_ASSERT_EQUAL(t1->status & STATUS_X_PRESENT, STATUS_X_PRESENT); free_calc_element(t1); /* x in the expression, complex */ t1 = create_bin_op('-', create_x(), create_number(17)); CU_ASSERT_NOT_EQUAL(calculate(&t1), 0); CU_ASSERT_EQUAL(t1->status & STATUS_X_PRESENT, STATUS_X_PRESENT); free_calc_element(t1); }
void LOG_ERR(LOG_TYPE_EN type, const char* format, ...) { va_list args; va_start(args, format); create_log(LOG_LEVEL_ERR, type, format, args); va_end(args); }
void test_log_cf(void) { CALC_ELEMENT *t1 = create_number(1.0); t1 = create_log(t1); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_LOG); CU_ASSERT_EQUAL(t1->status, 0); CU_ASSERT_EQUAL(t1->value, 1.0); CU_ASSERT_PTR_NOT_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); t1 = create_x(); t1 = create_log(t1); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_LOG); CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT | STATUS_X_IN_LOG); CU_ASSERT_EQUAL(t1->value, 1.0); CU_ASSERT_PTR_NOT_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); }
int parse_log(CALC_ELEMENT ** e) { CALC_ELEMENT *t = NULL; if (!accept(PARSE_LOG)) { parser_error("\'log\'"); return -1; } if (parse_paren_expr(&t) == -1) return -1; else { *e = create_log(t); return 0; } }
/* attack a position */ int hit_pos(int index, int x, int y) { Players player1, player2; int ind; get_log(&player1, index); if (player1.map[y][x].presentation != EMPTY && player1.map[y][x].isVisible == 0) { if (index == 0) ind = 1; else ind = 0; get_log(&player2, ind); player2.score++; create_log(&player2, ind, player2.name); if (player2.score >= TOTAL_SLOTS) printf("<meta http-equiv=\"refresh\" content=0;url=\"?mode=5\">"); } player1.map[y][x].isVisible = 1; create_log(&player1, index, player1.name); }
/* ai hit user positions */ void ai_hit_pos() { Players player1, player2; int x, y, around[2] = {1, -1}; char *query; query = getenv("QUERY_STRING"); if ((sscanf(query, "mode=4&player=0&posx=%d&posy=%d", &x, &y) == 2)) { x += around[rand() % 2]; y += around[rand() % 2]; while (x >= MAP_SIZE || x < 0 || y < 0 || y >= MAP_SIZE) { x = rand() % MAP_SIZE; y = rand() % MAP_SIZE; } } else { x = rand() % MAP_SIZE; y = rand() % MAP_SIZE; } get_log(&player1, 0); if (player1.map[y][x].presentation != EMPTY && player1.map[y][x].isVisible == 0) { get_log(&player2, 1); player2.score++; create_log(&player2, 1, AI_NAME); if (player2.score >= TOTAL_SLOTS) printf("<meta http-equiv=\"refresh\" content=0;url=\"?mode=5\">"); } player1.map[y][x].isVisible = 1; create_log(&player1, 0, player1.name); }
int main(int ac, char **arv) { int error; #ifdef DEBUG /* logfile=/var/log/log.txt */ create_log(); fprintf(log_path, "ac = %d\n", ac); fflush(log_path); #endif /* setup signal handlers */ init_signals(); /* printer DEVICE ID and command line option check */ if((error = get_printer_devid()) < 0 || check_arg(ac,arv) < 0){ /* Not Canon printer or "--gui" option not found */ #ifdef DEBUG write_log("Now normal printing ......\n"); #endif print_normal(); exit(0); } /* create semapho and other setup */ if((error = lm_init(PRNT_PATH))){ exit(0); } /* monitor_process/print_process/status_process start */ lm_main_fork(); /* delete semapho */ remove_sem(sem_id); /* free memory (status monitor argv string) */ free_arg(); #ifdef DEBUG write_log("LM end \n"); #endif exit(0); }
void load_settings() { void* handle = load_driver_settings(DRIVER_NAME); if (handle == 0) return; gTraceMask = strtoul(get_driver_parameter(handle, "trace", "1", "0"), 0, 0); gTruncateLogFile = get_driver_boolean_parameter(handle, "truncate_logfile", gTruncateLogFile, true); gAddTimeStamp = get_driver_boolean_parameter(handle, "add_timestamp", gAddTimeStamp, true); const char* logFilePath = get_driver_parameter(handle, "logfile", NULL, "/var/log/" DRIVER_NAME ".log"); if (logFilePath != NULL) gLogFilePath = strdup(logFilePath); unload_driver_settings(handle); create_log(); }
void test_bad_axb(void) { CALC_ELEMENT *t1, *t2, *t3; double a, b; /* log */ t2 = create_number(6.0); t1 = create_log(t2); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1); free_calc_element(t1); /* bin op different from + */ t2 = create_number(-9.0); t3 = create_x(); t1 = create_bin_op('*', t2, t3); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1); free_calc_element(t1); /* two numbers */ t2 = create_number(2.0); t3 = create_number(4.2); t1 = create_bin_op('+', t2, t3); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1); free_calc_element(t1); /* two xs */ t2 = create_x(); t3 = create_x(); t1 = create_bin_op('*', t2, t3); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1); free_calc_element(t1); /* something wonky, like 4 * 3 + 2 */ t2 = create_number(4); t3 = create_number(3); t2 = create_bin_op('*', t2, t3); t3 = create_number(2); t1 = create_bin_op('+', t2, t3); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1); free_calc_element(t1); }
static int write_log_page(struct file *file, struct log_param *lp) { struct file_header hdr; uint16_t region; coffee_page_t log_page; int16_t log_record; uint16_t log_record_size; uint16_t log_records; cfs_offset_t offset; struct log_param lp_out; read_header(&hdr, file->page); adjust_log_config(&hdr, &log_record_size, &log_records); region = modify_log_buffer(log_record_size, &lp->offset, &lp->size); log_page = 0; if(HDR_MODIFIED(hdr)) { /* A log structure has already been created. */ log_page = hdr.log_page; log_record = find_next_record(file, log_page, log_records); if(log_record >= log_records) { /* The log is full; merge the log. */ PRINTF(("Coffee: Merging the file %s with its log\n", hdr.name)); return merge_log(file->page, 0); } } else { /* Create a log structure. */ log_page = create_log(file, &hdr); if(log_page == INVALID_PAGE) { return -1; } PRINTF(("Coffee: Created a log structure for file %s at page %u\n", hdr.name, (unsigned)log_page)); hdr.log_page = log_page; log_record = 0; } { char copy_buf[log_record_size]; lp_out.offset = offset = region * log_record_size; lp_out.buf = copy_buf; lp_out.size = log_record_size; if((lp->offset > 0 || lp->size != log_record_size) && read_log_page(&hdr, log_record, &lp_out) < 0) { COFFEE_READ(copy_buf, sizeof(copy_buf), absolute_offset(file->page, offset)); } memcpy(©_buf[lp->offset], lp->buf, lp->size); /* * Write the region number in the region index table. * The region number is incremented to avoid values of zero. */ offset = absolute_offset(log_page, 0); ++region; COFFEE_WRITE(®ion, sizeof(region), offset + log_record * sizeof(region)); offset += log_records * sizeof(region); COFFEE_WRITE(copy_buf, sizeof(copy_buf), offset + log_record * log_record_size); file->record_count = log_record + 1; } return lp->size; }
void test_canon_calc_good(void) { CALC_ELEMENT *t1, *t2; /* single number */ t1 = create_number(12.0); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM); CU_ASSERT_EQUAL(t1->status, 0); CU_ASSERT_EQUAL(t1->value, 12.0); CU_ASSERT_PTR_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); /* addition */ t1 = create_number(2.0); t2 = create_number(-3.5); t1 = create_bin_op('+', t1, t2); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM); CU_ASSERT_EQUAL(t1->status, 0); CU_ASSERT_EQUAL(t1->value, -1.5); CU_ASSERT_PTR_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); /* substraction */ t1 = create_number(-3.0); t2 = create_number(-4.25); t1 = create_bin_op('-', t1, t2); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM); CU_ASSERT_EQUAL(t1->status, 0); CU_ASSERT_EQUAL(t1->value, 1.25); CU_ASSERT_PTR_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); /* multiplication */ t1 = create_number(4); t2 = create_number(1.25); t1 = create_bin_op('*', t1, t2); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM); CU_ASSERT_EQUAL(t1->status, 0); CU_ASSERT_EQUAL(t1->value, 5.0); CU_ASSERT_PTR_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); /* division */ t1 = create_number(8.0); t2 = create_number(16.0); t1 = create_bin_op('/', t1, t2); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM); CU_ASSERT_EQUAL(t1->status, 0); CU_ASSERT_EQUAL(t1->value, 0.5); CU_ASSERT_PTR_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); /* natural logarithm */ t1 = create_number(1.0); t1 = create_log(t1); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM); CU_ASSERT_EQUAL(t1->status, 0); CU_ASSERT_EQUAL(t1->value, 0.0); CU_ASSERT_PTR_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); t1 = create_number(M_E); t1 = create_log(t1); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM); CU_ASSERT_EQUAL(t1->status, 0); CU_ASSERT_EQUAL(t1->value, 1.0); CU_ASSERT_PTR_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); /* a slightly more complex example (3 + (4 - 1)) * 5 */ t1 = create_number(4); t2 = create_number(1); t2 = create_bin_op('-', t1, t2); t1 = create_number(3); t1 = create_bin_op('+', t1, t2); t2 = create_number(5); t1 = create_bin_op('*', t1, t2); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_PTR_NOT_NULL(t1); CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM); CU_ASSERT_EQUAL(t1->status, 0); CU_ASSERT_EQUAL(t1->value, 30.0); CU_ASSERT_PTR_NULL(t1->left); CU_ASSERT_PTR_NULL(t1->right); free_calc_element(t1); }
int main(void) { socklen_t fromlen; int len, n, server_socket, fd_log; unsigned long int nb_written; struct sockaddr_in client_addr; struct sockaddr_in server_addr; unsigned char logbuf[MAX_LOG_PKT_SZ]; unsigned char sha1sum[SHA1_SZ]; sha1_context sha1; create_log(&fd_log); nb_written = 0; /* start the UDP listening server */ if ((server_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { server_err("Socket creation failed: %d\n", errno); exit(1); } n = 1; if (setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (void *) &n, sizeof ( n)) < 0) { server_err("Set socket options failed: %d\n", errno); exit(1); } server_addr.sin_family = AF_INET; server_addr.sin_port = htons(SHELL_LOG_SERVER_PORT); server_addr.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(server_socket, (struct sockaddr *) &server_addr, sizeof ( server_addr)) < 0) { server_err("Bind socket failed: %d\n", errno); exit(1); } if (fork() != 0) exit(0); setsid(); while (1) { fromlen = sizeof (client_addr); if ((len = recvfrom(server_socket, &logbuf[IP_SZ + LENGTH_SZ], BUF_SZ, 0, (struct sockaddr *) &client_addr, &fromlen)) < MIN_TRANSFER_PKT_SZ) { // sleep(1); continue; } server_dbg("Received packet: %d\n", len); sha1_starts(&sha1); sha1_update(&sha1, logbuf + IP_SZ + LENGTH_SZ + RC4_SZ, len - RC4_SZ - SHA1_SZ); sha1_finish(&sha1, sha1sum); if (memcmp(logbuf + IP_SZ + LENGTH_SZ + len - SHA1_SZ, sha1sum, SHA1_SZ) != 0) { server_err("SHA-1 checksum verification failed\n"); continue; } memcpy(logbuf, &client_addr.sin_addr.s_addr, IP_SZ); memcpy(&logbuf[IP_SZ], &len, LENGTH_SZ); server_dbg("From : %d.%d.%d.%d\n", (client_addr.sin_addr.s_addr) & 0xFF, (client_addr.sin_addr.s_addr >> 8) & 0xFF, (client_addr.sin_addr.s_addr >> 16) & 0xFF, (client_addr.sin_addr.s_addr >> 24) & 0xFF ); write(fd_log, logbuf, IP_SZ + LENGTH_SZ + len); nb_written += (IP_SZ + LENGTH_SZ + len); if (nb_written > MAX_LOG_SIZE) { nb_written = 0; close(fd_log); create_log(&fd_log); } } return ( 0); }
void test_canon_x(void) { CALC_ELEMENT *t1; double a, b; /* addition x + a * x */ t1 = create_bin_op('+', create_x(), create_bin_op('*', create_number(2.5), create_x())); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_X); CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT); CU_ASSERT_EQUAL(t1->value, 3.5); free_calc_element(t1); /* addition a * x + b */ t1 = create_bin_op('+', create_bin_op('*', create_number(1.25), create_x()), create_number(14)); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP); CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0); CU_ASSERT_EQUAL(a, 1.25); CU_ASSERT_EQUAL(b, 14); free_calc_element(t1); /* addition a * x + b + c */ t1 = create_bin_op('+', create_bin_op('+', create_bin_op('*', create_number(0.75), create_x()), create_number(6)), create_number(-3.5)); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP); CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0); CU_ASSERT_EQUAL(a, 0.75); CU_ASSERT_EQUAL(b, 2.5); free_calc_element(t1); /* addition (a1 * x + b1) + (a2 * x + b2) */ t1 = create_bin_op('+', create_ax_b(9.0, -1.25), create_ax_b(2.0, 6.5)); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP); CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0); CU_ASSERT_EQUAL(a, 11.0); CU_ASSERT_EQUAL(b, 5.25); free_calc_element(t1); /* multiplication a * x */ t1 = create_bin_op('*', create_x(), create_number(-9.0)); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_X); CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0); CU_ASSERT_EQUAL(a, -9.0); CU_ASSERT_EQUAL(b, 0); free_calc_element(t1); /* multiplication x * a */ t1 = create_bin_op('*', create_number(7.5), create_x()); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_X); CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0); CU_ASSERT_EQUAL(a, 7.5); CU_ASSERT_EQUAL(b, 0); free_calc_element(t1); /* multiplication c * (a * x + b) */ t1 = create_bin_op('*', create_number(19), create_ax_b(4, -0.5)); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP); CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0); CU_ASSERT_EQUAL(a, 76); CU_ASSERT_EQUAL(b, -9.5); free_calc_element(t1); /* multiplication (a * x + b) * c */ t1 = create_bin_op('*', create_ax_b(-6, 4.5), create_number(0.5)); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP); CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0); CU_ASSERT_EQUAL(a, -3.0); CU_ASSERT_EQUAL(b, 2.25); free_calc_element(t1); /* multiplication x * x */ t1 = create_bin_op('*', create_x(), create_x()); CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP); CU_ASSERT_EQUAL(t1->status, STATUS_X_NON_LINEAR | STATUS_X_PRESENT); free_calc_element(t1); /* multiplication x * (a * x + b) */ t1 = create_bin_op('*', create_x(), create_x()); CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP); CU_ASSERT_EQUAL(t1->status, STATUS_X_NON_LINEAR | STATUS_X_PRESENT); free_calc_element(t1); /* multiplication (2*x - (2*x - 3)) * (3x - 4) - false square, actually linear */ t1 = create_bin_op('*', create_bin_op('-', create_ax_b(2.0, 0.0), create_ax_b(2, -3)), create_ax_b(3.0, -4.0)); CU_ASSERT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP); CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0); CU_ASSERT_EQUAL(a, 9.0); CU_ASSERT_EQUAL(b, -12.0); free_calc_element(t1); /* division x / a */ t1 = create_bin_op('/', create_x(), create_number(2.0)); CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP); CU_ASSERT_EQUAL(t1->status, STATUS_X_IN_DIV | STATUS_X_PRESENT); free_calc_element(t1); /* log (ax + b) */ t1 = create_log(create_ax_b(9.0, -3.0)); CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0); CU_ASSERT_EQUAL(t1->calc_t, CALC_LOG); CU_ASSERT_EQUAL(t1->status, STATUS_X_IN_LOG | STATUS_X_PRESENT); free_calc_element(t1); }
int __wrap_main(int argc, char *argv[], char *envp[]) { int c; char *config_file = NULL; char *log_file = NULL; bool daemon = false; while ((c = getopt(argc, argv, "c:dhl:vV")) != -1) { switch (c) { case 'c': config_file = strdup(optarg); break; case 'd': daemon = true; break; case 'h': usage(); _exit(EXIT_SUCCESS); case 'l': log_file = strdup(optarg); break; case 'v': ++verbose; break; case 'V': printf("%s\n", openrelease_version()); _exit(EXIT_SUCCESS); case '?': usage(); _exit(EXIT_FAILURE); default: say_error("unmatched option: -%c", c); _exit(EXIT_FAILURE); } } create_log(log_file); config_init(config_file); if (getenv("OPENRELEASE_STAGE2") == NULL) { if (daemon) { if (daemonize(1, 0) == -1) { say_error("can't daemonize"); _exit(EXIT_FAILURE); } } if (stdio_wrap(config.input, config.output) == -1) { say_error("stdio_wrap failed"); _exit(EXIT_FAILURE); } putenv("OPENRELEASE_STAGE2=1"); execvp(argv[0], argv); } mmaps_init(); symfile_load(config.symfile); wrap_init(); debug_init(); key_action_init(); say_info("dive into RELEASE"); unsetenv("LD_PRELOAD"); argc = 1; if (optind != argc) { memmove(&argv[1], &argv[optind], (optind - argc) * sizeof(argv[0])); argc += optind - argc; } argv[argc] = NULL; __real_main(argc, argv, envp); _exit(EXIT_SUCCESS); return 0; }
int main(int ac, char *av[]) { int errorn; long total_output_spks; double input_traject_vars[NUM_JOINTS*3]; // Desired trajectory position, velocity and acceletarion double robot_state_vars[NUM_JOINTS*3]; // Actual robot position, velocity and acceleration double cerebellar_output_vars[NUM_OUTPUT_VARS]={0.0}; // Corrective cerebellar output torque double robot_inv_dyn_torque[NUM_JOINTS]; // Robot's inverse dynamics torque double total_torque[NUM_JOINTS]; // Total torque applied to the robot double *delayed_error_vars; double robot_error_vars[NUM_JOINTS]; // Joint error (PD correction) double cerebellar_learning_vars[NUM_OUTPUT_VARS]; // Error-related learning signals // Robot's dynamics variables mxArray *robot_inv_dyn_object=NULL, *robot_dir_dyn_object=NULL; struct integrator_buffers num_integration_buffers; // Integration buffers used to simulate the robot Simulation *neural_sim; int n_robot_joints; // Time variables double sim_time,cur_traject_time; float slot_elapsed_time,sim_elapsed_time; int n_traj_exec; // Delay line struct delay error_delay; // Variable for logging the simulation state variables struct log var_log; #if defined(REAL_TIME_WINNT) // Variables for consumed-CPU-time measurement LARGE_INTEGER startt,endt,freq; #elif defined(REAL_TIME_OSX) uint64_t startt, endt, elapsed; static mach_timebase_info_data_t freq; #elif defined(REAL_TIME_LINUX) // Calculate time taken by a request - Link with real-time library -lrt struct timespec startt, endt, freq; #endif #if defined(_DEBUG) && (defined(_WIN32) || defined(_WIN64)) // _CrtMemState state0; _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE); _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR); #endif #if defined(REAL_TIME_WINNT) if(!QueryPerformanceFrequency(&freq)) puts("QueryPerformanceFrequency failed"); #elif defined (REAL_TIME_LINUX) if(clock_getres(CLOCK_REALTIME, &freq)) puts("clock_getres failed"); #elif defined (REAL_TIME_OSX) // If this is the first time we've run, get the timebase. // We can use denom == 0 to indicate that sTimebaseInfo is // uninitialised because it makes no sense to have a zero // denominator is a fraction. if (freq.denom == 0 ) { (void) mach_timebase_info(&freq); } #endif // Load Matlab robot objects from Matlab files if(!(errorn=load_robot(ROBOT_VAR_FILE_NAME,ROBOT_BASE_VAR_NAME,&n_robot_joints,&robot_inv_dyn_object)) && \ !(errorn=load_robot(ROBOT_VAR_FILE_NAME,ROBOT_SIMUL_VAR_NAME,NULL,&robot_dir_dyn_object))) { if(!(errorn=allocate_integration_buffers(&num_integration_buffers,n_robot_joints))) // Initialize the buffers for numerical integration using the initial desired robot's state { // Initialize variable log if(!(errorn=create_log(&var_log, MAX_TRAJ_EXECUTIONS, TRAJECTORY_TIME))) { // Initialize EDLUT and load neural network files neural_sim=create_neural_simulation(NET_FILE, INPUT_WEIGHT_FILE, INPUT_ACTIVITY_FILE, OUTPUT_WEIGHT_FILE, OUTPUT_ACTIVITY_FILE, WEIGHT_SAVE_PERIOD, REAL_TIME_NEURAL_SIM); if(neural_sim) { double min_traj_amplitude[3], max_traj_amplitude[3]; // Position, velocity and acceleration calculate_input_trajectory_max_amplitude(TRAJECTORY_TIME,TRAJ_POS_AMP, min_traj_amplitude, max_traj_amplitude); // Calcula the maximum and minimum values of the desired trajectory total_output_spks=0L; puts("Simulating..."); sim_elapsed_time=0.0; errorn=0; // _CrtMemCheckpoint(&state0); for(n_traj_exec=0;n_traj_exec<MAX_TRAJ_EXECUTIONS && !errorn;n_traj_exec++) { calculate_input_trajectory(robot_state_vars, TRAJ_POS_AMP, 0.0); // Initialize simulated robot's actual state from the desired state (input trajectory) (position, velocity and acceleration) initialize_integration_buffers(robot_state_vars,&num_integration_buffers,n_robot_joints); // For the robot's direct reset_neural_simulation(neural_sim); // after each trajectory execution the network simulation state must be reset (pending activity events are discarded) init_delay(&error_delay, ERROR_DELAY_TIME); // Clear the delay line cur_traject_time=0.0; do { int n_joint; #if defined(REAL_TIME_WINNT) QueryPerformanceCounter(&startt); #elif defined(REAL_TIME_LINUX) clock_gettime(CLOCK_REALTIME, &startt); #elif defined(REAL_TIME_OSX) startt = mach_absolute_time(); #endif // control loop iteration starts sim_time=(double)n_traj_exec*TRAJECTORY_TIME + cur_traject_time; // Calculate absolute simulation time calculate_input_trajectory(input_traject_vars, TRAJ_POS_AMP, cur_traject_time); // Calculate desired input trajectory //ECEA generate_input_traj_activity(neural_sim, sim_time, input_traject_vars, min_traj_amplitude, max_traj_amplitude); // Translates desired trajectory (position and velocity) into spikes generate_robot_state_activity(neural_sim, sim_time, input_traject_vars, min_traj_amplitude, max_traj_amplitude); // Translates desired trajectory into spikes again to improve the input codification (using the robot's state input neurons) //ICEA // generate_robot_state_activity(neural_sim, sim_time, robot_state_vars, min_traj_amplitude, max_traj_amplitude); // Translates robot's current state (position and velocity) into spikes compute_robot_inv_dynamics(robot_inv_dyn_object,input_traject_vars,ROBOT_EXTERNAL_FORCE,ROBOT_GRAVITY,robot_inv_dyn_torque); // Calculate crude inverse dynamics of the base robot. They constitude the base robot's input torque for(n_joint=0;n_joint<NUM_JOINTS;n_joint++) // Calculate total torque from forward controller (cerebellum) torque plus base controller torque total_torque[n_joint]=robot_inv_dyn_torque[n_joint]+cerebellar_output_vars[n_joint*2]-cerebellar_output_vars[n_joint*2+1]; compute_robot_dir_dynamics(robot_dir_dyn_object,robot_state_vars,total_torque,robot_state_vars,&num_integration_buffers,ROBOT_EXTERNAL_FORCE,ROBOT_GRAVITY,SIM_SLOT_LENGTH); // Simulate the robot (direct dynamics). calculate_error_signals(input_traject_vars, robot_state_vars, robot_error_vars); // Calculated robot's performed error //delayed_error_vars=delay_line(&error_delay,robot_error_vars); // Delay in the error bars delayed_error_vars=robot_error_vars; // No delay in the error bars calculate_learning_signals(delayed_error_vars, cerebellar_output_vars, cerebellar_learning_vars); // Calculate learning signal from the calculated error generate_learning_activity(neural_sim, sim_time, cerebellar_learning_vars); // Translates the learning activity into spikes and injects this activity in the network errorn=run_neural_simulation_slot(neural_sim, sim_time+SIM_SLOT_LENGTH); // Simulation the neural network during a time slot total_output_spks+=(long)compute_output_activity(neural_sim, cerebellar_output_vars); // Translates cerebellum output activity into analog output variables (corrective torques) // control loop iteration ends #if defined(REAL_TIME_WINNT) QueryPerformanceCounter(&endt); // measures time slot_elapsed_time=(endt.QuadPart-startt.QuadPart)/(float)freq.QuadPart; // to be logged #elif defined(REAL_TIME_LINUX) clock_gettime(CLOCK_REALTIME, &endt); // Calculate time it took slot_elapsed_time = (endt.tv_sec-startt.tv_sec ) + (endt.tv_nsec-endt.tv_nsec )/((float)(1e9)); #elif defined(REAL_TIME_OSX) // Stop the clock. endt = mach_absolute_time(); // Calculate the duration. elapsed = endt - startt; slot_elapsed_time = 1e-9 * elapsed * freq.numer / freq.denom; #endif sim_elapsed_time+=slot_elapsed_time; log_vars(&var_log, sim_time, input_traject_vars, robot_state_vars, robot_inv_dyn_torque, cerebellar_output_vars, cerebellar_learning_vars, delayed_error_vars, slot_elapsed_time,get_neural_simulation_spike_counter(neural_sim)); // Store vars into RAM cur_traject_time+=SIM_SLOT_LENGTH; } while(cur_traject_time<TRAJECTORY_TIME-(SIM_SLOT_LENGTH/2.0) && !errorn); // we add -(SIM_SLOT_LENGTH/2.0) because of floating-point-type codification problems } // reset_neural_simulation(neural_sim); // _CrtMemDumpAllObjectsSince(&state0); if(errorn) printf("Error %i performing neural network simulation\n",errorn); printf("Total neural-network output spikes: %li\n",total_output_spks); printf("Total number of neural updates: %Ld\n",get_neural_simulation_event_counter(neural_sim)); printf("Mean number of neural-network spikes in heap: %f\n",get_accumulated_heap_occupancy_counter(neural_sim)/(double)get_neural_simulation_event_counter(neural_sim)); #if defined(REAL_TIME_WINNT) printf("Total elapsed time: %fs (time resolution: %fus)\n",sim_elapsed_time,1.0e6/freq.QuadPart); #elif defined(REAL_TIME_LINUX) printf("Total elapsed time: %fs (time resolution: %fus)\n",sim_elapsed_time,freq.tv_sec*1.0e6+freq.tv_nsec/((float)(1e3))); #elif defined(REAL_TIME_OSX) printf("Total elapsed time: %fs (time resolution: %fus)\n",sim_elapsed_time,1e-3*freq.numer/freq.denom); #endif save_neural_weights(neural_sim); finish_neural_simulation(neural_sim); } else { errorn=10000; printf("Error initializing neural network simulation\n"); } puts("Saving log file"); errorn=save_and_finish_log(&var_log, LOG_FILE); // Store logged vars in disk if(errorn) printf("Error %i while saving log file\n",errorn); } else { errorn*=1000; printf("Error allocating memory for the log of the simulation variables\n"); } free_integration_buffers(&num_integration_buffers); } else { errorn*=100; printf("Error allocating memory for the numerical integration\n"); } free_robot(robot_inv_dyn_object); free_robot(robot_dir_dyn_object); } else { errorn*=10; printf("Error loading the robot object from file: %s\n",ROBOT_VAR_FILE_NAME); } if(!errorn) puts("OK"); else printf("Error: %i\n",errorn); #if defined(_DEBUG) && (defined(_WIN32) || defined(_WIN64)) _CrtDumpMemoryLeaks(); #endif return(errorn); }
// function main ------------------------------------------------- int main(int argc,char** argv) { int i, j; // TO DO // check the number of command line arguments, if not 2, terminate // the program with a proper error message on the screen. if (argc != 2){ perror("You do not have 2 arguments!"); exit(EXIT_FAILURE); } // check if the single command line argument (argv[1]) has value 3 to 6, // if not, treminate the program with a proper error message on the if (3 < atoi(argv[1]) && atoi(argv[1]) > 6){ perror("You need 3 to 6 jobs!"); exit(EXIT_FAILURE); } else { number_of_jobs = atoi(argv[1]); } // screen. // set appropriately number_of_jobs // END TO DO create_log("assgn1.log"); // TO DO // prepare mymask1 -- SIGCHLD and SIGALRM blocked, all other signals free // using sigemptyset(), sigfillset(), sigaddset(), sigdelset() sigemptyset(&mymask1); //sigfillset(&mymask1); sigaddset(&mymask1, SIGCHLD); sigaddset(&mymask1, SIGALRM); // END TO DO // TO DO // instal mymask1 as the process signal mask using sigrpocmask() if (sigprocmask(SIG_SETMASK, &mymask1, NULL) == -1){ perror("Failed to install mymask1."); return -1; } // END TO DO // TO DO // prepare mymask2 -- all signals free // using sigemptyset(), sigfillset(), sigaddset(), sigdelset() sigemptyset(&mymask2); // END TO DO // TO DO // prepare jobmask -- all signals blocked except SIGUSR2 // using sigemptyset(), sigfillset(), sigaddset(), sigdelset() if (sigfillset(&jobmask) == -1){ perror("Failed to fill jobmask."); return -1; } if (sigdelset(&jobmask, SIGUSR2)){ perror("Failed to remove SIGUSR2 from jobmask."); return -1; } // END TO DO // TO DO // prepare SIGALRM disposition sa_alarm // its handler (sa_handler) is siga_handler() // its signal mask (sa_mask) must block all signals // its flags (sa_flags) must be set to SA_RESTART sa_alarm.sa_handler=siga_handler; sigemptyset(&sa_alarm.sa_mask); sa_alarm.sa_flags=SA_RESTART; // END TO DO // TO DO // instal SIGALRM disposition using sigaction() if (sigaction(SIGALRM, &sa_alarm, NULL) == -1){ perror("Failed to install SIGALRM disposition."); return -1; } // END TO DO // TO DO // prepare SIGCHLD disposition sa_chld // its handler (sa_handler) is sigc_handler() // its signal mask (sa_mask) must block all signals // its flags (sa_flags) must be set to SA_RESTART sa_chld.sa_handler=sigc_handler; sigemptyset(&sa_chld.sa_mask); sa_chld.sa_flags=SA_RESTART; // END TO DO // TO DO // instal SIGCHLD disposition using sigaction() if (sigaction(SIGCHLD, &sa_chld, NULL) == -1){ perror("Failed to install SIGCHLD disposition."); return -1; } // END TO DO // TO DO //Create empty queues lP = createQueue(); mP = createQueue(); hP = createQueue(); // END TO DO // TO DO // create a data structure to keep information about jobs - PID, number of runs // put all jobs in the high-priority queue for(i = 0; i < number_of_jobs; i++) { pid = create_job(i); hP.push(&hP, pid, i, 0); //currentPID = pid; } // END TO DO // TO DO // in a loop // if all queues are empty // record it in the log by Msg("All jobs done\n"); // and display it on the screen by msg("All jobs done\n"); // and terminate the loop while(1){ if (hP.isEmpty(&hP) == 1 && mP.isEmpty(&mP) == 1 && lP.isEmpty(&lP) == 1){ Msg("All jobs done\n"); msg("All jobs done\n"); break; } //Demote all necessary jobs and put them back in their respective queue // hP.display(&hP); // mP.display(&mP); // lP.display(&lP); // "switch on" the first job from the highest-priority non-empty queue // by sending it the SIGUSR1 signal (using sigsend()) // Record it in the log using // Msg("Switched on high-priority job %d\n",job number); or // Msg("Switched on medium-priority job %d\n",job number); or // Msg("Switched on low-priority job %d\n",job number); if (hP.isEmpty(&hP) == 0){ currentRuns = hP.peekRuns(&hP); currentJob = hP.peekJob(&hP); currentPID = hP.peekProcess(&hP); Msg("Switched on high-priority job %d\n", currentJob); msg("Switched on high-priority job %d\n", currentJob); kill(currentPID, SIGUSR1); } else if (mP.isEmpty(&mP) == 0){ currentRuns = mP.peekRuns(&mP); currentJob = mP.peekJob(&mP); currentPID = mP.peekProcess(&mP); Msg("Switched on medium-priority job %d\n", currentJob); msg("Switched on medium-priority job %d\n", currentJob); kill(currentPID, SIGUSR1); } else { currentRuns = lP.peekRuns(&lP); currentJob = lP.peekJob(&lP); currentPID = lP.peekProcess(&lP); Msg("Switched on low-priority job %d\n", currentJob); msg("Switched on low-priority job %d\n", currentJob); kill(currentPID, SIGUSR1); } alarm(1); sigsuspend(&mymask2); // announce it on the screen using corresponding msg(); // set alarm for 1 second using alarm() // switch the current signal process mask mymask1 to mymask2 while // going to suspension using sigsuspend() // (thus only SIGCHLD or SIGALRM will wake it up from suspension // SIGCHLD indicates that the job that is currently executing just // terminated, SIGALRM indicates that the time for the job currently // executing is up and it must be "switched off") } // end loop // END TO DO return 0; }// end function main
int main(int argc, char **argv) { create_log(); char* path; if (argc == 2) { path = argv[1]; } bool termino = false; bool finaliza_nivel = false; t_personaje* personaje = configuracion_inicializar(path); signal(SIGTERM, handler); signal(SIGUSR1, handler); signal(SIGINT, handler); t_log* logger = recibir_logger(); personaje->nivel_actual = personaje->planDeNiveles; // pj sin plan de niveles-->pasa directo koopa t_info_nivel* info_nivel=conectarme_y_pedir_a_orquestador(personaje->nivel_actual); personaje_conecta(info_nivel); personaje->nodo_recurso_actual=personaje->nivel_actual ->objetivos->head; char envioAPlanificador[2]; while (termino == false) { // recibir turno del planificador char* data = receiveBytes(personaje->sk_planificador, sizeof(char), logger); if(data != NULL) //log_debug(logger, "{%c} [Main] recibi sizeof(char) del planificador...",personaje->id); if((data != NULL) && (data[0] == PERSONAJE_MOVETE)){ log_info(logger, "{%c} [Main] Recibi turno del Planificador del %s...",personaje->id,personaje->nivel_actual->nivel); if ((personaje->nivel_actual != NULL)) { //calculo movimiento y nivel me mueve hacer_movimiento(personaje->sk_nivel, &personaje->nodo_recurso_actual); if (llega_a_destino(personaje->actual, personaje->destino)) { log_info(logger, "{%c} [Main] Llegue a destino...",personaje->id); // le solicita a nivel el recurso y devuelve si me lo otorgo o no, ene sta parte el pj se bloquea-->esta bien! char* respuesta_a_solicitud = solicitar_recurso_a_nivel(); switch (respuesta_a_solicitud[0]) { case RECURSO_OTORGADO: { //avanzo al proximo recurso o nivel char* recurso = (char*) (personaje->nodo_recurso_actual->data); log_info(logger, "{%c} [Main] Recibi el recurso: %c ...",personaje->id,*recurso); finaliza_nivel = false; termino = avanzar_proximo_objetivo(&finaliza_nivel); if(!finaliza_nivel){ //notificar al planificador PERSONAJE_MOVIO envioAPlanificador[0] = PERSONAJE_MOVIO; log_info(logger, "{%c} [Main] Sending PERSONAJE_MOVIO al Planificador...",personaje->id); sendBytes(personaje->sk_planificador,&envioAPlanificador,sizeof(char)*2, logger); log_info(logger, "{%c} [Main] Send PERSONAJE_MOVIO al Planificador del %s...",personaje->id,personaje->nivel_actual->nivel); } break; } case NO_HAY_RECURSOS: { ////notificar al planificador PERSONAJE_BLOQUEADO y ID de recurso personaje->bloqueado = 1; envioAPlanificador[0] = PERSONAJE_BLOQ; char* id_rec = (char*) (personaje->nodo_recurso_actual->data); envioAPlanificador[1] = *id_rec; log_info(logger, "{%c} [Main] No hay recurso: %c, ME ESTOY BLOQUEANDO...",personaje->id,envioAPlanificador[1]); log_info(logger, "{%c} [Main] Sending PERSONAJE_BLOQ al Planificador...",personaje->id); sendBytes(personaje->sk_planificador,&envioAPlanificador,sizeof(char)*2, logger); log_info(logger, "{%c} [Main] Send realizado con PERSONAJE_BLOQ al Planificador...",personaje->id); //tengo que hacer un recibe aca asi me bloqueo hasta no aver conseguido el recurso // //pollcito // struct pollfd pollcito; // pollcito.fd=*personaje->sk_planificador; // pollcito.events=POLLIN; // pollcito.revents=0; // bool boolean=false; // while (boolean==false) { // poll(&pollcito, 2,50);//timeout 50 // if (pollcito.revents == POLLIN) { // boolean=true; char* data = receiveBytes(personaje->sk_planificador, sizeof(char), logger); if(data != NULL){ switch(data[0]){ case PERSONAJE_DESBLOQUEATE:{ log_info(logger, "{%c} [Main] Recibi PERSONAJE_DESBLOQUEATE del Planificador...",personaje->id); personaje->bloqueado = 0; finaliza_nivel = false; termino = avanzar_proximo_objetivo(&finaliza_nivel); if(!finaliza_nivel) { char envioAPlataforma[2]; envioAPlataforma[0] = IM_READY; envioAPlataforma[1] = personaje->id; log_info(logger,"{%c}[Main]: Sending IM_READY ...",personaje->id); sendBytes(personaje->sk_planificador,envioAPlataforma,sizeof(char)*2, logger); log_info(logger,"{%c}[Main]: Send realizado IM_READY ...",personaje->id); } break; } case TE_MATE:{ log_info(logger,"{%c} [Main] Recibi TE_MATE, me mataron por interbloqueo",personaje->id); personaje->bloqueado = 0; personaje_morir(); t_info_nivel* info_nivel = conectarme_y_pedir_a_orquestador(personaje->nivel_actual); //usleep(RECONEXION_LUEGO_DE_MUERTE); personaje_conecta(info_nivel); break; } } // } // } } break; } } } else{//No llegue a destino, entonces no solicite nada. envioAPlanificador[0] = PERSONAJE_MOVIO; sendBytes(personaje->sk_planificador,&envioAPlanificador,sizeof(char)*2, logger); log_info(logger, "{%c} [Main] Send PERSONAJE_MOVIO al Planificador del %s...",personaje->id,personaje->nivel_actual->nivel); } } } if(personaje->haceSigterm == 1){ log_debug(logger,"[MAIN] Valor de haceSigterm = %d",personaje->haceSigterm); personaje->haceSigterm = funcionDelSigterm(); log_debug(logger,"[MAIN] Valor de haceSigterm = %d",personaje->haceSigterm); } } destruir_personaje(personaje); destruir_log(); return EXIT_SUCCESS; }