/*
* 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();
}
