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