static void init (void) { Any_Type arg; size_t size; sess_private_data_offset = object_expand (OBJ_SESS, sizeof (Sess_Private_Data)); st.len_hist_alloced = 16; size = st.len_hist_alloced*sizeof (st.len_hist[0]); st.len_hist = malloc (size); memset (st.len_hist, 0, size); st.rate_min = DBL_MAX; if (!st.len_hist) { fprintf (stderr, "%s.sess_stat: Out of memory\n", prog_name); exit (1); } arg.l = 0; event_register_handler (EV_PERF_SAMPLE, perf_sample, arg); event_register_handler (EV_SESS_NEW, sess_created, arg); event_register_handler (EV_SESS_DESTROYED, sess_destroyed, arg); event_register_handler (EV_CONN_CONNECTED, conn_connected, arg); event_register_handler (EV_CALL_RECV_STOP, call_done, arg); }
static void init (void) { Any_Type arg; sess_private_data_offset = object_expand (OBJ_SESS, sizeof (Sess_Private_Data)); call_private_data_offset = object_expand (OBJ_CALL, sizeof (Call_Private_Data)); arg.l = 0; event_register_handler (EV_CALL_ISSUE, call_issue, arg); event_register_handler (EV_CALL_RECV_HDR, call_recv_hdr, arg); }
void session_init (void) { Any_Type arg; if (!param.max_conns) param.max_conns = MAX_CONN; if (!param.max_piped) { if (param.http_version >= 0x10001) param.max_piped = MAX_PIPED; else /* no pipelining before HTTP/1.1... */ param.max_piped = 1; } if (param.max_conns > MAX_CONN) { fprintf (stderr, "%s.session_init: --max-conns must be <= %u\n", prog_name, MAX_CONN); exit (1); } if (param.max_piped > MAX_PIPED) { fprintf (stderr, "%s.session_init: --max-piped-calls must be <= %u\n", prog_name, MAX_PIPED); exit (1); } max_qlen = param.max_conns * param.max_piped; sess_private_data_offset = object_expand (OBJ_SESS, sizeof (Sess_Private_Data)); conn_private_data_offset = object_expand (OBJ_CONN, sizeof (Conn_Private_Data)); call_private_data_offset = object_expand (OBJ_CALL, sizeof (Call_Private_Data)); arg.l = 0; event_register_handler (EV_SESS_DESTROYED, sess_destroyed, arg); event_register_handler (EV_CONN_CONNECTED, conn_connected, arg); event_register_handler (EV_CONN_FAILED, conn_failed, arg); event_register_handler (EV_CONN_TIMEOUT, conn_timeout, arg); event_register_handler (EV_CALL_RECV_STOP, call_done, arg); }
void init_wlog (void) { struct stat st; Any_Type arg; int fd; fd = open (param.wlog.file, O_RDONLY, 0); if (fd == -1) panic ("%s: can't open %s\n", prog_name, param.wlog.file); fstat (fd, &st); if (st.st_size == 0) panic ("%s: file %s is empty\n", prog_name, param.wlog.file); /* mmap anywhere in address space: */ fbase = (char *) mmap (0, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); if (fbase == (char *) -1) panic ("%s: can't mmap the file: %s\n", prog_name, strerror (errno)); close (fd); /* set the upper boundary: */ fend = fbase + st.st_size; /* set current entry: */ fcurrent = fbase; arg.l = 0; event_register_handler (EV_CALL_NEW, (Event_Handler) set_uri, arg); }
static void init (void) { Any_Type arg; struct stat st; int fd; if (param.additional_header) extra = unescape (param.additional_header, &extra_len); if (param.additional_header_file) { fd = open (param.additional_header_file, O_RDONLY); if (fd < 0) fprintf (stderr, "%s: failed to open header file\n", prog_name); else { if (fstat(fd, &st) < 0) fprintf (stderr, "%s: failed to stat header file\n", prog_name); else { extra_file = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0); if (extra_file == (char *)MAP_FAILED) { fprintf (stderr, "%s: failed to map header file\n", prog_name); extra_file = NULL; } else file_len = st.st_size; } close(fd); } } if (param.method) method_len = strlen (param.method); arg.l = 0; event_register_handler (EV_CALL_NEW, call_created, arg); }
static void init (void) { Any_Type arg; session_init (); sess_private_data_offset = object_expand (OBJ_SESS, sizeof (Sess_Private_Data)); rg_sess.rate = ¶m.rate; rg_sess.tick = sess_create; rg_sess.arg.l = 0; arg.l = 0; event_register_handler (EV_SESS_DESTROYED, sess_destroyed, arg); event_register_handler (EV_CALL_DESTROYED, call_destroyed, arg); }
static void init (void) { Any_Type arg; call_private_data_offset = object_expand (OBJ_CALL, sizeof (Call_Private_Data)); arg.l = 0; if ((param.print_request & (PRINT_HEADER | PRINT_BODY)) != 0) event_register_handler (EV_CALL_SEND_RAW_DATA, send_raw_data, arg); if ((param.print_reply & PRINT_HEADER) != 0) event_register_handler (EV_CALL_RECV_RAW_DATA, recv_raw_data, arg); if ((param.print_reply & PRINT_BODY) != 0) event_register_handler (EV_CALL_RECV_DATA, recv_data, arg); if ((param.print_reply & (PRINT_HEADER | PRINT_BODY)) != 0) event_register_handler (EV_CALL_RECV_STOP, recv_stop, arg); event_register_handler (EV_CALL_DESTROYED, call_destroyed, arg); }
static void init(void) { Any_Type arg; uri_len = strlen(param.uri); arg.l = 0; event_register_handler(EV_CALL_NEW, (Event_Handler) set_uri, arg); }
static void init(void) { Any_Type arg; rg.arg.l = 0; rg.tick = make_conn; arg.l = 0; event_register_handler(EV_CONN_DESTROYED, (Event_Handler) destroyed, arg); }
void app_main(void *data) { EatEvent_st event; EatEntryPara_st *para; event_handler_func func = NULL; APP_InitRegions();//Init app RAM APP_init_clib(); para = (EatEntryPara_st*)data; memcpy(&app_para, para, sizeof(EatEntryPara_st)); eat_trace(" App Main ENTRY update:%d result:%d", app_para.is_update_app,app_para.update_app_result); if(app_para.is_update_app && app_para.update_app_result) { eat_update_app_ok(); } eat_trace(" app_main ENTRY"); //event_register_handler(EAT_EVENT_TIMER, timer_proc); //event_register_handler(EAT_EVENT_KEY, key_proc); event_register_handler(EAT_EVENT_MDM_READY_RD, (event_handler_func)mdm_rx_proc); //event_register_handler(EAT_EVENT_MDM_READY_WR, mdm_tx_proc); //event_register_handler(EAT_EVENT_INT, int_proc); //event_register_handler(EAT_EVENT_UART_READY_RD, uart_rx_proc); //event_register_handler(EAT_EVENT_UART_READY_WR, uart_tx_proc); //event_register_handler(EAT_EVENT_UART_SEND_COMPLETE, uart_send_complete_proc); //event_register_handler(EAT_EVENT_USER_MSG, user_msg_proc); event_register_handler(EAT_EVENT_ADC, (event_handler_func)adc_event_proc); while(EAT_TRUE) { eat_get_event(&event); eat_trace("%s-%d:msg %x", __FILE__, __LINE__,event.event); func = EventHandlerTable[event.event]; if(event.event < EAT_EVENT_NUM && func != NULL) { (*func)(&event); } } }
static void init (void) { const char *slash; Any_Type arg; #ifdef UW_CALL_STATS if (param.call_stats >= 0) { fprintf(stderr, "Can not use --call-stats with --wsesspage\n"); exit(1); } #endif /* UW_CALL_STATS */ slash = strrchr (param.uri, '/'); if (slash) prefix_len = (slash + 1) - param.uri; else panic ("%s: URI specified with --uri must be absolute", prog_name); prefix = strdup (param.uri); prefix[prefix_len] = '\0'; session_init (); call_private_data_offset = object_expand (OBJ_CALL, sizeof (Call_Private_Data)); sess_private_data_offset = object_expand (OBJ_SESS, sizeof (Sess_Private_Data)); rg_sess.rate = ¶m.rate; rg_sess.tick = sess_create; rg_sess.arg.l = 0; arg.l = 0; event_register_handler (EV_CALL_RECV_HDR, call_recv_hdr, arg); event_register_handler (EV_CALL_RECV_DATA, call_recv_data, arg); event_register_handler (EV_SESS_DESTROYED, sess_destroyed, arg); event_register_handler (EV_CALL_DESTROYED, call_destroyed, arg); }
void rate_generator_start(Rate_Generator *rg, Event_Type completion_event) { Time(*func)( struct Rate_Generator *rg); Any_Type arg; Time delay; /* Initialize random number generator with the init values here, all rate generators (although independent) will follow the same sequence of random values. We factor in the client's id to make sure no two machines running httperf generate identical random numbers. May want to pass these values as args to rate_generator_start in the future. */ rg->xsubi[0] = 0x1234 ^ param.client.id; rg->xsubi[1] = 0x5678 ^ (param.client.id << 8); rg->xsubi[2] = 0x9abc ^ ~param.client.id; arg.vp = rg; if (rg->rate->rate_param > 0.0) { switch (rg->rate->dist) { case DETERMINISTIC: func = next_arrival_time_det; break; case UNIFORM: func = next_arrival_time_uniform; break; case EXPONENTIAL: func = next_arrival_time_exp; break; case VARIABLE: func = next_arrival_time_variable; break; default: fprintf(stderr, "%s: unrecognized interarrival distribution %d\n", prog_name, rg->rate->dist); exit(-1); } rg->next_interarrival_time = func; delay = (*func)(rg); /* bias `next time' so that timeouts are rounded to the closest tick: */ rg->next_time = timer_now() + delay; rg->timer = timer_schedule((Timer_Callback) tick, arg, delay); } else /* generate callbacks sequentially: */ event_register_handler(completion_event, done, arg); rg->start = timer_now(); rg->done = ((*rg->tick)(rg->arg) < 0); }
static void init (void) { Any_Type arg; if (param.additional_header) extra = unescape (param.additional_header, &extra_len); if (param.method) method_len = strlen (param.method); arg.l = 0; event_register_handler (EV_CALL_NEW, call_created, arg); }
void kb_setup(void) { // Clock always input, pull-up enabled KB_CLK_DDR &= ~_BV(KB_CLK_BIT); KB_CLK_PORT |= _BV(KB_CLK_BIT); // Data starts as input, pull-up enabled KB_DATA_PORT |= _BV(KB_DATA_BIT); KB_DATA_DDR &= ~_BV(KB_DATA_BIT); // External interrupt for PORTE7 EICRB = (EICRB | 0x80) & ~0x40; // int7: trigger on falling edge EIMSK &= ~0x80; // disable int7 until required _ticks_until_reset = (uint8_t)((uint16_t)500 / TVMillisPerTickTimer0); event_register_handler(EVENT_TYPE_TICK, _tick_handler, NULL); }
static void init (void) { Any_Type arg; basic.conn_lifetime_min = DBL_MAX; basic.reply_rate_min = DBL_MAX; arg.l = 0; #ifdef EXTENDED_STATS start=timer_now(); #endif event_register_handler (EV_PERF_SAMPLE, perf_sample, arg); event_register_handler (EV_CONN_FAILED, conn_fail, arg); event_register_handler (EV_CONN_TIMEOUT, conn_timeout, arg); event_register_handler (EV_CONN_NEW, conn_created, arg); event_register_handler (EV_CONN_CONNECTING, conn_connecting, arg); event_register_handler (EV_CONN_CONNECTED, conn_connected, arg); event_register_handler (EV_CONN_DESTROYED, conn_destroyed, arg); event_register_handler (EV_CALL_SEND_START, send_start, arg); event_register_handler (EV_CALL_SEND_STOP, send_stop, arg); event_register_handler (EV_CALL_RECV_START, recv_start, arg); event_register_handler (EV_CALL_RECV_STOP, recv_stop, arg); }
static void init (void) { Any_Type arg; es_lifetime.min = DBL_MAX; es_response.min = DBL_MAX; es_connect.min = DBL_MAX; es_transfer.min = DBL_MAX; arg.l = 0; event_register_handler (EV_PERF_SAMPLE, perf_sample, arg); event_register_handler (EV_CONN_FAILED, conn_fail, arg); event_register_handler (EV_CONN_TIMEOUT, conn_timeout, arg); event_register_handler (EV_CONN_NEW, conn_created, arg); event_register_handler (EV_CONN_CONNECTING, conn_connecting, arg); event_register_handler (EV_CONN_CONNECTED, conn_connected, arg); event_register_handler (EV_CONN_DESTROYED, conn_destroyed, arg); event_register_handler (EV_CALL_SEND_START, send_start, arg); event_register_handler (EV_CALL_SEND_STOP, send_stop, arg); event_register_handler (EV_CALL_RECV_START, recv_start, arg); event_register_handler (EV_CALL_RECV_STOP, recv_stop, arg); }