void depprint(double *hm, double *hd, double *hs, double *hk) { int i, n; double hmean[256], hstd[256], hskew[256], hkurt[256]; double mean, std, skew, kurt; n = 0; for (i = 0; i < 256; i++) { hmean[n] = esterror(hm, i); hstd[n] = esterror(hd, i); hskew[n] = esterror(hs, i); hkurt[n] = esterror(hk, i); if (hm[i] != 0 && hd[i] != 0) n++; } compute_stats(hmean, n, &mean, &std, &skew, &kurt); fprintf(stdout, "%f %f %f %f ", mean, std, skew, kurt); compute_stats(hstd, n, &mean, &std, &skew, &kurt); fprintf(stdout, "%f %f %f %f ", mean, std, skew, kurt); compute_stats(hskew, n, &mean, &std, &skew, &kurt); fprintf(stdout, "%f %f %f %f ", mean, std, skew, kurt); compute_stats(hkurt, n, &mean, &std, &skew, &kurt); fprintf(stdout, "%f %f %f %f ", mean, std, skew, kurt); }
static void devstats(void) { int dn; long double transfers_per_second; long double busy_seconds; diff_cp_time.cp_user = cp_time.cp_user - old_cp_time.cp_user; diff_cp_time.cp_nice = cp_time.cp_nice - old_cp_time.cp_nice; diff_cp_time.cp_sys = cp_time.cp_sys - old_cp_time.cp_sys; diff_cp_time.cp_intr = cp_time.cp_intr - old_cp_time.cp_intr; diff_cp_time.cp_idle = cp_time.cp_idle - old_cp_time.cp_idle; old_cp_time = cp_time; busy_seconds = compute_etime(cur.busy_time, last.busy_time); for (dn = 0; dn < num_devices; dn++) { int di; if ((dev_select[dn].selected == 0) || (dev_select[dn].selected > maxshowdevs)) continue; di = dev_select[dn].position; if (compute_stats(&cur.dinfo->devices[di], &last.dinfo->devices[di], busy_seconds, NULL, NULL, NULL, NULL, &transfers_per_second, NULL, NULL, NULL) != 0) errx(1, "%s", devstat_errbuf); printf("%3.0Lf ", transfers_per_second); } }
void CErrorAnal_dlg::OnChangeStatOptions() { get_stat_options(); // xfer stat options ctls to stat options of active data set list_stats(); compute_stats(); update_stat_param_ctls(); }
void flac__analyze_finish(analysis_options aopts) { if(aopts.do_residual_gnuplot) { compute_stats(&all_); (void)dump_stats(&all_, "all"); } }
// read method implementation char fifo::read () { // local buffer for storing the read byte until return char c; // record time last_time = sc_time_stamp(); // fetch the "oldest" byte in the buffer c = data[first]; // compute the new stats based on new counters compute_stats(); // if the buffer is already empty, we update the empty read counter if (num_elements == 0) { c = '0'; ++ num_emptyread; } // otherwise we decrement the number of elements counter, and // increment the first pointer to point to the next oldest element else { -- num_elements; first = (first + 1) % size; } #ifdef TRACE cout << "-" << c; #endif // return the correct byte return c; }
void CErrorAnal_dlg::OnFilter() { FeatureFilter& filter=active_data()->filter; if (CFeatureFilter_dlg(filter,this).DoModal()!=IDOK) return; list_stats(); compute_stats(); update_stat_param_ctls(); // xfer stats of active data set to stat ctls }
static void perform_ping_test(struct ping_test_recipe recipe, memcached_st *mst, struct moxi_stats *out, int *failures) { double *timing_results = calloc(recipe.iterations, sizeof(double)); assert(timing_results); struct timeval timing = { 0, 0 }; char *key = calloc(recipe.keysize, sizeof(char)); assert(key); char *value = calloc(recipe.valsize, sizeof(char)); assert(value); /* Key is all 't's...just because */ memset(key, 't', recipe.keysize); /* Value is a random bunch of stuff */ for (int i = 0; i < recipe.valsize; i++) { value[i] = random() & 0xff; } if (memcached_set(mst, key, recipe.keysize, value, recipe.valsize, 0, 0) != MEMCACHED_SUCCESS) { /* XXX: Failure */ } for (int i = 0 ; i < recipe.iterations; i++) { struct timeval tv_pre = { 0, 0 } , tv_post = { 0, 0 }; size_t retrieved_len = 0; uint32_t flags = 0; memcached_return error; gettimeofday(&tv_pre, NULL); char *retrieved = memcached_get(mst, key, recipe.keysize, &retrieved_len, &flags, &error); gettimeofday(&tv_post, NULL); timeval_subtract(&timing, &tv_post, &tv_pre); timing_results[i] = timeval_to_double(timing); if (retrieved) { free(retrieved); } else { (*failures)++; } } compute_stats(out, timing_results, recipe.iterations); free(timing_results); free(key); free(value); }
void CErrorAnal_dlg::compute_stats(AnalData *data) { if (!data) { compute_stats(&m_peak_data); if (m_separam) { compute_stats(&m_sadl_data); m_mahal=m_peak_data.regress.mahal(m_sadl_data.regress); } return; } data->regress.summarize(); m_more_params.EnableWindow(data->regress.n>data->regress.nparam); //if (data->gamma<0) { //AfxMessageBox("Unaccounted model error is negative!\n" //"Is your calibration range too low?",MB_ICONWARNING); //} //if (data==active_data()) update_stat_option_ctls(); }
void Histogram::high_clip( float val ) { high_clip_ = val; recompute_ = true; if( val < low_clip_ ) end_ = start_; else end_ = std::upper_bound( data_.begin(), data_.end(), high_clip_ ); compute_stats(); bins( bins_count_ ); }
void Histogram::low_clip( float val ) { low_clip_ = val; recompute_ = true; if( val > high_clip_ ) start_ = end_; else start_ = std::lower_bound( data_.begin(), data_.end(), low_clip_ ); compute_stats(); bins( bins_count_ ); }
void read(char &c){ last_time = sc_time_stamp(); if (num_elements == 0) wait(write_event); compute_stats(); c = data[first]; -- num_elements; first = (first + 1) % size; read_event.notify(); }
void Histogram::clipping_values( std::pair<float,float> vals ) { recompute_ = true; if( vals.second < vals.first ) vals.second = vals.first; low_clip_ = vals.first; high_clip_ = vals.second; start_ = std::lower_bound( data_.begin(), data_.end(), low_clip_ ); end_ = std::upper_bound( data_.begin(), data_.end(), high_clip_ ); compute_stats(); bins( bins_count_ ); }
void CErrorAnal_dlg::set_tabs() { m_featr_type_tab.DeleteAllItems(); if (m_separam) { m_featr_type_tab.InsertItem(0,"Peak"); m_featr_type_tab.InsertItem(1,"Saddle"); } else m_featr_type_tab.InsertItem(0,"Peak && Saddle"); list_stats(); compute_stats(0); update_option_ctls(); update_stat_param_ctls(); }
// [[Rcpp::export]] DataFrame compute_stats(NumericVector observed, NumericVector predicted) { vec obs = as<std::vector<double> >(observed); vec pred = as<std::vector<double> >(predicted); PredStats output = compute_stats(obs, pred); return DataFrame::create( Named("num_pred") = output.num_pred, Named("rho") = output.rho, Named("mae") = output.mae, Named("rmse") = output.rmse, Named("perc") = output.perc, Named("p_val") = output.p_val); }
void do_read_write(long *sizes, DATATYPE *x, double *times, double *bws, double *percents) { long limit, j, i, tloops; double refcnt, overhead_per_ref = 0.0, tmicrosec; /* double nullcnt = 0.0, cmicrosec = 0.0; */ if (my_isatty(1)) { printf("\n\t\t%s%s%s RMW Cache Test\n\n", ((type & HANDTUNED) ? "Tuned " : ""), ((!(type & NOCALIBRATE)) ? "Calibrated " : ""), DATASTRING); printf("C Size\t\tNanosec\t\tMB/sec\t\t%% Chnge\n"); printf("-------\t\t-------\t\t-------\t\t-------\n"); } for (i = 0; i < timeslots; i++) { limit = sizes[i] / (long)sizeof(DATATYPE); for (j = 0; j < repeat_count; j++) { if (type & HANDTUNED) refcnt = hand_benchmark_cache(x, limit, &tloops, &tmicrosec) * 2.0; else refcnt = benchmark_cache(x, limit, &tloops, &tmicrosec) * 2.0; /* if (type & NOCALIBRATE) { nullcnt = 0.0; overhead_per_ref = 0.0; cmicrosec = 0.0; } else { nullcnt = calibrate_benchmark(x, tloops, limit, &cmicrosec); nullcnt *= 2; overhead_per_ref = (cmicrosec*1000.0) / nullcnt; DBG(fprintf(stderr,"C: %f ns per ref.\n",overhead_per_ref)); } */ compute_stats(i,j,refcnt,overhead_per_ref,times,bws,percents,sizes,tmicrosec,sizeof(DATATYPE)); } } /* if ((my_isatty(1))&&(type&GUESSCACHESIZE)) compute_cache_sizes(times,bws,percents,sizes); */ }
double * roughness_transform(short *dcts, int bits, int *pnpoints) { double mean, std, skew, kurt; static double output[8]; double *poutput, *points; int i, j, n, off, npoints; n = bits / DCTSIZE2; if ((points = malloc(n * sizeof(double))) == NULL) err(1, "malloc"); /* Computes frequency averaged roughness */ for (i = 0; i < n; i++) { double sum = 0, weight = 0, val; off = i * DCTSIZE2; for (j = 0; j < DCTSIZE2; j++) { int u, v; val = dcts[off + j]; u = j / 8; v = j % 8; sum += (u*u + v*v) * val * val; weight += (u*u + v*v); } points[i] = sqrt(sum/weight); } compute_stats(points, n, &mean, &std, &skew, &kurt); npoints = 0; poutput = output; *poutput++ = mean; *poutput++ = std; *poutput++ = skew; *poutput++ = kurt; npoints += 4; *pnpoints = npoints; free(points); return (output); }
void do_memory_copy(long *sizes, void *x, double *times, double *bws, double *percents) { long limit, j, i, tloops; double refcnt, overhead_per_ref = 0.0, tmicrosec; /* double nullcnt = 0.0, cmicrosec = 0.0; */ void *y; assert(y = (void *)malloc(memsize)); memset(y,0x0f,memsize); if (my_isatty(1)) { printf("\n\t\t%sMemory Copy Library Cache Test\n\n", (!(type & NOCALIBRATE)) ? "Calibrated " : ""); printf("C Size\t\tNanosec\t\tMB/sec\t\t%% Chnge\n"); printf("-------\t\t-------\t\t-------\t\t-------\n"); } for (i = 0; i < timeslots; i++) { limit = sizes[i]; for (j = 0; j < repeat_count; j++) { refcnt = benchmark_cache_memory_copy(x, y, limit, &tloops, &tmicrosec) * 2.0; /* if (type & NOCALIBRATE) { nullcnt = 0.0; overhead_per_ref = 0.0; cmicrosec = 0.0; } else { nullcnt = calibrate_benchmark_cache_memory_copy(x, tloops, limit, &cmicrosec); overhead_per_ref = (cmicrosec*1000.0) / nullcnt; DBG(fprintf(stderr,"C: %f ns per ref.\n",overhead_per_ref)); } */ compute_stats(i,j,refcnt,overhead_per_ref,times,bws,percents,sizes,tmicrosec,1); } } /* if ((my_isatty(1))&&(type&GUESSCACHESIZE)) compute_cache_sizes(times,bws,percents,sizes); */ free(y); }
END_TEST START_TEST (test_compute_stats) { double vals[] = { 2, 4, 4, 4, 5, 5, 7, 9 }; struct moxi_stats stats; compute_stats(&stats, vals, sizeof(vals) / sizeof(double)); fail_unless(almost_equal(stats.min, 2.0), "Min should be 2"); fail_unless(almost_equal(stats.max, 9.0), "Max should be 9"); fail_unless(almost_equal(stats.avg, 5.0), "Avg should be 5"); fail_unless(almost_equal(stats.stddev, 2.0), "Standard devition should be 2."); fail_unless(almost_equal(stats.ninetyfifth, 9.0), "95th %%ile should be 9."); }
void CErrorAnal_dlg::OnOptions() { CStatOptions_dlg dlg; Stat_options& options=active_data()->options; dlg.m_symmetry=options.symmetry; dlg.m_min_nbr=options.mns; dlg.m_measr_error=options.measr_err; dlg.m_convolutn=options.nconv_inuse>0; if (dlg.DoModal()!=IDOK) return; options.symmetry=(Stat_options::Symmetry)dlg.m_symmetry; options.mns=(Stat_options::Min_nbr_set)dlg.m_min_nbr; options.measr_err=dlg.m_measr_error!=FALSE; options.nconv_inuse=dlg.m_convolutn?1:0; list_stats(); compute_stats(); update_stat_param_ctls(); }
double distribution(int slot, short *data, int bits, double *p) { double mean, std, skew, kurt; int i, j, n, nsimple; double *simple; double *herror; short *ndata; n = bits / DCTSIZE2; if ((ndata = malloc(n * sizeof(short))) == NULL) err(1, "malloc"); for (j = 0; j < n; j++) ndata[j] = data[j*DCTSIZE2 + slot]; histogram(ndata, n, &simple, &nsimple); free(ndata); if ((herror = calloc(nsimple, sizeof(double))) == NULL) err(1, "malloc"); for (i = 2; i < nsimple - 2; i++) { if (simple[i] != 0) herror[i] = esterror2(simple, i, nsimple-1)/simple[i]; else herror[i] = 0; /* fprintf(stderr, "%d %f\n", i, herror[i]); */ } compute_stats(herror, nsimple, &mean, &std, &skew, &kurt); free(simple); free(herror); *p++ = mean; *p++ = std; *p++ = skew; *p++ = kurt; return (0); }
static int devstats(int row, int _col, int dn) { long double transfers_per_second; long double kb_per_transfer, mb_per_second; long double busy_seconds; int di; di = dev_select[dn].position; busy_seconds = compute_etime(cur.busy_time, last.busy_time); if (compute_stats(&cur.dinfo->devices[di], &last.dinfo->devices[di], busy_seconds, NULL, NULL, NULL, &kb_per_transfer, &transfers_per_second, &mb_per_second, NULL, NULL) != 0) errx(1, "%s", devstat_errbuf); if (numbers) { mvwprintw(wnd, row, _col, " %5.2Lf %3.0Lf %5.2Lf ", kb_per_transfer, transfers_per_second, mb_per_second); return(row); } wmove(wnd, row++, _col); histogram(mb_per_second, 50, .5); wmove(wnd, row++, _col); histogram(transfers_per_second, 50, .5); if (kbpt) { wmove(wnd, row++, _col); histogram(kb_per_transfer, 50, .5); } return(row); }
PredStats ForecastMachine::make_const_stats() { return compute_stats(targets, const_predicted); }
void flac__analyze_frame(const FLAC__Frame *frame, unsigned frame_number, FLAC__uint64 frame_offset, unsigned frame_bytes, analysis_options aopts, FILE *fout) { const unsigned channels = frame->header.channels; char outfilename[1024]; subframe_stats_t stats; unsigned i, channel, partitions; /* do the human-readable part first */ #ifdef __MSVCRT__ fprintf(fout, "frame=%u\toffset=%I64u\tbits=%u\tblocksize=%u\tsample_rate=%u\tchannels=%u\tchannel_assignment=%s\n", frame_number, frame_offset, frame_bytes*8, frame->header.blocksize, frame->header.sample_rate, channels, FLAC__ChannelAssignmentString[frame->header.channel_assignment]); #else fprintf(fout, "frame=%u\toffset=%llu\tbits=%u\tblocksize=%u\tsample_rate=%u\tchannels=%u\tchannel_assignment=%s\n", frame_number, (unsigned long long)frame_offset, frame_bytes*8, frame->header.blocksize, frame->header.sample_rate, channels, FLAC__ChannelAssignmentString[frame->header.channel_assignment]); #endif for(channel = 0; channel < channels; channel++) { const FLAC__Subframe *subframe = frame->subframes+channel; const FLAC__bool is_rice2 = subframe->data.fixed.entropy_coding_method.type == FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2; const unsigned pesc = is_rice2? FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER : FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER; fprintf(fout, "\tsubframe=%u\twasted_bits=%u\ttype=%s", channel, subframe->wasted_bits, FLAC__SubframeTypeString[subframe->type]); switch(subframe->type) { case FLAC__SUBFRAME_TYPE_CONSTANT: fprintf(fout, "\tvalue=%d\n", subframe->data.constant.value); break; case FLAC__SUBFRAME_TYPE_FIXED: FLAC__ASSERT(subframe->data.fixed.entropy_coding_method.type <= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2); fprintf(fout, "\torder=%u\tresidual_type=%s\tpartition_order=%u\n", subframe->data.fixed.order, is_rice2? "RICE2":"RICE", subframe->data.fixed.entropy_coding_method.data.partitioned_rice.order); for(i = 0; i < subframe->data.fixed.order; i++) fprintf(fout, "\t\twarmup[%u]=%d\n", i, subframe->data.fixed.warmup[i]); partitions = (1u << subframe->data.fixed.entropy_coding_method.data.partitioned_rice.order); for(i = 0; i < partitions; i++) { unsigned parameter = subframe->data.fixed.entropy_coding_method.data.partitioned_rice.contents->parameters[i]; if(parameter == pesc) fprintf(fout, "\t\tparameter[%u]=ESCAPE, raw_bits=%u\n", i, subframe->data.fixed.entropy_coding_method.data.partitioned_rice.contents->raw_bits[i]); else fprintf(fout, "\t\tparameter[%u]=%u\n", i, parameter); } if(aopts.do_residual_text) { for(i = 0; i < frame->header.blocksize-subframe->data.fixed.order; i++) fprintf(fout, "\t\tresidual[%u]=%d\n", i, subframe->data.fixed.residual[i]); } break; case FLAC__SUBFRAME_TYPE_LPC: FLAC__ASSERT(subframe->data.lpc.entropy_coding_method.type <= FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2); fprintf(fout, "\torder=%u\tqlp_coeff_precision=%u\tquantization_level=%d\tresidual_type=%s\tpartition_order=%u\n", subframe->data.lpc.order, subframe->data.lpc.qlp_coeff_precision, subframe->data.lpc.quantization_level, is_rice2? "RICE2":"RICE", subframe->data.lpc.entropy_coding_method.data.partitioned_rice.order); for(i = 0; i < subframe->data.lpc.order; i++) fprintf(fout, "\t\tqlp_coeff[%u]=%d\n", i, subframe->data.lpc.qlp_coeff[i]); for(i = 0; i < subframe->data.lpc.order; i++) fprintf(fout, "\t\twarmup[%u]=%d\n", i, subframe->data.lpc.warmup[i]); partitions = (1u << subframe->data.lpc.entropy_coding_method.data.partitioned_rice.order); for(i = 0; i < partitions; i++) { unsigned parameter = subframe->data.lpc.entropy_coding_method.data.partitioned_rice.contents->parameters[i]; if(parameter == pesc) fprintf(fout, "\t\tparameter[%u]=ESCAPE, raw_bits=%u\n", i, subframe->data.lpc.entropy_coding_method.data.partitioned_rice.contents->raw_bits[i]); else fprintf(fout, "\t\tparameter[%u]=%u\n", i, parameter); } if(aopts.do_residual_text) { for(i = 0; i < frame->header.blocksize-subframe->data.lpc.order; i++) fprintf(fout, "\t\tresidual[%u]=%d\n", i, subframe->data.lpc.residual[i]); } break; case FLAC__SUBFRAME_TYPE_VERBATIM: fprintf(fout, "\n"); break; } } /* now do the residual distributions if requested */ if(aopts.do_residual_gnuplot) { for(channel = 0; channel < channels; channel++) { const FLAC__Subframe *subframe = frame->subframes+channel; unsigned residual_samples; init_stats(&stats); switch(subframe->type) { case FLAC__SUBFRAME_TYPE_FIXED: residual_samples = frame->header.blocksize - subframe->data.fixed.order; for(i = 0; i < residual_samples; i++) update_stats(&stats, subframe->data.fixed.residual[i], 1); break; case FLAC__SUBFRAME_TYPE_LPC: residual_samples = frame->header.blocksize - subframe->data.lpc.order; for(i = 0; i < residual_samples; i++) update_stats(&stats, subframe->data.lpc.residual[i], 1); break; default: break; } /* update all_ */ for(i = 0; i < stats.nbuckets; i++) { update_stats(&all_, stats.buckets[i].residual, stats.buckets[i].count); } /* write the subframe */ sprintf(outfilename, "f%06u.s%u.gp", frame_number, channel); compute_stats(&stats); (void)dump_stats(&stats, outfilename); } } }
int main(int argc, char* argv[]) { std::deque<std::string> str_list; switch (argc) { case 1 : strtk::load_from_text_file(std::cin,str_list); break; case 2 : strtk::load_from_text_file(argv[1],str_list); break; default : { std::cout << "usage: strtk_numstats <file name>" << std::endl; std::cout << "usage: cat data.txt | strtk_numstats" << std::endl; return 1; } } if (str_list.empty()) return 0; std::size_t total_length = 0; for (std::size_t i = 0; i < str_list.size(); total_length += str_list[i++].size()) ; std::string buffer; buffer.reserve(total_length + str_list.size()); strtk::join(buffer,"\n",str_list); std::vector<double> value_list; value_list.reserve(str_list.size()); str_list.clear(); strtk::token_grid::options options; options.set_column_delimiters(", "); strtk::token_grid grid(buffer.data(), buffer.size(), options); grid.remove_empty_tokens(); for (std::size_t column = 0; column < grid.max_column_count(); ++column) { value_list.clear(); grid.extract_column_checked(column,value_list); if (value_list.empty()) continue; std::cout << "C["<< column << "]" << "\t"; compute_stats(value_list); std::cout << std::endl; } for (std::size_t row = 0; row < grid.row_count(); ++row) { value_list.clear(); grid.row(row).parse_checked(value_list); if (value_list.empty()) continue; std::cout << "R["<< row << "]" << "\t"; compute_stats(value_list); std::cout << std::endl; } return 0; }
static void ctlstat_standard(struct ctlstat_context *ctx) { long double etime; uint64_t delta_jiffies, delta_idle; uint32_t port; long double cpu_percentage; int i; int j; cpu_percentage = 0; if (F_CPU(ctx) && (getcpu(&ctx->cur_cpu) != 0)) errx(1, "error returned from getcpu()"); etime = ctx->cur_time.tv_sec - ctx->prev_time.tv_sec + (ctx->prev_time.tv_nsec - ctx->cur_time.tv_nsec) * 1e-9; if (F_CPU(ctx)) { ctx->prev_total_jiffies = ctx->cur_total_jiffies; ctx->cur_total_jiffies = ctx->cur_cpu.user + ctx->cur_cpu.nice + ctx->cur_cpu.system + ctx->cur_cpu.intr + ctx->cur_cpu.idle; delta_jiffies = ctx->cur_total_jiffies; if (F_FIRST(ctx) == 0) delta_jiffies -= ctx->prev_total_jiffies; ctx->prev_idle = ctx->cur_idle; ctx->cur_idle = ctx->cur_cpu.idle; delta_idle = ctx->cur_idle - ctx->prev_idle; cpu_percentage = delta_jiffies - delta_idle; cpu_percentage /= delta_jiffies; cpu_percentage *= 100; } if (F_HDR(ctx)) { ctx->header_interval--; if (ctx->header_interval <= 0) { int hdr_devs; hdr_devs = 0; if (F_TOTALS(ctx)) { fprintf(stdout, "%s System Read %s" "System Write %sSystem Total%s\n", (F_LUNVAL(ctx) != 0) ? " " : "", (F_LUNVAL(ctx) != 0) ? " " : "", (F_LUNVAL(ctx) != 0) ? " " : "", (F_CPU(ctx) == 0) ? " CPU" : ""); hdr_devs = 3; } else { if (F_CPU(ctx)) fprintf(stdout, " CPU "); for (i = 0; i < min(CTL_STAT_LUN_BITS, ctx->num_luns); i++) { int lun; /* * Obviously this won't work with * LUN numbers greater than a signed * integer. */ lun = (int)ctx->cur_lun_stats[i ].lun_number; if (bit_test(ctx->lun_mask, lun) == 0) continue; fprintf(stdout, "%15.6s%d ", "lun", lun); hdr_devs++; } fprintf(stdout, "\n"); } for (i = 0; i < hdr_devs; i++) fprintf(stdout, "%s %sKB/t %s MB/s ", ((F_CPU(ctx) != 0) && (i == 0) && (F_TOTALS(ctx) == 0)) ? " " : "", (F_LUNVAL(ctx) != 0) ? " ms " : "", (F_DMA(ctx) == 0) ? "tps" : "dps"); fprintf(stdout, "\n"); ctx->header_interval = 20; } } if (F_TOTALS(ctx) != 0) { long double mbsec[3]; long double kb_per_transfer[3]; long double transfers_per_sec[3]; long double ms_per_transfer[3]; long double ms_per_dma[3]; long double dmas_per_sec[3]; for (i = 0; i < 3; i++) ctx->prev_total_stats[i] = ctx->cur_total_stats[i]; memset(&ctx->cur_total_stats, 0, sizeof(ctx->cur_total_stats)); /* Use macros to make the next loop more readable. */ #define ADD_STATS_BYTES(st, p, i, j) \ ctx->cur_total_stats[st].ports[p].bytes[j] += \ ctx->cur_lun_stats[i].ports[p].bytes[j] #define ADD_STATS_OPERATIONS(st, p, i, j) \ ctx->cur_total_stats[st].ports[p].operations[j] += \ ctx->cur_lun_stats[i].ports[p].operations[j] #define ADD_STATS_NUM_DMAS(st, p, i, j) \ ctx->cur_total_stats[st].ports[p].num_dmas[j] += \ ctx->cur_lun_stats[i].ports[p].num_dmas[j] #define ADD_STATS_TIME(st, p, i, j) \ bintime_add(&ctx->cur_total_stats[st].ports[p].time[j], \ &ctx->cur_lun_stats[i].ports[p].time[j]) #define ADD_STATS_DMA_TIME(st, p, i, j) \ bintime_add(&ctx->cur_total_stats[st].ports[p].dma_time[j], \ &ctx->cur_lun_stats[i].ports[p].dma_time[j]) for (i = 0; i < ctx->num_luns; i++) { for (port = 0; port < CTL_MAX_PORTS; port++) { for (j = 0; j < CTL_STATS_NUM_TYPES; j++) { ADD_STATS_BYTES(2, port, i, j); ADD_STATS_OPERATIONS(2, port, i, j); ADD_STATS_NUM_DMAS(2, port, i, j); ADD_STATS_TIME(2, port, i, j); ADD_STATS_DMA_TIME(2, port, i, j); } ADD_STATS_BYTES(0, port, i, CTL_STATS_READ); ADD_STATS_OPERATIONS(0, port, i, CTL_STATS_READ); ADD_STATS_NUM_DMAS(0, port, i, CTL_STATS_READ); ADD_STATS_TIME(0, port, i, CTL_STATS_READ); ADD_STATS_DMA_TIME(0, port, i, CTL_STATS_READ); ADD_STATS_BYTES(1, port, i, CTL_STATS_WRITE); ADD_STATS_OPERATIONS(1, port, i, CTL_STATS_WRITE); ADD_STATS_NUM_DMAS(1, port, i, CTL_STATS_WRITE); ADD_STATS_TIME(1, port, i, CTL_STATS_WRITE); ADD_STATS_DMA_TIME(1, port, i, CTL_STATS_WRITE); } } for (i = 0; i < 3; i++) { compute_stats(&ctx->cur_total_stats[i], F_FIRST(ctx) ? NULL : &ctx->prev_total_stats[i], etime, &mbsec[i], &kb_per_transfer[i], &transfers_per_sec[i], &ms_per_transfer[i], &ms_per_dma[i], &dmas_per_sec[i]); if (F_DMA(ctx) != 0) fprintf(stdout, " %2.2Lf", ms_per_dma[i]); else if (F_LUNVAL(ctx) != 0) fprintf(stdout, " %2.2Lf", ms_per_transfer[i]); fprintf(stdout, " %5.2Lf %3.0Lf %5.2Lf ", kb_per_transfer[i], (F_DMA(ctx) == 0) ? transfers_per_sec[i] : dmas_per_sec[i], mbsec[i]); } if (F_CPU(ctx)) fprintf(stdout, " %5.1Lf%%", cpu_percentage); } else { if (F_CPU(ctx)) fprintf(stdout, "%5.1Lf%% ", cpu_percentage); for (i = 0; i < min(CTL_STAT_LUN_BITS, ctx->num_luns); i++) { long double mbsec, kb_per_transfer; long double transfers_per_sec; long double ms_per_transfer; long double ms_per_dma; long double dmas_per_sec; if (bit_test(ctx->lun_mask, (int)ctx->cur_lun_stats[i].lun_number) == 0) continue; compute_stats(&ctx->cur_lun_stats[i], F_FIRST(ctx) ? NULL : &ctx->prev_lun_stats[i], etime, &mbsec, &kb_per_transfer, &transfers_per_sec, &ms_per_transfer, &ms_per_dma, &dmas_per_sec); if (F_DMA(ctx)) fprintf(stdout, " %2.2Lf", ms_per_dma); else if (F_LUNVAL(ctx) != 0) fprintf(stdout, " %2.2Lf", ms_per_transfer); fprintf(stdout, " %5.2Lf %3.0Lf %5.2Lf ", kb_per_transfer, (F_DMA(ctx) == 0) ? transfers_per_sec : dmas_per_sec, mbsec); } } }
int main(int argc, char **argv) { uint64_t iterations, i; double *jitter_arr, *fraction_arr; double *wakeup_second_jitter_arr; uint64_t target_time; uint64_t sleep_length_abs; uint64_t min_sleep_ns = 0; uint64_t max_sleep_ns = DEFAULT_MAX_SLEEP_NS; uint64_t wake_time; unsigned random_seed; boolean_t need_seed = TRUE; char ch; int res; kern_return_t kret; my_policy_type_t pol; boolean_t wakeup_second_thread = FALSE; semaphore_t wakeup_semaphore, return_semaphore; double avg, stddev, max, min; double avg_fract, stddev_fract, max_fract, min_fract; uint64_t too_much; struct second_thread_args secargs; pthread_t secthread; mach_timebase_info(&g_mti); /* Seed random */ opterr = 0; while ((ch = getopt(argc, argv, "m:n:hs:w")) != -1 && ch != '?') { switch (ch) { case 's': /* Specified seed for random)() */ random_seed = (unsigned)atoi(optarg); srandom(random_seed); need_seed = FALSE; break; case 'm': /* How long per timer? */ max_sleep_ns = strtoull(optarg, NULL, 10); break; case 'n': /* How long per timer? */ min_sleep_ns = strtoull(optarg, NULL, 10); break; case 'w': /* After each timed wait, wakeup another thread */ wakeup_second_thread = TRUE; break; case 'h': print_usage(); exit(0); break; default: fprintf(stderr, "Got unexpected result from getopt().\n"); exit(1); break; } } argc -= optind; argv += optind; if (argc != 3) { print_usage(); exit(1); } if (min_sleep_ns >= max_sleep_ns) { print_usage(); exit(1); } if (need_seed) { srandom(time(NULL)); } /* What scheduling policy? */ pol = parse_thread_policy(argv[0]); /* How many timers? */ iterations = strtoull(argv[1], NULL, 10); /* How much jitter is so extreme that we should cut a trace point */ too_much = strtoull(argv[2], NULL, 10); /* Array for data */ jitter_arr = (double*)malloc(sizeof(*jitter_arr) * iterations); if (jitter_arr == NULL) { printf("Couldn't allocate array to store results.\n"); exit(1); } fraction_arr = (double*)malloc(sizeof(*fraction_arr) * iterations); if (fraction_arr == NULL) { printf("Couldn't allocate array to store results.\n"); exit(1); } if (wakeup_second_thread) { /* Array for data */ wakeup_second_jitter_arr = (double*)malloc(sizeof(*jitter_arr) * iterations); if (wakeup_second_jitter_arr == NULL) { printf("Couldn't allocate array to store results.\n"); exit(1); } kret = semaphore_create(mach_task_self(), &wakeup_semaphore, SYNC_POLICY_FIFO, 0); if (kret != KERN_SUCCESS) { printf("Couldn't allocate semaphore %d\n", kret); exit(1); } kret = semaphore_create(mach_task_self(), &return_semaphore, SYNC_POLICY_FIFO, 0); if (kret != KERN_SUCCESS) { printf("Couldn't allocate semaphore %d\n", kret); exit(1); } secargs.wakeup_semaphore = wakeup_semaphore; secargs.return_semaphore = return_semaphore; secargs.iterations = iterations; secargs.pol = pol; secargs.wakeup_second_jitter_arr = wakeup_second_jitter_arr; secargs.woke_on_same_cpu = 0; secargs.too_much = too_much; secargs.last_poke_time = 0ULL; secargs.cpuno = 0; res = pthread_create(§hread, NULL, second_thread, &secargs); if (res) { err(1, "pthread_create"); } sleep(1); /* Time for other thread to start up */ } /* Set scheduling policy */ res = thread_setup(pol); if (res != 0) { printf("Couldn't set thread policy.\n"); exit(1); } /* * Repeatedly pick a random timer length and * try to sleep exactly that long */ for (i = 0; i < iterations; i++) { sleep_length_abs = (uint64_t) (get_random_sleep_length_abs_ns(min_sleep_ns, max_sleep_ns) * (((double)g_mti.denom) / ((double)g_mti.numer))); target_time = mach_absolute_time() + sleep_length_abs; /* Sleep */ kret = mach_wait_until(target_time); wake_time = mach_absolute_time(); jitter_arr[i] = (double)(wake_time - target_time); fraction_arr[i] = jitter_arr[i] / ((double)sleep_length_abs); /* Too much: cut a tracepoint for a debugger */ if (jitter_arr[i] >= too_much) { kdebug_trace(0xeeeee0 | DBG_FUNC_NONE, 0, 0, 0, 0); } if (wakeup_second_thread) { secargs.last_poke_time = mach_absolute_time(); secargs.cpuno = cpu_number(); OSMemoryBarrier(); kret = semaphore_signal(wakeup_semaphore); if (kret != KERN_SUCCESS) { errx(1, "semaphore_signal"); } kret = semaphore_wait(return_semaphore); if (kret != KERN_SUCCESS) { errx(1, "semaphore_wait"); } } } /* * Compute statistics and output results. */ compute_stats(jitter_arr, iterations, &avg, &max, &min, &stddev); compute_stats(fraction_arr, iterations, &avg_fract, &max_fract, &min_fract, &stddev_fract); putchar('\n'); print_stats_us("jitter", avg, max, min, stddev); print_stats_fract("%", avg_fract, max_fract, min_fract, stddev_fract); if (wakeup_second_thread) { res = pthread_join(secthread, NULL); if (res) { err(1, "pthread_join"); } compute_stats(wakeup_second_jitter_arr, iterations, &avg, &max, &min, &stddev); putchar('\n'); print_stats_us("second jitter", avg, max, min, stddev); putchar('\n'); printf("%llu/%llu (%.1f%%) wakeups on same CPU\n", secargs.woke_on_same_cpu, iterations, 100.0*((double)secargs.woke_on_same_cpu)/iterations); } return 0; }
static void dinfo(int dn, int lc, struct statinfo *now, struct statinfo *then) { long double kb_per_transfer; long double transfers_per_secondr; long double transfers_per_secondw; long double mb_per_secondr; long double mb_per_secondw; long double elapsed_time, device_busy; int di; di = dev_select[dn].position; elapsed_time = compute_etime(now->busy_time, then ? then->busy_time : now->dinfo->devices[di].dev_creation_time); device_busy = compute_etime(now->dinfo->devices[di].busy_time, then ? then->dinfo->devices[di].busy_time : now->dinfo->devices[di].dev_creation_time); if (compute_stats( &now->dinfo->devices[di], (then ? &then->dinfo->devices[di] : NULL), elapsed_time, NULL, NULL, NULL, &kb_per_transfer, NULL, NULL, NULL, NULL) != 0) errx(1, "%s", devstat_errbuf); if (compute_stats_read( &now->dinfo->devices[di], (then ? &then->dinfo->devices[di] : NULL), elapsed_time, NULL, NULL, NULL, NULL, &transfers_per_secondr, &mb_per_secondr, NULL, NULL) != 0) errx(1, "%s", devstat_errbuf); if (compute_stats_write( &now->dinfo->devices[di], (then ? &then->dinfo->devices[di] : NULL), elapsed_time, NULL, NULL, NULL, NULL, &transfers_per_secondw, &mb_per_secondw, NULL, NULL) != 0) errx(1, "%s", devstat_errbuf); if ((device_busy == 0) && (transfers_per_secondr > 5 || transfers_per_secondw > 5)) { /* the device has been 100% busy, fake it because * as long as the device is 100% busy the busy_time * field in the devstat struct is not updated */ device_busy = elapsed_time; } if (device_busy > elapsed_time) { /* this normally happens after one or more periods * where the device has been 100% busy, correct it */ device_busy = elapsed_time; } lc = DISKCOL + lc * 6; putlongdoublez(kb_per_transfer, DISKROW + 1, lc, 5, 2, 0); putlongdoublez(transfers_per_secondr, DISKROW + 2, lc, 5, 0, 0); putlongdoublez(mb_per_secondr, DISKROW + 3, lc, 5, 2, 0); putlongdoublez(transfers_per_secondw, DISKROW + 4, lc, 5, 0, 0); putlongdoublez(mb_per_secondw, DISKROW + 5, lc, 5, 2, 0); putlongdouble(device_busy * 100 / elapsed_time, DISKROW + 6, lc, 5, 0, 0); }
void CErrorAnal_dlg::compute_stats() { compute_stats(active_data()); if (m_separam) m_mahal=m_peak_data.regress.mahal(m_sadl_data.regress); }
double * diffsquare_transform(short *dcts, int bits, int *pnpoints) { double mean, std, skew, kurt; static double output[64]; double *poutput, *points; int i, j, k, n, off, npoints; n = bits / DCTSIZE2; if ((points = malloc(n * sizeof(double))) == NULL) err(1, "malloc"); npoints = 0; poutput = output; for (k = 0; k < DCTSIZE; k++) { for (i = 0; i < n; i++) { double sum = 0; double val1, val2, weight = 0; off = i * DCTSIZE2; for (j = 0; j < DCTSIZE - 1; j++) { val1 = dcts[off + k * DCTSIZE + j]; val2 = dcts[off + k * DCTSIZE + j + 1]; sum += (val2 - val1) * (val2 - val1); weight += abs(val1); } points[i] = sqrt(sum)/(weight + 1); } compute_stats(points, n, &mean, &std, &skew, &kurt); *poutput++ = mean; *poutput++ = std; *poutput++ = skew; *poutput++ = kurt; npoints += 4; } for (k = 0; k < DCTSIZE; k++) { for (i = 0; i < n; i++) { double sum = 0; double val1, val2, weight = 0; off = i * DCTSIZE2; for (j = 0; j < DCTSIZE - 1; j++) { val1 = dcts[off + k + DCTSIZE * j]; val2 = dcts[off + k + DCTSIZE * (j + 1)]; sum += (val2 - val1) * (val2 - val1); weight += abs(val1); } points[i] = sqrt(sum)/(weight + 1); } compute_stats(points, n, &mean, &std, &skew, &kurt); *poutput++ = mean; *poutput++ = std; *poutput++ = skew; *poutput++ = kurt; npoints += 4; } *pnpoints = npoints; free(points); return (output); }
double dependency(int one, int two, short *data, int bits, double *hmean, double *hstd, double *hskew, double *hkurt) { double mean, std, skew, kurt; int i, j, n; short dct, dctnext; u_short model[256][256]; double *simple[256]; size_t nsimple[256]; memset(hmean, 0, 256*sizeof(double)); memset(hstd, 0, 256*sizeof(double)); memset(hskew, 0, 256*sizeof(double)); memset(hkurt, 0, 256*sizeof(double)); memset(model, 0, sizeof(model)); memset(simple, 0, sizeof(simple)); for (i = 0; i < bits; i+= DCTSIZE2) { dct = data[i + one]; dctnext = data[i + two]; dct += 128; dctnext += 128; if (dct > 255 || dctnext > 255) continue; model[dct][dctnext]++; } for (i = 0; i < 256; i++) { double *p; n = 0; for (j = 0; j < 256; j++) { n += model[i][j]; } nsimple[i] = n; simple[i] = malloc(n * sizeof(double)); if (simple[i] == NULL) err(1, "malloc"); p = simple[i]; for (j = 0; j < 256; j++) { n = model[i][j]; while (n-- > 0) *p++ = j; } } n = 0; for (i = 0; i < 256; i++) { if (nsimple[i] > 4) { compute_stats(simple[i], nsimple[i], &mean, &std, &skew, &kurt); hmean[i] = mean; hstd[i] = std; hskew[i] = skew; hkurt[i] = kurt; n++; } } for (i = 0; i < 256; i++) free(simple[i]); return (0); }