static char* test_reset() { load_histograms(); // before mu_assert("Value at 99% == 0.0", hdr_value_at_percentile(raw_histogram, 99.0) != 0); mu_assert("Value at 99% == 0.0", hdr_value_at_percentile(cor_histogram, 99.0) != 0); hdr_reset(raw_histogram); hdr_reset(cor_histogram); //after mu_assert("Total raw count != 0", raw_histogram->total_count == 0); mu_assert("Total corrected count != 0", cor_histogram->total_count == 0); mu_assert("Value at 99% not 0.0", hdr_value_at_percentile(raw_histogram, 99.0) == 0); mu_assert("Value at 99% not 0.0", hdr_value_at_percentile(cor_histogram, 99.0) == 0); return 0; }
ERL_NIF_TERM _hh_reset(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { hh_ctx_t* ctx = NULL; ErlNifResourceType* ctx_type = get_hh_ctx_type(env); if (ctx_type != NULL && !enif_get_resource(env, argv[0], ctx_type, (void **)&ctx)) { return enif_make_badarg(env); } if (ctx != NULL && ctx->data != NULL) { hdr_reset(ctx->data); return ATOM_OK; } return make_error(env, "bad_hdr_histogram_nif_impl"); }
int main ( int argc, char *argv[] ) { unsigned long int microdelta, interval_length, interval_diff, sample_desired_wait_time; int nfds,return_value, delay_microseconds, run_seconds, total_runtime_seconds; int fd, opt, quit=0; char buffer[128]; char identifier[IDENTIFIER_SIZE]; struct pollfd poll_list[256]; struct itimerspec timeout; struct timespec sample_start_time, sample_end_time, interval_start; struct timeval end; struct hdr_histogram *interval_histogram, *cumulative_histogram; // 10 seconds worth of microseconds if (hdr_alloc(10000000, 3, &interval_histogram) == -1) { printf("unable to allocate interval histogram\n"); exit (1); } if (hdr_alloc(10000000, 3, &cumulative_histogram) == -1) { printf("unable to allocate cumulative histogram\n"); exit (1); } memset (buffer, 0, 128); memset (identifier, 0, IDENTIFIER_SIZE); // Timing and names // // interval_length - this is the length of time between successive histogram line printouts // // sample_desired_wait_time - this is the amount of time we set the timer to wait for. This should be // less than the jitter we're attempting to measure. Given the nature of this // program, this should always be less than 1 second. If it is not, you'll need to // modify the code below where we set the interval timer. // sample_start_time, // sample_end_time - The times associated with a single pass through the timing loop. // // delay_microseconds - An arbitrary amount of time we wait before starting anything. This is useful if // you want to catch something, and there's a warm up period. // For compatibility with jHiccup this is specified on the command line as millis. // // run_seconds - The time we spend running the timing loops. // interval_length = 5; // 5 seconds per reporting interval sample_desired_wait_time = 1000000; // 1 millisecond in nanoseconds. delay_microseconds = 0; run_seconds = 100000000; // forever, or near enough - 3 years. while ( (opt = getopt(argc, argv, "d:l:r:vh")) != -1) { switch (opt) { case 'd': delay_microseconds = atoi(optarg) * 1000; break; case 'l': strncpy(identifier, optarg, IDENTIFIER_SIZE-1); break; case 'r': run_seconds = atoi(optarg); break; case 'v': verbose_flag = 1; break; case 'h': default: usage(); exit(-1); } } total_runtime_seconds = run_seconds + (delay_microseconds/1000000); open_files(identifier); if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC)) < 0) { perror("timerfd_create; failed to create timer"); return -1; } zero_timeout(&timeout); interval_length = interval_length * 1000000000; // convert to nanoseconds // set up the poll list structure. memset (&poll_list, 0, (256*sizeof(struct pollfd))); poll_list[0].fd=fd; poll_list[0].events=POLLIN|POLLPRI|POLLRDHUP; poll_list[0].revents=0; nfds = 1; // get wall clock start time and push out a header gettimeofday(&start,NULL); print_header_line(log_file, &start); if (verbose_flag) print_header_line(stdout, &start); // we wait a set number of seconds before starting the test. usleep(delay_microseconds); // get start of our delta interval measurement clock_gettime(CLOCK_MONOTONIC, &interval_start); while (!quit) { timeout.it_value.tv_sec = 0; timeout.it_value.tv_nsec = sample_desired_wait_time; // We arm the timer first (timerfd_settime), then get the time as quickly as possible. // We don't want to measure the time that timerfd_settime takes, so its a choice between // under or over reporting the time, as clock_gettime is expected to be fast. timerfd_settime(fd, 0, &timeout, NULL); clock_gettime(CLOCK_MONOTONIC,&sample_start_time); return_value = poll(poll_list,nfds,-1); clock_gettime(CLOCK_MONOTONIC,&sample_end_time); // the the error value is anything other than EINTR we have a real problem. if ((return_value < 0) && (errno != EINTR)) { perror("poll problem"); exit(-1); } // read the timer to clear the event. read(fd,buffer,8); // record the delta for both the interval and cumulative histograms. microdelta = nano_difftime(sample_start_time, sample_end_time)/1000; hdr_record_value(interval_histogram, microdelta); hdr_record_value(cumulative_histogram, microdelta); // See if we're due to print out an interval update. interval_diff = nano_difftime(interval_start, sample_end_time); if (interval_diff >= interval_length) { // print progress print_histogram_line(log_file, interval_histogram, cumulative_histogram); if (verbose_flag) print_histogram_line(stdout, interval_histogram, cumulative_histogram); print_full_histogram(histogram_file,cumulative_histogram); // are we done? gettimeofday(&end, NULL); if (end.tv_sec >= (start.tv_sec + total_runtime_seconds)) quit++; // reset the interval histogram. hdr_reset(interval_histogram); // reset the interval start timer. clock_gettime(CLOCK_MONOTONIC, &interval_start); } } close(fd); exit (0); }
int main(int argc, char** argv) { struct timespec timestamp; struct timespec start_timestamp; struct timespec end_timestamp; struct hdr_interval_recorder recorder; struct hdr_log_writer log_writer; struct config_t config; pthread_t recording_thread; FILE* output = stdout; memset(&config, 0, sizeof(struct config_t)); if (!handle_opts(argc, argv, &config)) { printf("%s", USAGE); return 0; } if (config.filename) { output = fopen(config.filename, "a+"); if (!output) { fprintf( stderr, "Failed to open/create file: %s, %s", config.filename, strerror(errno)); return -1; } } if (0 != hdr_interval_recorder_init(&recorder)) { fprintf(stderr, "%s\n", "Failed to init phaser"); return -1; } if (0 != hdr_init( 1, INT64_C(24) * 60 * 60 * 1000000, 3, (struct hdr_histogram**) &recorder.active)) { fprintf(stderr, "%s\n", "Failed to init hdr_histogram"); return -1; } if (0 != hdr_init( 1, INT64_C(24) * 60 * 60 * 1000000, 3, (struct hdr_histogram**) &recorder.inactive)) { fprintf(stderr, "%s\n", "Failed to init hdr_histogram"); return -1; } if (pthread_create(&recording_thread, NULL, record_hiccups, &recorder)) { fprintf(stderr, "%s\n", "Failed to create thread"); return -1; } hdr_gettime(&start_timestamp); hdr_log_writer_init(&log_writer); hdr_log_write_header(&log_writer, output, "foobar", ×tamp); #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wmissing-noreturn" while (true) { sleep(config.interval); hdr_reset(recorder.inactive); struct hdr_histogram* h = hdr_interval_recorder_sample(&recorder); hdr_gettime(&end_timestamp); timestamp = start_timestamp; hdr_gettime(&start_timestamp); hdr_log_write(&log_writer, output, ×tamp, &end_timestamp, h); fflush(output); } #pragma clang diagnostic pop pthread_exit(NULL); }