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