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