int am_merge(achievement_manager_t* am, const achievement_manager_t* another_am)
{
uint32_t i = 0;
achievement_state_t* state = &am->states[0];
for (i = 0; i < am->nachievements; ++i, ++state)
{
const achievement_state_t* another = find_achievement(another_am, state->achievement_id);
if (another == NULL)
{
LOGI("Unable to find achievement %s", state->achievement_id);
continue;
}
int unlocked = state->status.unlocked;
int another_unlocked = another->status.unlocked;
if ((!unlocked && another_unlocked) ||
(!unlocked && !another_unlocked && state->status.progress < another->status.progress) ||
(unlocked && another_unlocked && timestamp_diff(&state->status.unlocked_at, &another->status.unlocked_at) > 0))
{
state->status = another->status;
state->data = another->data;
}
}
return 0;
}
struct task_t* task_dispatcher_enqueue_task(struct task_dispatcher_t* td, task_callback_pf callback, void* ctx, long delay, long interval)
{
struct task_t task =
{
.callback = callback,
.ctx = ctx,
.interval = interval,
};
timestamp_set(&task.enqueue_time);
timestamp_offset(&task.enqueue_time, &task.activate_time, delay);
pthread_mutex_lock(&td->lock);
struct task_t* queued_task = pool_get_next(td->tasks, NULL);
struct task_t* after = NULL;
while (queued_task != NULL && timestamp_diff(&queued_task->activate_time, &task.activate_time) <= 0)
{
after = queued_task;
queued_task = pool_get_next(td->tasks, queued_task);
}
struct task_t* p = pool_insert(td->tasks, &task, after);
LOGD("Enqueued task %p after %p", p, after);
if (after == NULL)
{
pthread_cond_broadcast(&td->event);
}
pthread_mutex_unlock(&td->lock);
return p;
}
static void gaim_loop(GameData &d) {
register const timestamp_t loop_cap = 1000/60 + 1;
register timestamp_t timesand;
register uint64_t total_sand = 0;
register uint16_t numloops = 0;
InputControl inputControl(d);
while (!d.bools->exit && !d.bools->won) {
// get gaim loop starting time
d.currTime = timesand = currTime = getTimestamp();
// Handle input events
inputControl();
if (!d.bools->paused) {
// Progress everything
AnimatorHolder::Progress(timesand);
std::for_each(d.akmovs.begin(), d.akmovs.end(),
AnimatorProgressor(timesand));
// collision checking happens through callbacks
d.cc->Commit();
// Run scheduled tasks
d.sch->check(timesand);
// Draw on the screen
SDL_FillRect(d.screen, NULL, d.bg);
d.animdata->plathold->displayPlatforms(d.screen);
d.animdata->spritehold->displaySprites(d.screen);
d.stats->Draw(d.screen);
SDL_Flip(d.screen);
}
// Cap gaim loop speed
timestamp_t sanddiff = timestamp_diff(
cs454_2006::getTimestamp(), timesand);
SDL_Delay(sanddiff > loop_cap ? 0 :
timestamp_diff(loop_cap, sanddiff));
// Time statistics
total_sand += timestamp_diff(getTimestamp(), timesand);
numloops++;
} // gaim loop while
double loop_avg = CAST(double, total_sand) / numloops;
std::cerr << "Average gaim loop duration: " << loop_avg <<
std::endl << "Average fps: " << (1000 / loop_avg) << std::endl;
} // gaim_loop
static void* working_thread(void* ctx)
{
struct task_dispatcher_t* td = (struct task_dispatcher_t*)ctx;
LOGI("Task dispatcher working thread started");
pthread_mutex_lock(&td->event_lock);
while (1)
{
if (pool_is_empty(td->tasks))
{
LOGD("Waiting for event");
pthread_cond_wait(&td->event, &td->event_lock);
}
else
{
struct task_t* task = pool_get_next(td->tasks, NULL);
struct timespec activate_time = {0};
timestamp_to_timespec(&task->activate_time, &activate_time);
timestamp_t current = {0};
timestamp_set(¤t);
LOGD("Waiting for task [%ld:%d -> %ld:%d]", current.value.tv_sec, current.value.tv_usec, task->activate_time.value.tv_sec, task->activate_time.value.tv_usec);
pthread_cond_timedwait(&td->event, &td->event_lock, &activate_time);
}
if (!td->running)
{
LOGI("Stopping working thread");
break;
}
if (!pool_is_empty(td->tasks))
{
struct task_t* task = pool_get_next(td->tasks, NULL);
timestamp_t current = {0};
timestamp_set(¤t);
if (timestamp_diff(¤t, &task->activate_time) >= 0)
{
pool_remove(td->tasks, task);
LOGD("Removed task %p [queue empty %d]", task, pool_is_empty(td->tasks));
if (task->interval > 0)
{
task_dispatcher_enqueue_task(td, task->callback, task->ctx, task->interval, task->interval);
}
pthread_mutex_unlock(&td->event_lock);
LOGD("Running task");
task->callback(td, task, &task->enqueue_time, ¤t, task->ctx);
pthread_mutex_lock(&td->event_lock);
}
}
}
pthread_mutex_unlock(&td->event_lock);
LOGI("Task dispatcher working thread stopped");
return NULL;
}
long timestamp_update(timestamp_t* timestamp)
{
timestamp_t prev = *timestamp;
timestamp_set(timestamp);
return timestamp_diff(timestamp, &prev);
}
long timestamp_elapsed(const timestamp_t* timestamp)
{
timestamp_t current;
timestamp_set(¤t);
return timestamp_diff(¤t, timestamp);
}
int update()
{
if (get_active_screen() == NULL)
{
return 1;
}
timestamp_t current = {0};
timestamp_set(¤t);
long dt = timestamp_diff(¤t, &timer);
if (dt > 0)
{
timer = current;
screen_update(dt);
}
long fps_dt = timestamp_diff(¤t, &fps_timer);
LOGD("DT: %ld", fps_dt);
if (fps_dt > 500)
{
fps = frames * 1000.0f / (float)fps_dt;
fps_timer = current;
frames = 0;
LOGI("FPS: %.2f", fps);
}
else
{
++frames;
}
char fps_str[32] = {0};
sprintf(fps_str, "FPS: %.2f", fps);
const rect_t fps_rect = { 8.0f, 8.0f, 256.0f, 32.0f };
const rgba_t fps_color = { 1.0f, 0.0f, 0.0f, 0.8f };
mat4f_t transform = {0};
mat4_mult(&transform, &camera.proj, &camera.view);
rect_t screen = { 0, 0, screen_size.x, screen_size.y };
rgba_t color = {0.7f, 0.7f, 0.0f, 1.0f };
gfx_set_target(gfx, "test_target", &screen);
gfx_enable_depth_buffer(gfx, 1);
gfx_clear(gfx);
screen_render(gfx, &camera);
gfx_set_shader(gfx, "text");
gfx_set_uniform_mat4f(gfx, "uMVP", 1, &transform);
draw_text(fps_str, &fps_rect, 0.0f, 4.9f, &fps_color);
gfx_flush(gfx);
static int take_screenshot = 0;
if (take_screenshot && frames == 0)
{
take_screenshot = 0;
image_t* img = NULL;
if (gfx_take_screenshot(gfx, &img) == 0)
{
image_save_to_png(img, "screenshot.png");
image_free(img);
}
}
gfx_set_target(gfx, NULL, &screen);
gfx_enable_depth_buffer(gfx, 0);
gfx_clear(gfx);
int32_t sampler = 0;
rect_t uv = { 0, screen.height/buffer_size.y, screen.width/buffer_size.x, -screen.height/buffer_size.y };
gfx_set_shader(gfx, "postprocess");
gfx_set_uniform_mat4f(gfx, "uMVP", 1, &transform);
gfx_set_uniform_1i(gfx, "uTex", 1, &sampler);
gfx_set_texture(gfx, "test_texture", sampler);
gfx_render_textured_rect(gfx, &screen, 1.0f, &uv);
gfx_set_texture(gfx, NULL, sampler);
gfx_flush(gfx);
return 0;
}
int main(int argc, char *argv[])
{
configuration_t configuration;
int i, j;
struct timeval tm;
struct timezone tz;
measurement_t *measurement;
struct timeval next, wait;
int subject_id, flow_id;
unsigned long long packets, bytes;
double mbps;
char command[MAX_COMMAND+1];
char hostname_interface[MAX_HOSTNAME_INTERFACE+1]; /* DiMAPI connect string
as "hostname:interface,..." */
struct timeval tv_start, tv_stop; /* to measure how fast mapi_read_result()
responds */
int tv_diff_pkt, tv_diff_byte; /* time used by mapi_read_results() */
int tv_diff_threshold; /* 1 if threshold was reached */
mapi_results_t *pkt_counter_res;
mapi_results_t *byte_counter_res;
unsigned long long pkt_counter;
unsigned long long byte_counter;
int scope_size;
double pkt_sec; /* seconds from previous packet result */
double byte_sec; /* seconds from previous byte result */
mapi_flow_info_t info;
mapi_device_info_t dinfo;
openlog("abw", LOG_PID, LOG_LOCAL0);
syslog(LOG_DEBUG, "starting abw");
memset((void *)&configuration, 0, (size_t)(sizeof(configuration)));
/* Create global configuration */
if ((configuration.global=malloc(sizeof(global_t)))==NULL) {
fprintf(stderr, "%s: malloc() failed\n", __func__);
return -1;
}
memset(configuration.global, 0, sizeof(global_t));
/* Create first subject, scope, parameters and measurement so that they
can be filled-in by command-line options */
/* if ((configuration.subject=new_subject())==NULL) {
fprintf(stderr, "%s: new_subject() failed\n", __func__);
return -1;
}
if ((configuration.scope=new_scope())==NULL) {
fprintf(stderr, "%s: new_subject() failed\n", __func__);
return -1;
}
if ((configuration.parameters=new_parameters())==NULL) {
fprintf(stderr, "%s: new_parameters() failed\n", __func__);
return -1;
}
if ((configuration.measurement=new_measurement())==NULL) {
fprintf(stderr, "%s: new_measurement() failed\n", __func__);
return -1;
} */
/* Read command line */
if (read_command_line(argc, argv, &configuration)<0) {
fprintf(stderr, "%s: read_command_line() failed\n", __func__);
return -1;
}
/* Read configuration file */
if (configuration.global->conf_filename) {
if (read_conf_file(&configuration)<0) {
fprintf(stderr, "%s: read_conf_file() failed\n", __func__);
return -1;
}
}
/* Fill-in local hostname */
if (get_local_hostname(&(configuration.global->hostname))<0) {
fprintf(stderr, "%s: get_local_hostname() failed\n", __func__);
return -1;
}
/* Check if specified values are within acceptable limits */
if (check_conf(&configuration)<0) {
fprintf(stderr, "%s: check_conf() failed\n", __func__);
exit(-1);
}
/* Print configuration */
if (debug)
print_conf(&configuration);
if (daemonize) {
printf("Switching to daemon\n");
if (continue_as_daemon()<0) {
fprintf(stderr, "%s: continue_as_daemon() failed\n", __func__);
return -1;
}
printf("Continuing as daemon\n");
}
/*
* Create RRD files
*/
/* Go over all measurements */
measurement=configuration.measurement;
while (measurement) {
int parameters_id;
char *filename;
parameters_id = measurement->parameters_id;
/* Go over all protocols */
j=0;
while (protocols[j].protocol) {
if ((filename=
abw_rrd_create_filename(measurement->scope,
parameters_id, protocols[j].protocol))==NULL) {
fprintf(stderr, "%s: rrd_create_filename() failed\n",
__func__);
return -1;
}
if (abw_rrd_create_file(filename)<0) {
fprintf(stderr, "%s: abw_rrd_create_file() failed\n", __func__);
return -1;
}
j++;
} /* Go over all protocols */
/* Go over all tracked protocols */
j=0;
while (tracked_protocols[j].protocol) {
if ((filename=
abw_rrd_create_filename(measurement->scope,
parameters_id, tracked_protocols[j].protocol))==NULL) {
fprintf(stderr, "%s: rrd_create_filename() failed\n",
__func__);
return -1;
}
if (abw_rrd_create_file(filename)<0) {
fprintf(stderr, "%s: abw_rrd_create_file() failed\n", __func__);
return -1;
}
j++;
} /* Go over all tracked protocols */
/* Create RRD file for "all" protocol (all traffic together) */
if ((filename=
abw_rrd_create_filename(measurement->scope,
parameters_id, "all"))==NULL) {
fprintf(stderr, "%s: rrd_create_filename() failed\n",
__func__);
return -1;
}
if (abw_rrd_create_file(filename)<0) {
fprintf(stderr, "%s: abw_rrd_create_file() failed\n", __func__);
return -1;
}
measurement=measurement->next;
} /* while (measurement) */
/*
* Create MAPI flows
*/
flow_id=0;
/* Go over all measurements */
measurement=configuration.measurement;
while (measurement) {
/* Go over all monitored protocols */
i=0;
while (measurement->protocols_array[i] && i<MAX_PROTOCOLS) {
int parameters_id;
char *protocol;
/* Create data structure to maintain MAPI information */
if (flow_id>=MAX_FLOWS) {
fprintf(stderr, "%s: more than %d flows requested\n", __func__,
MAX_FLOWS);
return -1;
}
if ((flow[flow_id]=new_flow())==NULL) {
fprintf(stderr, "%s: new_flow() failed\n", __func__);
return -1;
}
flow[flow_id]->measurement=measurement;
flow[flow_id]->protocol=measurement->protocols_array[i];
parameters_id = measurement->parameters_id;
protocol = measurement->protocols_array[i];
if ((flow[flow_id]->rrd_filename=
abw_rrd_create_filename(measurement->scope,
parameters_id, protocol))==NULL) {
fprintf(stderr, "%s: rrd_create_filename() failed\n",
__func__);
return -1;
}
/*
* If scope has only one subject and if hostname is "localhost" or
* equal to local hostname, then use MAPI connect string (not DiMAPI)
*/
if (!(measurement->scope->subject[1]) &&
(!strcmp(measurement->scope->subject[0]->hostname, "localhost") ||
!strcmp(measurement->scope->subject[0]->hostname,
configuration.global->hostname)))
strcpy(hostname_interface,
measurement->scope->subject[0]->interface);
/*
* Prepare DiMAPI connect string as hostname:interface, ...
*/
else {
j=0; hostname_interface[0]='\0';
while (measurement->scope->subject[j] && j<MAX_SUBJECTS) {
/* Append comma "," */
if (hostname_interface[0]) {
if (strlen(hostname_interface)+1>=MAX_HOSTNAME_INTERFACE) {
fprintf(stderr, "%s: DiMAPI connect string is longer than %d characters\n", __func__, MAX_HOSTNAME_INTERFACE);
return -1;
}
strcat(hostname_interface, ",");
}
/* Append next hostname:interface */
if (strlen(hostname_interface) +
strlen(measurement->scope->subject[j]->hostname) +
strlen(measurement->scope->subject[j]->interface)
>= MAX_HOSTNAME_INTERFACE) {
fprintf(stderr, "%s: DiMAPI connect string is longer than %d characters\n", __func__, MAX_HOSTNAME_INTERFACE);
return -1;
}
sprintf(hostname_interface + strlen(hostname_interface), "%s:%s",
measurement->scope->subject[j]->hostname,
measurement->scope->subject[j]->interface);
j++;
} /* while (measurement->scope->subject[j] && j<MAX_SUBJECTS) */
} /* Creating DiMAPI connect string */
/* Create a new MAPI flow */
if (debug)
printf("%s: mapi_create_flow(%s)\n", __func__, hostname_interface);
if ((flow[flow_id]->fd=mapi_create_flow(hostname_interface))<0) {
fprintf(stderr, "%s: mapi_create_flow(%s) failed\n", __func__,
hostname_interface);
fprintf(stderr, "%s: Do you run mapid daemon on the machine where you connect to?\n", __func__);
fprintf(stderr, "%s: Do you run mapicommd daemon on the machine where you connect to? (if you are connecting to a non-local machine or to multiple machines)\n", __func__);
return -1;
}
/* If this is a MAPI flow (not DiMAPI flow), then set MPLS and VLAN
flags according to mapi.conf. Otherwise the flags were set in
abw.conf */
if (!strchr(hostname_interface, ':')) {
if (debug)
printf("%s: MAPI flow on \"%s\", setting MPLS and VLAN flags from mapi.conf\n", __func__, hostname_interface);
if ((mapi_get_flow_info(flow[flow_id]->fd, &info)) < 0){
fprintf(stderr, "%s: mapi_get_flow_info() failed\n", __func__);
return -1;
}
if ((mapi_get_device_info(info.devid, &dinfo)) < 0) {
fprintf(stderr, "%s: mapi_get_device_info() failed\n", __func__);
return -1;
}
measurement->scope->mpls = dinfo.mpls;
measurement->scope->vlan = dinfo.vlan;
}
else
if (debug)
printf("%s: DiMAPI flow on \"%s\", setting MPLS and VLAN flags from abw.conf\n", __func__, hostname_interface);
/* Prepare header filter for this protocol */
if ((flow[flow_id]->tracked_protocol=
protocol_filter(measurement->parameters->header_filter,
flow[flow_id]->protocol, measurement->scope->mpls,
measurement->scope->vlan,
&(flow[flow_id]->header_filter)))<0) {
fprintf(stderr, "%s: protocol_filter() failed\n", __func__);
return -1;
}
if (debug)
printf("measurement->parameters->header_filter: %s, flow[flow_id]->protocol: %s, flow[flow_id]->header_filter: %s, track_function: %s\n", (measurement->parameters->header_filter)?measurement->parameters->header_filter:"NULL", flow[flow_id]->protocol, (flow[flow_id]->header_filter)?flow[flow_id]->header_filter:"NULL", (flow[flow_id]->tracked_protocol)?tracked_protocols[flow[flow_id]->tracked_protocol-1].track_function:"none");
/* Filter based on input port, we can use port number in the first
subject of the scope, because all subjects in a scope must have
the same port number */
if (measurement->scope->subject[0]->port >= 0) {
if ((flow[flow_id]->interface_fid=mapi_apply_function(flow[flow_id]->fd, "INTERFACE", measurement->scope->subject[0]->port))<0) {
fprintf(stderr, "%s: INTERFACE failed\n", __func__);
return -1;
}
}
/* Note that BPF_FILTER uses compiled header filter that
selects packets of the given protocol */
/* BPF_FILTER is applied if a) header_filter was specified in
[parameters] section or b) protocol other than "all" and other than
some that requires tracking was specified in [parameters] section or
c) MPLS is used on links in this [scope] */
if (flow[flow_id]->header_filter) {
if (debug)
printf("%s: mapi_apply_function(%d, BPF_FILTER, \"%s\")\n",
__func__, flow[flow_id]->fd, flow[flow_id]->header_filter);
if ((flow[flow_id]->bpf_filter_fid=
mapi_apply_function(flow[flow_id]->fd, "BPF_FILTER",
flow[flow_id]->header_filter))<0) {
fprintf(stderr, "%s: BPF_FILTER (\"%s\") failed\n",
__func__, flow[flow_id]->header_filter);
return -1;
}
}
/* Track application protocol, BPF_FILTER could have been applied
before */
if (flow[flow_id]->tracked_protocol) {
if (debug)
printf("%s: mapi_apply_function(%d, %s)\n", __func__,
flow[flow_id]->fd,
tracked_protocols[flow[flow_id]->tracked_protocol-1].
track_function);
if ((flow[flow_id]->track_function_fid=
mapi_apply_function(flow[flow_id]->fd,
tracked_protocols[flow[flow_id]->tracked_protocol-1].
track_function))<0) {
fprintf(stderr, "%s: tracking (%s) failed\n", __func__,
tracked_protocols[flow[flow_id]->tracked_protocol-1].
track_function);
return -1;
}
}
/* Sampling */
if (measurement->parameters->sau_mode == 'd' &&
(unsigned int)(measurement->parameters->sau_threshold) != 1) {
if ((flow[flow_id]->sample_fid=
mapi_apply_function(flow[flow_id]->fd, "SAMPLE",
measurement->parameters->sau_threshold, PERIODIC))<0) {
fprintf(stderr, "%s: SAMPLE (PERIODIC, %.02f) failed\n",
__func__, measurement->parameters->sau_threshold);
return -1;
}
}
else if (measurement->parameters->sau_mode == 'p' &&
(unsigned int)(measurement->parameters->sau_threshold) != 1) {
if ((flow[flow_id]->sample_fid=
mapi_apply_function(flow[flow_id]->fd, "SAMPLE",
(measurement->parameters->sau_threshold)*100,
PROBABILISTIC))<0) {
fprintf(stderr, "%s: SAMPLE (PROBABILISTIC, %.02f) failed\n",
__func__, (measurement->parameters->sau_threshold)*100);
return -1;
}
}
/* Payload searching */
if (measurement->parameters->payload_strings[0]) {
if ((flow[flow_id]->str_search_fid=
mapi_apply_function(flow[flow_id]->fd, "STR_SEARCH",
measurement->parameters->payload_strings[0], 0, 0))<0) {
fprintf(stderr, "%s: STR_SEARCH (%s) failed\n",
__func__, measurement->parameters->payload_strings[0]);
return -1;
}
}
/* Counting packets and bytes */
if ((flow[flow_id]->pkt_counter_fid=
mapi_apply_function(flow[flow_id]->fd, "PKT_COUNTER"))<0) {
fprintf(stderr, "%s: PKT_COUNTER failed\n", __func__);
return -1;
}
/* Simultaneous use of PKT_COUNTER and BYTE_COUNTER does not
work with DAG4.3GE. Temporary hack: always use stflib version */
if ((flow[flow_id]->byte_counter_fid=
mapi_apply_function(flow[flow_id]->fd, "stdflib:BYTE_COUNTER"))<0) {
fprintf(stderr, "%s: BYTE_COUNTER failed\n",
__func__);
return -1;
}
/* Connect to flow */
if (!configuration.global->no_measure) {
if (mapi_connect(flow[flow_id]->fd)<0) {
fprintf(stderr, "%s: mapi_connect() (%s) failed\n",
__func__, hostname_interface);
return -1;
}
if ((scope_size=mapi_get_scope_size(flow[flow_id]->fd)) !=
flow[flow_id]->measurement->scope->subject_no) {
fprintf(stderr, "%s: mapi_get_scope_size() returned %d for %d subjects\n", __func__, scope_size, flow[flow_id]->measurement->scope->subject_no);
return -1;
}
}
i++;
flow_id++;
} /* while (measurement->protocols_array[i] && i<MAX_PROTOCOLS) */
measurement=measurement->next;
} /* while (measurement) */
if (configuration.global->no_measure || !configuration.measurement)
return 0;
/* Periodically get results from MAPI flows */
while (1) {
if (gettimeofday(&tm, &tz)<0) {
fprintf(stderr, "%s: gettimeofday() failed\n", __func__);
return -1;
}
flow_id=0;
while (flow[flow_id] && flow_id<MAX_FLOWS) {
int scope_packets, scope_bytes;
if (!configuration.global->no_stdout) {
printf("%d %u.%u", flow[flow_id]->measurement->scope->id,
(unsigned int)(tm.tv_sec),
(unsigned int)(tm.tv_usec));
if (!configuration.global->stdout_simple)
printf(" %s\n", flow[flow_id]->protocol);
}
gettimeofday(&tv_start, NULL);
if ((pkt_counter_res=mapi_read_results(flow[flow_id]->fd,
flow[flow_id]->pkt_counter_fid))==NULL) {
fprintf(stderr, "%s: mapi_read_results() for flow %d failed\n",
__func__, flow_id);
return -1;
}
gettimeofday(&tv_stop, NULL);
tv_diff_pkt=timestamp_diff(&tv_start, &tv_stop);
gettimeofday(&tv_start, NULL);
if ((byte_counter_res=mapi_read_results(flow[flow_id]->fd,
flow[flow_id]->byte_counter_fid))==NULL) {
fprintf(stderr, "%s: mapi_read_results() for flow %d failed\n",
__func__, flow_id);
return -1;
}
gettimeofday(&tv_stop, NULL);
tv_diff_byte=timestamp_diff(&tv_start, &tv_stop);
if (tv_diff_pkt>=TV_DIFF_THRESHOLD ||
tv_diff_byte>=TV_DIFF_THRESHOLD)
tv_diff_threshold=1;
else
tv_diff_threshold=0;
if (tv_diff_pkt>=TV_DIFF_THRESHOLD)
syslog(LOG_DEBUG, "mapi_read_result() for PKT_COUNTER takes %d us for measurement ID %d and protocol %s (threshold %d us reached)", tv_diff_pkt, flow[flow_id]->measurement->id, flow[flow_id]->protocol, TV_DIFF_THRESHOLD);
if (tv_diff_byte>=TV_DIFF_THRESHOLD)
syslog(LOG_DEBUG, "mapi_read_result() for BYTE_COUNTER takes %d us for measurement ID %d and protocol %s (threshold %d us reached)", tv_diff_byte, flow[flow_id]->measurement->id, flow[flow_id]->protocol, TV_DIFF_THRESHOLD);
scope_size = flow[flow_id]->measurement->scope->subject_no;
scope_packets=0;
scope_bytes=0;
for (subject_id=0; subject_id<scope_size; subject_id++) {
pkt_counter=
*((unsigned long long*)(pkt_counter_res[subject_id].res));
byte_counter=
*((unsigned long long*)(byte_counter_res[subject_id].res));
packets=pkt_counter - flow[flow_id]->pkt_counter[subject_id];
bytes=byte_counter - flow[flow_id]->byte_counter[subject_id];
mbps=(double)bytes*8/1000000;
flow[flow_id]->pkt_counter[subject_id]=pkt_counter;
flow[flow_id]->byte_counter[subject_id]=byte_counter;
/* Determine seconds from previous result */
if (flow[flow_id]->pkt_ts[subject_id])
pkt_sec=(double)(pkt_counter_res[subject_id].ts -
flow[flow_id]->pkt_ts[subject_id])/1000000;
else
pkt_sec=
flow[flow_id]->measurement->parameters->interval.tv_sec +
(double)(flow[flow_id]->measurement->parameters->interval.tv_usec)/1000000;
if (flow[flow_id]->byte_ts[subject_id])
byte_sec=(double)(byte_counter_res[subject_id].ts -
flow[flow_id]->byte_ts[subject_id])/1000000;
else
byte_sec=
flow[flow_id]->measurement->parameters->interval.tv_sec +
(double)(flow[flow_id]->measurement->parameters->interval.tv_usec)/1000000;
scope_packets+=(packets/pkt_sec);
scope_bytes+=(bytes/byte_sec);
flow[flow_id]->pkt_ts[subject_id]=
pkt_counter_res[subject_id].ts;
flow[flow_id]->byte_ts[subject_id]=
byte_counter_res[subject_id].ts;
if (tv_diff_threshold) {
syslog(LOG_DEBUG, "%s:%s: %.02f seconds from previous result",
flow[flow_id]->measurement->scope->subject[subject_id]->hostname,
flow[flow_id]->measurement->scope->subject[subject_id]->interface,
byte_sec);
}
/* Print result */
if (!configuration.global->no_stdout) {
if (configuration.global->stdout_simple)
printf(" %0.2f %0.2f %0.2f", packets/pkt_sec,
bytes/byte_sec, mbps/byte_sec);
else
printf(" %0.2f packets/s, %0.2f bytes/s, %0.2f Mb/s, time %uus/%uus, interval %0.2fs/%0.2fs\n",
packets/pkt_sec, bytes/byte_sec, mbps/byte_sec,
tv_diff_pkt, tv_diff_byte, pkt_sec, byte_sec);
}
} /* for (subject_id=0; subject_id++; subject_id<scope_size) */
if (!configuration.global->no_stdout)
printf("\n");
/* If interval is at least 1 second, then store results
to RRD file */
if (flow[flow_id]->measurement->parameters->interval.tv_sec) {
sprintf(command, "rrdtool update %s %u:%lu:%lu:%.6f",
flow[flow_id]->rrd_filename,
(unsigned int)(tm.tv_sec),
(unsigned long)(scope_packets),
(unsigned long)(scope_bytes),
(double)scope_bytes*8/1000000);
if (configuration.global->debug > 1)
syslog(LOG_DEBUG, "system(%s)", command);
if (tm.tv_sec == flow[flow_id]->rrd_ts)
syslog(LOG_ERR, "duplicate RRD timestamp %u for scope %d\n", (unsigned int)(tm.tv_sec), flow[flow_id]->measurement->scope->id);
else
flow[flow_id]->rrd_ts=tm.tv_sec;
if (debug)
printf("%s: system(%s)\n", __func__, command);
if (system(command)<0) {
fprintf(stderr, "%s: command(%s) failed\n", __func__,
command);
return -1;
}
}
flow_id++;
} /* while (flow[flow_id] && flow_id<MAX_FLOWS) */
abw_next_timestamp(&(configuration.measurement->parameters->interval),
&next, &wait);
if (!configuration.global->no_stdout &&
!configuration.global->stdout_simple) {
printf("next.tv_sec: %d, next.tv_usec: %d, wait.tv_sec: %d, wait.tv_usec: %d\n", (int)(next.tv_sec), (int)(next.tv_usec), (int)(wait.tv_sec), (int)(wait.tv_usec));
printf("===============================================================================\n");
}
usleep(wait.tv_sec * 1000000 + wait.tv_usec);
} /* while (1) */
return 0;
} /* main() */
