/* * Stop timing. */ double stop(struct timeinfo *begin, struct timeinfo *end) { double elapsed = 0.0; struct timeinfo stop_ti; if (end == NULL) { get_time(&stop_ti); elapsed = get_elapsed(begin, &stop_ti); } else { get_time(end); elapsed = get_elapsed(begin, end); } return elapsed; }
static void hello_version_exit(void) { printk(KERN_ALERT "Goodbye, %s.\n", qui); printk(KERN_ALERT "This module has been loaded for %d seconds.\n", get_elapsed()); remove_proc_entry("hello_version_elapsed", NULL); }
void show_perf_mr(int tsize, int iters, struct timespec *start, struct timespec *end, int xfers_per_iter, int argc, char *argv[]) { static int header = 1; int64_t elapsed = get_elapsed(start, end, MICRO); long long total = (long long) iters * tsize * xfers_per_iter; int i; float usec_per_xfer; if (header) { printf("---\n"); for (i = 0; i < argc; ++i) printf("%s ", argv[i]); printf(":\n"); header = 0; } usec_per_xfer = ((float)elapsed / iters / xfers_per_iter); printf("- { "); printf("xfer_size: %d, ", tsize); printf("iterations: %d, ", iters); printf("total: %lld, ", total); printf("time: %f, ", elapsed / 1000000.0); printf("MB/sec: %f, ", (total) / (1.0 * elapsed)); printf("usec/xfer: %f", usec_per_xfer); printf("Mxfers/sec: %f", 1.0/usec_per_xfer); printf(" }\n"); }
static pj_highprec_t elapsed_usec( const pj_timestamp *start, const pj_timestamp *stop ) { pj_timestamp ts_freq; pj_highprec_t freq, elapsed; if (pj_get_timestamp_freq(&ts_freq) != PJ_SUCCESS) return 0; /* Convert frequency timestamp */ #if defined(PJ_HAS_INT64) && PJ_HAS_INT64!=0 freq = u64tohighprec(ts_freq.u64); #else freq = ts_freq.u32.hi; pj_highprec_mul(freq, U32MAX); freq += ts_freq.u32.lo; #endif /* Avoid division by zero. */ if (freq == 0) freq = 1; /* Get elapsed time in cycles. */ elapsed = get_elapsed(start, stop); /* usec = elapsed * USEC / freq */ pj_highprec_mul(elapsed, USEC); pj_highprec_div(elapsed, freq); return elapsed; }
static int sread_event(int timeout, uint64_t flags) { struct fi_eq_entry entry; int64_t elapsed; uint32_t event; int ret; ft_start(); ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), timeout, flags); if (ret != sizeof(entry)) { sprintf(err_buf, "fi_eq_sread returned %d, %s", ret, fi_strerror(-ret)); return ret; } /* check timeout accuracy */ ft_stop(); elapsed = get_elapsed(&start, &end, MILLI); if (elapsed > (int) (timeout * 1.25)) { sprintf(err_buf, "fi_eq_sread slept %d ms, expected %d", (int) elapsed, timeout); return -FI_EOTHER; } return FI_SUCCESS; }
void show_perf(char *name, int tsize, int iters, struct timespec *start, struct timespec *end, int xfers_per_iter) { static int header = 1; char str[FT_STR_LEN]; int64_t elapsed = get_elapsed(start, end, MICRO); long long bytes = (long long) iters * tsize * xfers_per_iter; if (header) { printf("%-10s%-8s%-8s%-8s%8s %10s%13s\n", "name", "bytes", "iters", "total", "time", "Gb/sec", "usec/xfer"); header = 0; } printf("%-10s", name); printf("%-8s", size_str(str, tsize)); printf("%-8s", cnt_str(str, iters)); printf("%-8s", size_str(str, bytes)); printf("%8.2fs%10.2f%11.2f\n", elapsed / 1000000.0, (bytes * 8) / (1000.0 * elapsed), ((float)elapsed / iters / xfers_per_iter)); }
/// /// Compares the elapsed time with the specified number of seconds. The /// method returns a negative value if the elapsed time is lesser. /// /// \return Negative, positive, or zero. /// int compare( const double seconds) ///< The elapsed seconds to compare. const { const auto lhs = get_elapsed(); const auto rhs = seconds; return lhs < rhs ? -1 : rhs < lhs ? +1 : 0; }
void access_bank(uint64_t gpu_mask, int shift, uint64_t iter){ int oft = 0; if(gpu_mask > 0){ g_mem_size += gpu_mask; oft += gpu_mask / 4; } if(shift >= 0){ g_mem_size += (uint64_t)1 << shift; oft += ((uint64_t)1 << shift) / 4; } g_mem_size += farest_dist; g_mem_size = CEIL(g_mem_size, min_interval); /* alloc memory. align to a page boundary */ int fd = open("/dev/mem", O_RDWR | O_SYNC); void *addr = (void *) 0x1000000080000000; int *memchunk = NULL; if (fd < 0) { perror("Open failed"); exit(1); } memchunk = mmap(0, g_mem_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)addr); if (memchunk == MAP_FAILED) { perror("failed to alloc"); exit(1); } list = &memchunk[oft]; next = 0; struct timespec start, end; clock_gettime(CLOCK_REALTIME, &start); /* access banks */ uint64_t naccess = run(iter); clock_gettime(CLOCK_REALTIME, &end); uint64_t nsdiff = get_elapsed(&start, &end); //printf("bandwidth %.2f MB/s\n", 64.0*1000.0*(double)naccess/(double)nsdiff); if(shift >= 0) bandwidth[shift] = 64.0 * 1000.0 * (double)naccess/(double)nsdiff; else bandwidth[MAX_SHIFT_NUM - 1] = 64.0 * 1000.0 * (double)naccess/(double)nsdiff; munmap(memchunk, g_mem_size); close(fd); }
int main(int argc, char** argv) { // Initialize the MPI environment MPI_Init(NULL, NULL); // Get the number of processes int world_size; MPI_Comm_size(MPI_COMM_WORLD, &world_size); // Get the rank of the process int world_rank; MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); // Get the name of the processor char processor_name[MPI_MAX_PROCESSOR_NAME]; int name_len; MPI_Get_processor_name(processor_name, &name_len); if (world_rank==0) { printf("Hello from cpu 0\n"); long elapsed[world_size]; elapsed[0]=0; for (int k=1; k<world_size; k++) { MPI_Recv(&elapsed[k],1,MPI_LONG,k,k,MPI_COMM_WORLD,MPI_STATUS_IGNORE); printf("Elapsed time for cpu %d: %lu microseconds\n",k,elapsed[k]); } long sum=0; long sumsqr=0; for (int k=1; k<world_size; k++) { sum+=elapsed[k]; sumsqr+=elapsed[k]*elapsed[k]; } FILE *outf=fopen("output.txt","w"); fprintf(outf,"avg = %g\n",(double)sum/(world_size-1)); if (world_size>0) { double stdev=sqrt((double)sumsqr-sum*sum/(world_size-1))/world_size; fprintf(outf,"stdev = %g\n",stdev); fprintf(outf,"CV = %g%%\n",stdev/(sum/(world_size-1))*100); } for (int k=1; k<world_size; k++) { fprintf(outf,"%lu\n",elapsed[k]); } fclose(outf); } else { printf("Hello from cpu %d\n",world_rank); int k=world_rank; long elapsed=get_elapsed(); MPI_Send(&elapsed,1,MPI_LONG,0,k,MPI_COMM_WORLD); } // Finalize the MPI environment. MPI_Finalize(); }
static int cq_signal() { struct fid_cq *cq; struct fi_cq_tagged_entry entry; int64_t elapsed; int testret; int ret; testret = FAIL; ret = create_cq(&cq, 1, 0, FI_CQ_FORMAT_UNSPEC, FI_WAIT_UNSPEC); if (ret) { sprintf(err_buf, "fi_cq_open(1, 0, FI_CQ_FORMAT_UNSPEC, " "FI_WAIT_UNSPEC) = %d, %s", ret, fi_strerror(-ret)); goto fail1; } ret = fi_cq_signal(cq); if (ret) { sprintf(err_buf, "fi_cq_signal = %d %s", ret, fi_strerror(-ret)); goto fail2; } ft_start(); ret = fi_cq_sread(cq, &entry, 1, NULL, 2000); ft_stop(); elapsed = get_elapsed(&start, &end, MILLI); if (ret != -FI_EAGAIN && ret != -FI_ECANCELED) { sprintf(err_buf, "fi_cq_sread = %d %s", ret, fi_strerror(-ret)); goto fail2; } if (elapsed > 1000) { sprintf(err_buf, "fi_cq_sread - signal ignored"); goto fail2; } ret = fi_close(&cq->fid); if (ret) { sprintf(err_buf, "close(cq) = %d, %s", ret, fi_strerror(-ret)); goto fail1; } cq = NULL; testret = PASS; fail2: FT_CLOSE_FID(cq); fail1: cq = NULL; return TEST_RET_VAL(ret, testret); }
void InitIMU(void) { struct timespec start, end;double interval_sec = (double)1/20; VN_ERROR_CODE errorCode; clock_gettime(CLOCK_REALTIME, &start); errorCode = vn200_connect(&vn200, COM_PORT, VN_BAUDRATE); clock_gettime(CLOCK_REALTIME, &end); uint64_t tmpdiff; double remain_us; tmpdiff = get_elapsed(&start, &end); remain_us = (interval_sec * 1000000 - tmpdiff / 1000); printf("\nVectornav initialization took %llu us\n", tmpdiff/1000); /* Make sure the user has permission to use the COM port. */ if (errorCode == VNERR_PERMISSION_DENIED) { printf("Current user does not have permission to open the COM port.\n"); printf("Try running again using 'sudo'.\n"); } else if (errorCode != VNERR_NO_ERROR) { printf("%d Error encountered when trying to connect to the sensor.\n",errorCode); } printf("%d\n",errorCode); }
static int ft_comp_x(struct fid_cq *cq, struct ft_xcontrol *ft_x, const char *x_str, int timeout) { uint8_t buf[FT_COMP_BUF_SIZE]; struct timespec s, e; int poll_time = 0; int ret; switch(test_info.cq_wait_obj) { case FI_WAIT_NONE: do { if (!poll_time) clock_gettime(CLOCK_MONOTONIC, &s); ft_cq_read(fi_cq_read, cq, buf, comp_entry_cnt[ft_x->cq_format], ft_x->credits, x_str, ret); clock_gettime(CLOCK_MONOTONIC, &e); poll_time = get_elapsed(&s, &e, MILLI); } while (ret == -FI_EAGAIN && poll_time < timeout); break; case FI_WAIT_UNSPEC: case FI_WAIT_FD: case FI_WAIT_MUTEX_COND: ft_cq_read(fi_cq_sread, cq, buf, comp_entry_cnt[ft_x->cq_format], ft_x->credits, x_str, ret, NULL, timeout); break; case FI_WAIT_SET: FT_ERR("fi_ubertest: Unsupported cq wait object"); return -1; default: FT_ERR("Unknown cq wait object"); return -1; } return (ret == -FI_EAGAIN && timeout) ? ret : 0; }
int main(int argc, char *argv[]) { long iter, repeat = 0; double interval_sec = (double)1/20; struct timespec start, end; int opt; /* * get command line options */ while ((opt = getopt(argc, argv, "i:h")) != -1) { switch (opt) { case 'i': /* iterations */ repeat = strtol(optarg, NULL, 0); PDEBUG("repeat=%ld\n", repeat); break; case 'h': usage(argc, argv); break; } } /* Initialize model */ EKF_IFS_2_initialize(); /* Initialize hardware */ InitIMU(); /* vectornav */ InitSerial(); /* arduino */ clock_gettime(CLOCK_REALTIME, &start); iter = 0; while (1) { double remain_us; uint64_t tmpdiff; /* Get sensor data */ GetIMUData(&EKF_IFS_2_U); /* Get Arduino Data */ GetSerialData(&EKF_IFS_2_U); /* Get moving points Data */ InitMovingWaypoints(&EKF_IFS_2_U); /* Get waypoints Data */ InitStaticWaypoints(&EKF_IFS_2_U); /* Get Servo deflection Data */ InitOther(&EKF_IFS_2_U); /* Step the model */ EKF_IFS_2_step(); /* Output to the motor controller */ SendSerialData(&EKF_IFS_2_Y); /* Time book keeping */ clock_gettime(CLOCK_REALTIME, &end); tmpdiff = get_elapsed(&start, &end); remain_us = (interval_sec * 1000000 - tmpdiff / 1000); if (remain_us > 0) { usleep((useconds_t)remain_us); } clock_gettime(CLOCK_REALTIME, &start); iter++; PDEBUG("iter %ld took %" PRIu64 "us\n", iter, tmpdiff/1000); PDEBUG("Out: throttle=%f elevator=%f aileron=%f rudder=%f\n", EKF_IFS_2_Y.ControlSurfaceCommands.throttle_cmd, EKF_IFS_2_Y.ControlSurfaceCommands.elevator_cmd, EKF_IFS_2_Y.ControlSurfaceCommands.aileron_cmd, EKF_IFS_2_Y.ControlSurfaceCommands.rudder_cmd); if (iter >= repeat) break; } /* Matfile logging */ rt_StopDataLogging(MATFILE, EKF_IFS_2_M->rtwLogInfo); /* Terminate model */ EKF_IFS_2_terminate(); /* Close hardware */ CloseIMU(); CloseSerial(); return 0; }
int main(int argc, char ** argv) { static msg_block_t msg; memset((void *)&msg, 0, sizeof(msg)); struct timespec time; double time0, time1; uint32_t notes[SCALE_PATTERN][NOTES_SIZE]; uint32_t scales[SCALE_PATTERN][SCALE_SIZE] = { {0,4,7,9,}, {0,5,7,9,}, {2,4,7,11,}, {2,5,7,9,}, {2,5,7,11,}, {0,2,4,7,}, {0,2,5,7,}, {0,2,5,9,}, }; uint32_t instruments[] = { 0, 4, 5, 6, 8, 9, 11, 14, 15, 16, 17, 19, 24, 25, 26, 30, 40, 42, 46, 48, 51, 52, 56, 57, 60, 61, 63, 64, 65, 68, 69, 70, 73, 88, 89, 91, 93, 94, 95, 98, 99, 103, 104, 110, }; uint32_t insts = sizeof(instruments) / sizeof(uint32_t); int fb = open(FBDEV, O_RDWR); if (fb > 0) { struct fb_fix_screeninfo fbfsi; struct fb_var_screeninfo fbvsi; if (ioctl(fb, FBIOGET_FSCREENINFO, &fbfsi) == 0) { msg.fbinfo.smem_start = fbfsi.smem_start; msg.fbinfo.smem_len = fbfsi.smem_len; msg.fbinfo.line_length = fbfsi.line_length; } if (ioctl(fb, FBIOGET_VSCREENINFO, &fbvsi) == 0) { msg.fbinfo.xres = fbvsi.xres; msg.fbinfo.yres = fbvsi.yres; msg.fbinfo.xres_virtual = fbvsi.xres_virtual; msg.fbinfo.yres_virtual = fbvsi.yres_virtual; msg.fbinfo.xoffset = fbvsi.xoffset; msg.fbinfo.yoffset = fbvsi.yoffset; msg.fbinfo.bits_per_pixel = fbvsi.bits_per_pixel; } close(fb); } long pagesize = (sysconf(_SC_PAGESIZE)); int fdmem = open(MEMDEV, O_RDWR | O_SYNC); uint32_t *frame_buffer = NULL; size_t mapsize = 0; if ((fdmem > 0) && (msg.fbinfo.smem_start != 0)) { off_t physical_page = msg.fbinfo.smem_start & (~(pagesize - 1)); unsigned long offset = msg.fbinfo.smem_start - (unsigned long)physical_page; mapsize = msg.fbinfo.smem_len + offset; frame_buffer = mmap(NULL, mapsize, PROT_READ | PROT_WRITE, MAP_SHARED, fdmem, physical_page); if (frame_buffer == MAP_FAILED) { perror("Framebuffer Map Failed"); } } struct timespec time_start; clock_gettime(CLOCK_MONOTONIC_RAW, &time_start); srand((uint32_t)time_start.tv_nsec); seq_context_t seq; if (open_sequencer(&seq) == FALSE) { exit(EXIT_FAILURE); } program_change(&seq, 0, 48); control_change(&seq, 0, 91, 127); static rt_context_t rtx; memset((void *)&rtx, 0, sizeof(rtx)); int width = msg.fbinfo.xres_virtual; int height = msg.fbinfo.yres_virtual; rtx.objnum = OBJNUM; rtx.light.pos = vec3_set(-4.0f, 8.0f, 2.0f); rtx.light.col = vec3_set(1.0f, 1.0f, 1.0f); rtx.eye = vec3_set(0.0f, 0.0f, -7.0f); rtx.swidth = 10.0f * (float)width / (float)height; rtx.sheight = 10.0f; rtx.width = width / SCALE; rtx.height = height / SCALE; rtx.xoff = 0; rtx.yoff = 0; rtx.ax = rtx.swidth / (float)rtx.width; rtx.ayc = rtx.sheight / (float)rtx.height; rtx.ay = rtx.sheight / (float)rtx.height; uint32_t i, j; for (i = 0; i < SCALE_PATTERN; i++) { for (j = 0; j < NOTES_SIZE; j++) { notes[i][j] = scales[i][j % SCALE_SIZE] + (j / SCALE_SIZE) * 12; } } for (i = 0; i < rtx.objnum; i++) { rtx.obj[i].type = SPHERE; rtx.obj[i].pos = vec3_set(0.0f, -100.0f, 0.0f); rtx.obj[i].rad = 1.0f; rtx.obj[i].col = vec3_set(randf(), randf(), randf()); rtx.obj[i].flag_shadow = TRUE; rtx.obj[i].flag_refrect = TRUE; rtx.obj[i].spd = vec3_set(0.0f, 0.0f, 0.0f); rtx.obj[i].note = 0; } rtx.obj[0].type = PLANE; rtx.obj[0].norm = normalize(vec3_set(0.0f, 1.0f, 0.0f)); rtx.obj[0].dist = 2.0f; rtx.obj[0].col = vec3_set(0.1f, 0.3f, 0.6f); rtx.obj[0].flag_shadow = TRUE; rtx.obj[0].flag_refrect = TRUE; rtx.obj[0].spd = vec3_set(0.0f, 0.0f, 0.0f); uint32_t scale = 0; uint32_t curobj = 0; float next_note_time = get_elapsed(time_start) + 3.0f; float next_scale_time = get_elapsed(time_start) + 15.0f + randf() * 15.0f; float time_now = get_elapsed(time_start); float time_quit = time_now + 3600.0f; uint32_t retry_count = 0; uint32_t counter = 0; float time_prev = 0.0f; while(time_now < time_quit) { uint32_t e; for (e = 1; e < rtx.objnum; e++) { rtx.obj[e].pos = vec3_add(rtx.obj[e].pos, rtx.obj[e].spd); } time_now = get_elapsed(time_start); if (time_now > next_note_time) { e = (curobj % (rtx.objnum - 1)) + 1; rtx.obj[e].pos = vec3_set(randf()*8.0f-4.0f, randf()*6.0f-1.0f, randf()*8.0+0.0f); rtx.obj[e].col = vec3_set(randf(), randf(), randf()); rtx.obj[e].spd = vec3_set(randf()*0.1f-0.05f,randf()*0.1f-0.05f,randf()*0.1f-0.05f); note_off(&seq, 0, rtx.obj[e].note); rtx.obj[e].note = notes[scale][(uint32_t)(randf() * 17.0f) + 12]; note_on(&seq, 0, rtx.obj[e].note, 127 - rtx.obj[e].note); curobj++; float len = (randf() + 0.5f); next_note_time = time_now + len * len * len; } if (time_now > next_scale_time) { scale = (uint32_t)(randf() * (float)SCALE_PATTERN); program_change(&seq, 0, instruments[(uint32_t)(randf() * ((float)insts + 0.99f))]); rtx.obj[0].col = vec3_set(randf(), randf(), randf()); rtx.light.pos = vec3_set(randf() * 8.0f - 4.0f, 8.0f, randf() * 4.0f); next_scale_time = time_now + (randf() + 0.1f) * 40.0f; } render(&msg, &rtx, frame_buffer); counter++; if (counter > 100) { //printf("FPS: %.2f\n", 100.0f / (time_now - time_prev)); time_prev = time_now; counter = 0; } } close_sequencer(&seq); munmap(frame_buffer, mapsize); close(fdmem); return 0; }
/* * Tests: * - sread with event pending * - sread with no event pending */ static int eq_wait_fd_sread() { struct fi_eq_entry entry; uint32_t event; int64_t elapsed; int testret; int ret; testret = FAIL; ret = create_eq(32, FI_WRITE, FI_WAIT_FD); if (ret != 0) { sprintf(err_buf, "fi_eq_open ret=%d, %s", ret, fi_strerror(-ret)); goto fail; } /* timed sread on empty EQ, 2s timeout */ ft_start(); ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), 2000, 0); if (ret != -FI_EAGAIN) { sprintf(err_buf, "fi_eq_read of empty EQ returned %d", ret); goto fail; } /* check timeout accuracy */ ft_stop(); elapsed = get_elapsed(&start, &end, MILLI); if (elapsed < 1500 || elapsed > 2500) { sprintf(err_buf, "fi_eq_sread slept %d ms, expected 2000", (int)elapsed); goto fail; } /* write an event */ entry.fid = &eq->fid; entry.context = eq; ret = fi_eq_write(eq, FI_NOTIFY, &entry, sizeof(entry), 0); if (ret != sizeof(entry)) { sprintf(err_buf, "fi_eq_write ret=%d, %s", ret, fi_strerror(-ret)); goto fail; } /* timed sread on EQ with event, 2s timeout */ ft_start(); event = ~0; memset(&entry, 0, sizeof(entry)); ret = fi_eq_sread(eq, &event, &entry, sizeof(entry), 2000, 0); if (ret != sizeof(entry)) { sprintf(err_buf, "fi_eq_read ret=%d, %s", ret, fi_strerror(-ret)); goto fail; } /* check that no undue waiting occurred */ ft_stop(); elapsed = get_elapsed(&start, &end, MILLI); if (elapsed > 5) { sprintf(err_buf, "fi_eq_sread slept %d ms, expected immediate return", (int)elapsed); goto fail; } if (event != FI_NOTIFY) { sprintf(err_buf, "fi_eq_sread: event = %d, should be %d\n", event, FI_NOTIFY); goto fail; } if (entry.fid != &eq->fid) { sprintf(err_buf, "fi_eq_sread: fid mismatch: %p should be %p\n", entry.fid, &eq->fid); goto fail; } if (entry.context != eq) { sprintf(err_buf, "fi_eq_sread: context mismatch: %p should be %p\n", entry.context, eq); goto fail; } testret = PASS; fail: FT_CLOSE_FID(eq); return TEST_RET_VAL(ret, testret); }
bool out_of_time(const double &max_duration_in_sec) { if(get_elapsed() >= max_duration_in_sec) { return true; } return false; }
int main(int argc, char** argv) { width = 12, depth = 8, height = 60; xd = (width - 1) / 2.4; yd = (depth - 1) / 1.6; zd = (height - 1) / 2.0; xl = (width - 1) / xd; yl = (depth - 1) / yd; zl = (height - 1) / zd; total_leds = width * depth * height; channel = 0; fps = 60; period_x = xl / (2 * M_PI); speed_x = 1.0 / fps; period_y = yl / (2 * M_PI); speed_y = 0.9 / fps; period_z = zl / (2 * M_PI); speed_z = 0.8 / fps; sphere_r = .3; spheres = sqrt(pow(xl/2, 2) + pow(yl/2, 2) + pow(zl/2, 2)) / sphere_r; spheres += 2; frames_per_layer = fps / 2; pixel l_sphere_colors[spheres]; sphere_colors = l_sphere_colors; int i; for (i = 0; i < spheres; i++) { sphere_colors[i] = randcolor(); } pixel pixels[total_leds + 1]; opc_sink s; if (argc < 2) { fprintf(stderr, "Usage: %s <server>[:<port>]\n", argv[0]); return 1; } s = opc_new_sink(argv[1]); int64_t frame_index = 0; int64_t start = now(); struct fps_queue fpsq; int64_t frames[total_leds]; fpsq.samples = fps; fpsq.pos = 0; fpsq.frames = frames; while (1) { sleep_until(start + 1000000 * frame_index / fps); render_frame(pixels, frame_index); if (!opc_put_pixels(s, channel, total_leds, pixels)) { break; } record_frame(&fpsq); if (fpsq.pos == 0) { double cur_fps = (fpsq.samples - 1) / (get_elapsed(&fpsq) / 1000000.0); printf("fps: %.2f (%.2f Mbps)\n", cur_fps, total_leds * 24 * cur_fps / 1000000.0); } frame_index++; } printf("fps: %f\n", frame_index / 5.0); }
/// /// \return The current time as a string. /// std::string str() const { std::ostringstream out; out << std::fixed << std::setprecision(6) << get_elapsed(); return out.str(); }
int main(int argc, char* argv[]) { struct sched_param param; cpu_set_t cmask; int num_processors; int cpuid = 0; int use_dev_mem = 0; int *memchunk = NULL; int opt, prio; int i,j; uint64_t repeat = 1000; int page_shift = 0; int xor_page_shift = -1; /* * get command line options */ while ((opt = getopt(argc, argv, "a:xb:s:o:m:c:i:l:h")) != -1) { switch (opt) { case 'b': /* bank bit */ page_shift = strtol(optarg, NULL, 0); break; case 's': /* xor-bank bit */ xor_page_shift = strtol(optarg, NULL, 0); break; case 'm': /* set memory size */ g_mem_size = 1024 * strtol(optarg, NULL, 0); break; case 'x': /* mmap to /dev/mem, owise use hugepage */ use_dev_mem = 1; break; case 'c': /* set CPU affinity */ cpuid = strtol(optarg, NULL, 0); num_processors = sysconf(_SC_NPROCESSORS_CONF); CPU_ZERO(&cmask); CPU_SET(cpuid % num_processors, &cmask); if (sched_setaffinity(0, num_processors, &cmask) < 0) perror("error"); break; case 'p': /* set priority */ prio = strtol(optarg, NULL, 0); if (setpriority(PRIO_PROCESS, 0, prio) < 0) perror("error"); break; case 'i': /* iterations */ repeat = (uint64_t)strtol(optarg, NULL, 0); printf("repeat=%lu\n", repeat); break; } } printf("xor_page_shift : %d -------------\n", xor_page_shift); if(xor_page_shift >= 0) g_mem_size += (1 << page_shift) + (1 << xor_page_shift); else g_mem_size += (1 << page_shift); #ifdef RANDOM g_mem_size = CEIL(g_mem_size, ENTRY_DIST_AVG); #else g_mem_size = CEIL(g_mem_size, ENTRY_DIST); #endif /* alloc memory. align to a page boundary */ if (use_dev_mem) { int fd = open("/dev/mem", O_RDWR | O_SYNC); void *addr = (void *) 0x1000000080000000; if (fd < 0) { perror("Open failed"); exit(1); } memchunk = mmap(0, g_mem_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)addr); } else { memchunk = mmap(0, g_mem_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0); } if (memchunk == MAP_FAILED) { perror("failed to alloc"); exit(1); } int off_idx = (1<<page_shift) / 4; if (xor_page_shift > 0) { off_idx = ((1<<page_shift) + (1<<xor_page_shift)) / 4; } #if 0 /* just test bits smaller than ENTRY_SHIFT */ if (page_shift >= ENTRY_SHIFT || xor_page_shift >= ENTRY_SHIFT) { fprintf(stderr, "page_shift or xor_page_shift must be less than %d bits\n", ENTRY_SHIFT); exit(1); } #endif list = &memchunk[off_idx]; #ifdef RANDOM /* bit RANGE_LEFT~RANGE_RIGHT : xxxxx present 32 entry dist, randomly assign one(choose from 32 dist) for each access, * min entry dist = 2^RANGE_LEFT > 2^18: guarantee same cache set index. */ uint64_t ibit = 0; int mask[NUM_ENTRIES] = {0}; struct timespec seed; uint64_t entry_dist; for(i = 0; i < NUM_ENTRIES; i++){ while(1){ clock_gettime(CLOCK_REALTIME, &seed); ibit = seed.tv_nsec % (1 << (RANGE_RIGHT - RANGE_LEFT + 1)); if(mask[ibit] == 0){ mask[ibit] = 1; break; } } entry_dist = (uint64_t)(ibit << RANGE_LEFT); indices[i] = entry_dist / 4; //printf("%dth entry_dist %lx\n", i, entry_dist); } #else for (i = 0; i < NUM_ENTRIES; i++) { if (i == (NUM_ENTRIES - 1)) indices[i] = 0; else indices[i] = (i + 1) * ENTRY_DIST/4; } #endif next = 0; printf("pshift: %d, XOR-pshift: %d\n", page_shift, xor_page_shift); struct timespec start, end; clock_gettime(CLOCK_REALTIME, &start); /* access banks */ uint64_t naccess = run(repeat); clock_gettime(CLOCK_REALTIME, &end); int64_t nsdiff = get_elapsed(&start, &end); double avglat = (double)nsdiff/naccess; //printf("size: %ld (%ld KB)\n", g_mem_size, g_mem_size/1024); //printf("duration %ld ns, #access %ld\n", nsdiff, naccess); //printf("average latency: %ld ns\n", nsdiff/naccess); printf("bandwidth %.2f MB/s\n", 64.0*1000.0*(double)naccess/(double)nsdiff); return 0; }
int main(int argc, char* argv[]) { struct item *list; int workingset_size = 1024; int i, j; struct list_head head; struct list_head *pos; struct timespec start, end; uint64_t nsdiff; double avglat; uint64_t readsum = 0; int serial = 0; int repeat = 10; int cpuid = 0; struct sched_param param; cpu_set_t cmask; int num_processors; int opt, prio; /* * get command line options */ while ((opt = getopt(argc, argv, "m:sc:i:p:h")) != -1) { switch (opt) { case 'm': /* set memory size */ g_mem_size = 1024 * strtol(optarg, NULL, 0); break; case 's': /* set access type */ serial = 1; break; case 'c': /* set CPU affinity */ cpuid = strtol(optarg, NULL, 0); num_processors = sysconf(_SC_NPROCESSORS_CONF); CPU_ZERO(&cmask); CPU_SET(cpuid % num_processors, &cmask); if (sched_setaffinity(0, num_processors, &cmask) < 0) perror("error"); else fprintf(stderr, "assigned to cpu %d\n", cpuid); break; case 'p': /* set priority */ prio = strtol(optarg, NULL, 0); if (setpriority(PRIO_PROCESS, 0, prio) < 0) perror("error"); else fprintf(stderr, "assigned priority %d\n", prio); break; case 'i': /* iterations */ repeat = strtol(optarg, NULL, 0); fprintf(stderr, "repeat=%d\n", repeat); break; case 'h': usage(argc, argv); break; } } workingset_size = g_mem_size / CACHE_LINE_SIZE; srand(0); #if 0 param.sched_priority = 1; /* 1(low) - 99(high) for SCHED_FIFO or SCHED_RR 0 for SCHED_OTHER or SCHED_BATCH */ if(sched_setscheduler(0, SCHED_FIFO, ¶m) == -1) { perror("sched_setscheduler failed"); } #endif INIT_LIST_HEAD(&head); /* allocate */ list = (struct item *)malloc(sizeof(struct item) * workingset_size + CACHE_LINE_SIZE); for (i = 0; i < workingset_size; i++) { list[i].data = i; list[i].in_use = 0; INIT_LIST_HEAD(&list[i].list); // printf("%d 0x%x\n", list[i].data, &list[i].data); } printf("allocated: wokingsetsize=%d entries\n", workingset_size); /* initialize */ int *perm = (int *)malloc(workingset_size * sizeof(int)); for (i = 0; i < workingset_size; i++) perm[i] = i; if (!serial) { for (i = 0; i < workingset_size; i++) { int tmp = perm[i]; int next = rand() % workingset_size; perm[i] = perm[next]; perm[next] = tmp; } } for (i = 0; i < workingset_size; i++) { list_add(&list[perm[i]].list, &head); // printf("%d\n", perm[i]); } fprintf(stderr, "initialized\n"); /* actual access */ clock_gettime(CLOCK_REALTIME, &start); for (j = 0; j < repeat; j++) { pos = (&head)->next; for (i = 0; i < workingset_size; i++) { struct item *tmp = list_entry(pos, struct item, list); readsum += tmp->data; pos = pos->next; // printf("%d ", tmp->data, &tmp->data); } } clock_gettime(CLOCK_REALTIME, &end); nsdiff = get_elapsed(&start, &end); avglat = (double)nsdiff/workingset_size/repeat; printf("duration %ld us\naverage %.2f ns | ", nsdiff/1000, avglat); printf("bandwidth %.2f MB (%.2f MiB)/s\n", (double)64*1000/avglat, (double)64*1000000000/avglat/1024/1024); printf("readsum %ld\n", readsum); }
static int read_proc_elapsed(char *buffer, char **start, off_t fpos, int length) { sprintf(buffer, "%d\n", get_elapsed()); return strlen(buffer); }
int main(int argc, char *argv[]) { (void) argc; (void) argv; hash_table ht; ht_init(&ht, HT_KEY_CONST | HT_VALUE_CONST, 0.05); char *s1 = (char*)"teststring 1"; char *s2 = (char*)"teststring 2"; char *s3 = (char*)"teststring 3"; ht_insert(&ht, s1, strlen(s1)+1, s2, strlen(s2)+1); int contains = ht_contains(&ht, s1, strlen(s1)+1); test(contains, "Checking for key \"%s\"", s1); size_t value_size; char *got = ht_get(&ht, s1, strlen(s1)+1, &value_size); fprintf(stderr, "Value size: %zu\n", value_size); fprintf(stderr, "Got: {\"%s\": -----\"%s\"}\n", s1, got); test(value_size == strlen(s2)+1, "Value size was %zu (desired %lu)", value_size, strlen(s2)+1); fprintf(stderr, "Replacing {\"%s\": \"%s\"} with {\"%s\": \"%s\"}\n", s1, s2, s1, s3); ht_insert(&ht, s1, strlen(s1)+1, s3, strlen(s3)+1); unsigned int num_keys; void **keys; keys = ht_keys(&ht, &num_keys); test(num_keys == 1, "HashTable has %d keys", num_keys); test(keys != NULL, "Keys is not null"); if(keys) free(keys); got = ht_get(&ht, s1, strlen(s1)+1, &value_size); fprintf(stderr, "Value size: %zu\n", value_size); fprintf(stderr, "Got: {\"%s\": \"%s\"}\n", s1, got); test(value_size == strlen(s3)+1, "Value size was %zu (desired %lu)", value_size, strlen(s3)+1); fprintf(stderr, "Removing entry with key \"%s\"\n", s1); ht_remove(&ht, s1, strlen(s1)+1); contains = ht_contains(&ht, s1, strlen(s1)+1); test(!contains, "Checking for removal of key \"%s\"", s1); keys = ht_keys(&ht, &num_keys); test(num_keys == 0, "HashTable has %d keys", num_keys); if(keys) free(keys); fprintf(stderr, "Stress test"); int key_count = 1000000; int i; int *many_keys = malloc(key_count * sizeof(*many_keys)); int *many_values = malloc(key_count * sizeof(*many_values)); srand(time(NULL)); for(i = 0; i < key_count; i++) { many_keys[i] = i; many_values[i] = rand(); } struct timespec t1; struct timespec t2; t1 = snap_time(); for(i = 0; i < key_count; i++) { ht_insert(&ht, &(many_keys[i]), sizeof(many_keys[i]), &(many_values[i]), sizeof(many_values[i])); } t2 = snap_time(); fprintf(stderr, "Inserting %d keys took %.2f seconds\n", key_count, get_elapsed(t1, t2)); fprintf(stderr, "Checking inserted keys\n"); int ok_flag = 1; for(i = 0; i < key_count; i++) { if(ht_contains(&ht, &(many_keys[i]), sizeof(many_keys[i]))) { size_t value_size; int value; value = *(int*)ht_get(&ht, &(many_keys[i]), sizeof(many_keys[i]), &value_size); if(value != many_values[i]) { fprintf(stderr, "Key value mismatch. Got {%d: %d} expected: {%d: %d}\n", many_keys[i], value, many_keys[i], many_values[i]); ok_flag = 0; break; } } else { fprintf(stderr, "Missing key-value pair {%d: %d}\n", many_keys[i], many_values[i]); ok_flag = 0; break; } } test(ok_flag == 1, "Result was %d", ok_flag); ht_clear(&ht); ht_resize(&ht, 4194304); t1 = snap_time(); for(i = 0; i < key_count; i++) { ht_insert(&ht, &(many_keys[i]), sizeof(many_keys[i]), &(many_values[i]), sizeof(many_values[i])); } t2 = snap_time(); fprintf(stderr, "Inserting %d keys (on preallocated table) took %.2f seconds\n", key_count, get_elapsed(t1, t2)); for(i = 0; i < key_count; i++) { ht_remove(&ht, &(many_keys[i]), sizeof(many_keys[i])); } test(ht_size(&ht) == 0, "%d keys remaining", ht_size(&ht)); ht_destroy(&ht); free(many_keys); free(many_values); return report_results(); }