inline int AddItem(DB, __local ideal_t *unique, VECTOR(*stats), size_t item) { size_t passive_id; int removed_n = 0; if (item == 0) return 1; for (size_t i = 0; i < BUILDTREE_WIDTH; ++i) { size_t id = db_items[item].buildtree[i]; if (id == 0) continue; passive_id = db_items[id].passive_id; stats_remove(db_items, stats, id, --unique[passive_id] == 0); ++removed_n; } passive_id = db_items[item].passive_id; stats_add(db_items, stats, item, ++unique[passive_id] == 1); return 1 - removed_n; }
result_t build_combo_m(__constant item_t db_items[], llf_criteria *cfg, ulong_t rank, uint_t db_len, uint_t combo_len, __local setmax_t *unique) { setmax_t combo[NK_MULTISET_MAX_K]; result_t dps; VECTOR(stats) = VECTOR_ZERO_INIT; combo_unrank(rank, db_len, combo_len, combo); for (size_t i = 0; i < combo_len; ++i) { itemid_t item = combo[i]; itemid_t passive = db_items[item].passive_id; stats_add(db_items, &stats, item, ++unique[passive] == 1); } dps.index = rank; dps.metric = llf_metric(cfg, &stats); return dps; }
void mail_user_refresh(struct mail_user *user, const struct stats *diff_stats) { if (diff_stats != NULL) stats_add(user->stats, diff_stats); user->last_update = ioloop_timeval; DLLIST2_REMOVE_FULL(&mail_users_head, &mail_users_tail, user, sorted_prev, sorted_next); DLLIST2_APPEND_FULL(&mail_users_head, &mail_users_tail, user, sorted_prev, sorted_next); mail_domain_refresh(user->domain, diff_stats); }
int main(int argc, char** argv) { stats_init(); int i = 0; while (++i < 5000) { stats_add(ARANDN, ARANDN, ARANDN); if (i % 10 == 0) { printf("xsum: %d\nysum: %d\nzsum: %d\nptr: %d\n\n", stats.xsum, stats.ysum, stats.zsum, stats.aptr); } } return 0; }
void mail_session_refresh(struct mail_session *session, const struct stats *diff_stats) { timeout_reset(session->to_idle); if (diff_stats != NULL) stats_add(session->stats, diff_stats); session->last_update = ioloop_timeval; DLLIST2_REMOVE_FULL(&mail_sessions_head, &mail_sessions_tail, session, sorted_prev, sorted_next); DLLIST2_APPEND_FULL(&mail_sessions_head, &mail_sessions_tail, session, sorted_prev, sorted_next); mail_user_refresh(session->user, diff_stats); if (session->ip != NULL) mail_ip_refresh(session->ip, diff_stats); }
void stats_accumulate(stats_t *sp) { stats_t *result; for (result = sp->prev; result != NULL; result = result->prev) { if (result->type == STATS_FILE || result->type == STATS_TOTAL) break; } if (result == NULL) { fprintf(stderr, "Error in stats_accumulate() - exit\n"); exit(3); } stats_add(result, sp); }
static void stats_add_session(struct mail_user *user) { struct stats_user *suser = STATS_USER_CONTEXT(user); struct stats *new_stats, *diff_stats; const char *error; new_stats = stats_alloc(pool_datastack_create()); diff_stats = stats_alloc(pool_datastack_create()); mail_user_stats_fill(user, new_stats); /* we'll count new_stats-pre_io_stats and add the changes to session_stats. the new_stats can't be directly copied to session_stats because there are some fields that don't start from zero, like clock_time. (actually with stats_global_user code we're requiring that clock_time is the only such field..) */ if (!stats_diff(suser->pre_io_stats, new_stats, diff_stats, &error)) i_error("stats: session stats shrank: %s", error); stats_add(suser->session_stats, diff_stats); /* copying is only needed if stats_global_user=NULL */ stats_copy(suser->pre_io_stats, new_stats); }
int thread_collect_results(const struct settings *settings, struct stats *total_stats, int (*print_results)(const struct settings *, const struct stats *, void *), void *data) { unsigned int i = 0; SOCKET s; assert( settings != NULL ); assert( total_stats != NULL ); s = ((struct remote_data*)data)->stats_socket; assert ( s != INVALID_SOCKET ); if ( settings->verbose ) printf("Collecting %u results\n", settings->servercores); for ( ; i < settings->servercores; i++ ) { struct stats stats; if ( read_results(s, &stats) != 0 ) { fprintf(stderr, "%s:%d read_results() error\n", __FILE__, __LINE__ ); return -1; } if ( print_results(settings, &stats, data) ) { fprintf(stderr, "%s:%d print_results() error\n", __FILE__, __LINE__ ); return -1; } // Now add the values to the total stats_add( total_stats, &stats ); } // Divide the duration by the # of CPUs used if ( settings->servercores > 1 ) total_stats->duration /= settings->servercores; return 0; }
/* * Takes a "snapshot" of the global statistics. Actually, it calculates * them from the local statistics maintained by each flowop. * First the routine pauses filebench, then rolls the statistics for * each flowop into its associated FLOW_MASTER flowop. * Next all the FLOW_MASTER flowops' statistics are written * to the log file followed by the global totals. Then filebench * operation is allowed to resume. */ void stats_snap(void) { struct flowstats *iostat = &globalstats[FLOW_TYPE_IO]; struct flowstats *aiostat = &globalstats[FLOW_TYPE_AIO]; hrtime_t orig_starttime; flowop_t *flowop; char *str; double total_time_sec; if (!globalstats) { filebench_log(LOG_ERROR, "'stats snap' called before 'stats clear'"); return; } /* don't print out if run ended in error */ if (filebench_shm->shm_f_abort == FILEBENCH_ABORT_ERROR) { filebench_log(LOG_ERROR, "NO VALID RESULTS! Filebench run terminated prematurely"); return; } /* Freeze statistics during update */ filebench_shm->shm_bequiet = 1; /* We want to have blank global statistics each * time we start the summation process, but the * statistics collection start time must remain * unchanged (it's a snapshot compared to the original * start time). */ orig_starttime = globalstats->fs_stime; (void) memset(globalstats, 0, FLOW_TYPES * sizeof(struct flowstats)); globalstats->fs_stime = orig_starttime; globalstats->fs_etime = gethrtime(); total_time_sec = (globalstats->fs_etime - globalstats->fs_stime) / SEC2NS_FLOAT; filebench_log(LOG_DEBUG_SCRIPT, "Stats period = %.0f sec", total_time_sec); /* Similarly we blank the master flowop statistics */ flowop = filebench_shm->shm_flowoplist; while (flowop) { if (flowop->fo_instance == FLOW_MASTER) { (void) memset(&flowop->fo_stats, 0, sizeof(struct flowstats)); flowop->fo_stats.fs_minlat = ULLONG_MAX; } flowop = flowop->fo_next; } /* Roll up per-flowop statistics in globalstats and master flowops */ flowop = filebench_shm->shm_flowoplist; while (flowop) { flowop_t *flowop_master; if (flowop->fo_instance <= FLOW_DEFINITION) { flowop = flowop->fo_next; continue; } /* Roll up per-flowop into global stats */ stats_add(&globalstats[flowop->fo_type], &flowop->fo_stats); stats_add(&globalstats[FLOW_TYPE_GLOBAL], &flowop->fo_stats); flowop_master = flowop_find_one(flowop->fo_name, FLOW_MASTER); if (flowop_master) { /* Roll up per-flowop stats into master */ stats_add(&flowop_master->fo_stats, &flowop->fo_stats); } else { filebench_log(LOG_DEBUG_NEVER, "flowop_stats could not find %s", flowop->fo_name); } filebench_log(LOG_DEBUG_SCRIPT, "flowop %-20s-%4d - %5d ops %5.1lf ops/sec %5.1lfmb/s " "%8.3fms/op", flowop->fo_name, flowop->fo_instance, flowop->fo_stats.fs_count, flowop->fo_stats.fs_count / total_time_sec, (flowop->fo_stats.fs_bytes / MB_FLOAT) / total_time_sec, flowop->fo_stats.fs_count ? flowop->fo_stats.fs_total_lat / (flowop->fo_stats.fs_count * SEC2MS_FLOAT) : 0); flowop = flowop->fo_next; } flowop = filebench_shm->shm_flowoplist; str = malloc(1048576); *str = '\0'; (void) strcpy(str, "Per-Operation Breakdown\n"); while (flowop) { char line[1024]; char histogram[1024]; char hist_reading[20]; int i = 0; if (flowop->fo_instance != FLOW_MASTER) { flowop = flowop->fo_next; continue; } (void) snprintf(line, sizeof(line), "%-20s %dops %8.0lfops/s " "%5.1lfmb/s %8.1fms/op", flowop->fo_name, flowop->fo_stats.fs_count, flowop->fo_stats.fs_count / total_time_sec, (flowop->fo_stats.fs_bytes / MB_FLOAT) / total_time_sec, flowop->fo_stats.fs_count ? flowop->fo_stats.fs_total_lat / (flowop->fo_stats.fs_count * SEC2MS_FLOAT) : 0); (void) strcat(str, line); (void) snprintf(line, sizeof(line)," [%.2fms - %5.2fms]", flowop->fo_stats.fs_minlat / SEC2MS_FLOAT, flowop->fo_stats.fs_maxlat / SEC2MS_FLOAT); (void) strcat(str, line); if (filebench_shm->lathist_enabled) { (void) sprintf(histogram, "\t[ "); for (i = 0; i < OSPROF_BUCKET_NUMBER; i++) { (void) sprintf(hist_reading, "%lu ", flowop->fo_stats.fs_distribution[i]); (void) strcat(histogram, hist_reading); } (void) strcat(histogram, "]\n"); (void) strcat(str, histogram); } else (void) strcat(str, "\n"); flowop = flowop->fo_next; } /* removing last \n */ str[strlen(str) - 1] = '\0'; filebench_log(LOG_INFO, "%s", str); free(str); filebench_log(LOG_INFO, "IO Summary: %5d ops %5.3lf ops/s %0.0lf/%0.0lf rd/wr " "%5.1lfmb/s %5.1fms/op", iostat->fs_count + aiostat->fs_count, (iostat->fs_count + aiostat->fs_count) / total_time_sec, (iostat->fs_rcount + aiostat->fs_rcount) / total_time_sec, (iostat->fs_wcount + aiostat->fs_wcount) / total_time_sec, ((iostat->fs_bytes + aiostat->fs_bytes) / MB_FLOAT) / total_time_sec, (iostat->fs_rcount + iostat->fs_wcount) ? iostat->fs_total_lat / ((iostat->fs_rcount + iostat->fs_wcount) * SEC2MS_FLOAT) : 0); filebench_shm->shm_bequiet = 0; }
int mail_command_update_parse(const char *const *args, const char **error_r) { struct mail_session *session; struct mail_command *cmd; struct stats *new_stats, *diff_stats; buffer_t *buf; const char *error; unsigned int i, cmd_id; bool done = FALSE, continued = FALSE; /* <session guid> <cmd id> [d] <name> <args> <stats> <session guid> <cmd id> c[d] <stats> */ if (str_array_length(args) < 3) { *error_r = "UPDATE-CMD: Too few parameters"; return -1; } if (mail_session_get(args[0], &session, error_r) < 0) return -1; if (str_to_uint(args[1], &cmd_id) < 0 || cmd_id == 0) { *error_r = "UPDATE-CMD: Invalid command id"; return -1; } for (i = 0; args[2][i] != '\0'; i++) { switch (args[2][i]) { case 'd': done = TRUE; break; case 'c': continued = TRUE; break; default: *error_r = "UPDATE-CMD: Invalid flags parameter"; return -1; } } cmd = mail_command_find(session, cmd_id); if (!continued) { /* new command */ if (cmd != NULL) { *error_r = "UPDATE-CMD: Duplicate new command id"; return -1; } if (str_array_length(args) < 5) { *error_r = "UPDATE-CMD: Too few parameters"; return -1; } cmd = mail_command_add(session, args[3], args[4]); cmd->id = cmd_id; session->highest_cmd_id = I_MAX(session->highest_cmd_id, cmd_id); session->num_cmds++; session->user->num_cmds++; session->user->domain->num_cmds++; if (session->ip != NULL) session->ip->num_cmds++; mail_global_stats.num_cmds++; args += 5; } else { if (cmd == NULL) { /* already expired command, ignore */ i_warning("UPDATE-CMD: Already expired"); return 0; } args += 3; cmd->last_update = ioloop_timeval; } buf = t_buffer_create(256); if (args[0] == NULL || base64_decode(args[0], strlen(args[0]), NULL, buf) < 0) { *error_r = t_strdup_printf("UPDATE-CMD: Invalid base64 input"); return -1; } new_stats = stats_alloc(pool_datastack_create()); diff_stats = stats_alloc(pool_datastack_create()); if (!stats_import(buf->data, buf->used, cmd->stats, new_stats, &error)) { *error_r = t_strdup_printf("UPDATE-CMD: %s", error); return -1; } if (!stats_diff(cmd->stats, new_stats, diff_stats, &error)) { *error_r = t_strdup_printf("UPDATE-CMD: stats shrank: %s", error); return -1; } stats_add(cmd->stats, diff_stats); if (done) { cmd->id = 0; mail_command_unref(&cmd); } mail_session_refresh(session, NULL); return 0; }
static int msg_op(char *nick, char *host, struct userrec *u, char *par) { struct chanset_t *chan = NULL; char *pass = NULL; struct flag_record fr = {FR_GLOBAL | FR_CHAN, 0, 0, 0 }; if (match_my_nick(nick)) return BIND_RET_BREAK; pass = newsplit(&par); bd::String msg; if (homechan[0]) { struct chanset_t *hchan = NULL; hchan = findchan_by_dname(homechan); if (hchan && channel_active(hchan) && !ismember(hchan, nick)) { putlog(LOG_CMDS, "*", "(%s!%s) !*! failed OP %s (not in %s)", nick, host, par, homechan); if (par[0]) msg = bd::String::printf("---- (%s!%s) attempted to OP for %s but is not currently in %s.", nick, host, par, homechan); else msg = bd::String::printf("---- (%s!%s) attempted to OP but is not currently in %s.", nick, host, homechan); privmsg(homechan, msg.c_str(), DP_SERVER); return BIND_RET_BREAK; } } if (u_pass_match(u, pass)) { if (!u_pass_match(u, "-")) { if (par[0]) { chan = findchan_by_dname(par); if (chan && channel_active(chan)) { get_user_flagrec(u, &fr, par, chan); if (chk_op(fr, chan)) { if (do_op(nick, chan, 0, 1)) { stats_add(u, 0, 1); putlog(LOG_CMDS, "*", "(%s!%s) !%s! OP %s", nick, host, u->handle, par); if (manop_warn && chan->manop) { msg = bd::String::printf("%s is currently set to punish for manual op.", chan->dname); notice(nick, msg.c_str(), DP_HELP); } } } return BIND_RET_BREAK; } } else { int stats = 0; for (chan = chanset; chan; chan = chan->next) { get_user_flagrec(u, &fr, chan->dname, chan); if (chk_op(fr, chan)) { if (do_op(nick, chan, 0, 1)) { stats++; if (manop_warn && chan->manop) { msg = bd::String::printf("%s is currently set to punish for manual op.", chan->dname); notice(nick, msg.c_str(), DP_HELP); } } } } putlog(LOG_CMDS, "*", "(%s!%s) !%s! OP", nick, host, u->handle); if (stats) stats_add(u, 0, 1); return BIND_RET_BREAK; } } } putlog(LOG_CMDS, "*", "(%s!%s) !*! failed OP", nick, host); return BIND_RET_BREAK; }