void tui::StatusLine::draw() { glColor4f((GLfloat)1,(GLfloat)1,(GLfloat)1,(GLfloat)0.7); glEnable(GL_POLYGON_SMOOTH); //- for solid fill glDisable(GL_POLYGON_STIPPLE); //- for solid fill glRecti(_sb_TR.x(), _sb_TR.y(), _sb_BL.x(), _sb_BL.y()); glColor4f(0,0,0,1); glPushMatrix(); glTranslatef(_cY.x(), _cY.y(), 0); glScalef(_scaledpix, _scaledpix, 1); glfDrawSolidString("Y:"); glPopMatrix(); glPushMatrix(); glTranslatef(_cX.x(), _cX.y(), 0); glScalef(_scaledpix, _scaledpix, 1); glfDrawSolidString("X:"); glPopMatrix(); glPushMatrix(); glTranslatef(_dY.x(), _dY.y(), 0); glScalef(_scaledpix, _scaledpix, 1); glfDrawSolidString("dX:"); glPopMatrix(); glPushMatrix(); glTranslatef(_dX.x(), _dX.y(), 0); glScalef(_scaledpix, _scaledpix, 1); glfDrawSolidString("dX:"); glPopMatrix(); update_coords(_cp); }
// Main from original file copied to best tested multiple times double testmain(uint_fast32_t N, uint_fast32_t M) { uint_fast32_t object_size = N; uint_fast32_t iters = M; srand(object_size); double* x = generate_random_list(object_size, 1000); double* y = generate_random_list(object_size, 1000); double* z = generate_random_list(object_size, 1000); double* vx = generate_random_list(object_size, 1); double* vy = generate_random_list(object_size, 1); double* vz = generate_random_list(object_size, 1); struct timespec requestStart, requestEnd; clock_gettime(CLOCK_MONOTONIC, &requestStart); for (uint_fast32_t i=0; i < iters; i++) { for (uint_fast32_t j=0; j < object_size; j++) { update_coords(j,x,y,z,vx,vy,vz); } } clock_gettime(CLOCK_MONOTONIC, &requestEnd); double timeTaken = (requestEnd.tv_sec + (requestEnd.tv_nsec / 1000000000.)) - (requestStart.tv_sec + (requestStart.tv_nsec / 1000000000.)); free(x); free(y); free(z); free(vx); free(vy); free(vz); return(((1000000. * timeTaken) / (object_size * iters))); }
int main(int argc, char *argv[]){ const double bound = 1000.0; const double v_bound = 1.0; if (argc != 3){ printf("Required arguments: vector_length(N) and iterations_num(M)"); exit(EXIT_FAILURE); } // get command line args uint32_t size = (uint32_t)atoi(argv[1]); uint32_t iters = (uint32_t)atoi(argv[2]); // set seed srand(size); // initialize points double *x = generate_random_list(size, bound); double *y = generate_random_list(size, bound); double *z = generate_random_list(size, bound); // initialize velocities double *vx = generate_random_list(size, v_bound); double *vy = generate_random_list(size, v_bound); double *vz = generate_random_list(size, v_bound); // time while we update coodinates iters number of times struct timespec start, end; clock_gettime(&start); for(uint32_t i = 0; i < iters; i++){ update_coords(size, x, y, z, vx, vy, vz); } clock_gettime(&end); //compute the checksum double chksum = 0; for (uint32_t i = 0; i < size; i++){ chksum += *(x + i) + *(y + i) + *(z + i); //printf("x: %f y: %f z: %f, vx: %f vy: %f vz: %f checksum: %f iters: %u\n", *(x + i), *(y + i), *(z + i), *(vx + i), *(vy + i), *(vz + i), chksum, iters); } free(x); free(y); free(z); free(vx); free(vy); free(vz); // output //convert nanoseconds to microseconds //convert seconds to microseconds double micro_sec = SEC_TO_MICRO * (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / NANO_TO_MICRO; double mean_time = micro_sec/(size * iters); printf("Mean time per coordinate: %f us\n", mean_time); printf("Final checksum is: %f", chksum); exit(EXIT_SUCCESS); }
void vnode_impl::doRPC_cb (ptr<location> l, xdrproc_t proc, void *out, aclnt_cb cb, ref<dorpc_res> res, clnt_stat err) { if (err) { ptr<location> reall = locations->lookup (l->id ()); if (reall && reall->alive ()) { warn << "got error " << err << ", but " << l << " is still marked alive\n"; reall->set_alive (false); } else if (!reall) { locations->insert (l); l->set_alive (false); } if (!l->alive () && checkdead_int > 0) { // benjie: no longer alive, put it on the dead_nodes list so // we can try to contact it periodically unsigned i=0; for (i=0; i<dead_nodes.size (); i++) if (dead_nodes[i]->id () == l->id ()) break; if (i == dead_nodes.size ()) { dead_nodes.push_back (l); delaycb (checkdead_int, wrap (this, &vnode_impl::check_dead_node, l, checkdead_int)); } } cb (err); } else if (res->status != DORPC_OK) cb (RPC_CANTRECV); else { float distance = l->distance (); chord_node n = make_chord_node (res->resok->src); l->set_coords (n); Coord u_coords (n); update_coords (u_coords, distance); // This should reset the age of the node to zero because // remote side always provides an age of zero for self // and locationtable will pull in updates that are younger. if (me_->id () != n.x) locations->insert (n); //unmarshall the result and copy to out xdrmem x ((char *)res->resok->results.base (), res->resok->results.size (), XDR_DECODE); assert (proc); if (!proc (x.xdrp (), out)) { fatal << "failed to unmarshall result\n"; cb (RPC_CANTSEND); } else cb (err); } }
// Main: int main(int argc, char* argv[]) { if (argc != 3) { printf("Required arguments: vector_length(N) and iterations_num(M)\n"); exit(-1); } uint_fast32_t object_size = atoi(argv[1]); uint_fast32_t iters = atoi(argv[2]); srand(object_size); float* x = generate_random_list(object_size, 1000); float* y = generate_random_list(object_size, 1000); float* z = generate_random_list(object_size, 1000); float* vx = generate_random_list(object_size, 1); float* vy = generate_random_list(object_size, 1); float* vz = generate_random_list(object_size, 1); struct timespec requestStart, requestEnd; clock_gettime(CLOCK_MONOTONIC, &requestStart); for (uint_fast32_t i=0; i < iters; i++) { for (uint_fast32_t j=0; j < object_size; j++) { update_coords(j,x,y,z,vx,vy,vz); } } clock_gettime(CLOCK_MONOTONIC, &requestEnd); float chksum = (float)sum(x,object_size) + (float)sum(y,object_size) + (float)sum(z,object_size); float timeTaken = (requestEnd.tv_sec + (requestEnd.tv_nsec / 1000000000.)) - (requestStart.tv_sec + (requestStart.tv_nsec / 1000000000.)); printf(" (1000000 * %f) / (%lu * %lu))\n",timeTaken,object_size,iters); printf("Mean time per coordinate: %f us\n", ((1000000. * timeTaken) / (object_size * iters))); printf("Final checksum is: %f\n", chksum); _mm_free(x); _mm_free(y); _mm_free(z); _mm_free(vx); _mm_free(vy); _mm_free(vz); return(0); }
int main(int argc, char** argv){ if(argc < 3){ printf("args: <size> <iters>\n"); return -1; } uint64_t size = 1 << atoi(argv[1]); uint64_t iters = 1 << atoi(argv[2]); srand(size); float* x = generate_random_list(size,1000.); float* y = generate_random_list(size,1000.); float* z = generate_random_list(size,1.); float* vx = generate_random_list(size,1.); float* vy = generate_random_list(size,1.); float* vz = generate_random_list(size,1.); struct timespec start,end; clock_gettime(CLOCK_MONOTONIC, &start); for (uint64_t i=0; i < iters; i++) update_coords(size,x,y,z,vx,vy,vz); clock_gettime(CLOCK_MONOTONIC, &end); float elapsed = (end.tv_sec * BILLION + end.tv_nsec) - (start.tv_sec * BILLION + start.tv_nsec); float avg = elapsed/(size * iters); int checksum = 0; for (uint64_t i=0; i<size; i++){ checksum += x[i] + y[i] + z[i]; } fileout = fopen(outputFilename, "a"); fprintf(fileout, "%f\n",avg); fclose(fileout); printf("checksum is %d\n",checksum); printf("Average Elapsed Time: %fns\n",avg); return 0; }
static void draw_drive(lemuria_engine_t * e, void * user_data) { int index_1; int index_2; int i; float delta_phi; float angle; float speed; float speed_norm; drive_data * d = (drive_data*)(user_data); lemuria_range_update(&(d->curvature_range)); lemuria_range_update(&(d->speed_range)); /* Change stuff */ lemuria_range_get(&(d->speed_range), &(d->speed_start), &(d->speed_end), &speed); speed_norm = speed / SPEED_MAX; // fprintf(stderr, "Speed: %f speed_max: %f (Speed/speed_max)^2: %f\n", // speed, SPEED_MAX, speed_norm * speed_norm); // fprintf(stderr, "Speed: %f %f\n", speed, SPEED_MAX); if(e->quiet) { d->speed_start = speed; d->speed_end = SPEED_MIN; lemuria_range_init(e, &(d->speed_range), 1, 100, 200); } else if(e->beat_detected) { if(lemuria_range_done(&(d->speed_range)) && lemuria_decide(e, 0.2)) { d->speed_start = d->speed_end; d->speed_end = SPEED_MIN + (lemuria_random(e, 0.0, 0.5) + 0.5 * (float)e->loudness/32768.0)*(SPEED_MAX - SPEED_MIN); lemuria_range_init(e, &(d->speed_range), 1, 100, 200); } if(lemuria_range_done(&(d->curvature_range)) && lemuria_decide(e, 0.2)) { d->delta_phi_start = d->delta_phi_end; // if(d->delta_phi_end > 0.0) if(lemuria_decide(e, 0.3)) d->delta_phi_end = 0.0; else { // d->delta_phi_end = lemuria_random(DELTA_PHI_MIN, DELTA_PHI_MAX); d->delta_phi_end = DELTA_PHI_MIN + (lemuria_random(e, 0.0, 0.5) + 0.5 * (float)e->loudness / 32768.0)*(DELTA_PHI_MAX - DELTA_PHI_MIN); if(lemuria_decide(e, 0.5)) d->delta_phi_end *= -1.0; } // fprintf(stderr, "New phi: %f\n", d->delta_phi_end * 180.0 / M_PI); lemuria_range_init(e, &(d->curvature_range), 2, 50, 100); } } /* Create new rings if necessary */ d->z_start += speed; lemuria_range_get(&(d->curvature_range), &(d->delta_phi_start), &(d->delta_phi_end), &delta_phi); if(fabs(delta_phi) < DELTA_PHI_MIN) delta_phi = 0.0; while(d->z_start >= DELTA_Z) { d->segments[d->start_segment].delta_phi = delta_phi; d->texture_y += TEXTURE_DELTA_Y; d->segments[d->start_segment].texture_y_before = d->texture_y; if(d->texture_y > 1.0) d->texture_y -= 1.0; d->segments[d->start_segment].texture_y_after = d->texture_y; d->start_segment++; if(d->start_segment >= NUM_SEGMENTS) d->start_segment = 0; d->z_start -= DELTA_Z; } update_coords(d); /* Set up Opengl */ glClearColor(0.0, 0.0, 0.0, 0.0); // glDisable(GL_DEPTH_TEST); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); lemuria_set_perspective(e, 1, 1000.0); /* Set up light and materials */ #ifndef DRAW_MESH glShadeModel(GL_SMOOTH); #endif glMatrixMode(GL_MODELVIEW); glPushMatrix(); index_1 = d->start_segment; index_2 = index_1 + 1; if(index_2 >= NUM_SEGMENTS) index_2 = 0; /* Do curvature transformation */ angle = atan2(20.0 * (speed_norm * speed_norm) * d->segments[d->start_segment].delta_phi, DELTA_PHI_MAX); /* / (SPEED_MAX * SPEED_MAX) */ d->angle = 0.8 * d->angle + 0.2 * angle; /* */ glTranslatef(0.0, SEGMENT_RADIUS - CAMERA_HEIGHT, 0.0); glRotatef(d->angle * 180.0 / M_PI, 0.0, 0.0, 1.0); glTranslatef(0.0, CAMERA_HEIGHT - SEGMENT_RADIUS, 0.0); #ifndef DRAW_MESH draw_sky(d, 0.0); glFogi(GL_FOG_MODE, GL_LINEAR ); glFogfv(GL_FOG_COLOR, fog_color); glFogf(GL_FOG_START, FOG_START); glFogf(GL_FOG_END, FOG_END); glEnable(GL_FOG); /* We set the light after we rotated stuff */ lemuria_set_material(&material, GL_FRONT); glEnable(GL_LIGHTING); lemuria_background_set(&(d->drive_background)); lemuria_set_light(&light_0, GL_LIGHT0); glEnable(GL_LIGHT0); glEnable(GL_TEXTURE_2D); #endif // lemuria_set_light(&light_1, GL_LIGHT1); // glEnable(GL_LIGHT1); // fprintf(stderr, "Segments: %d %d\n", d->start_segment, d->end_segment); for(i = 0; i < NUM_SEGMENTS-1; i++) { draw_segment(d, index_1, index_2); if(index_2 == d->end_segment) break; index_1++; if(index_1 >= NUM_SEGMENTS) index_1 = 0; index_2++; if(index_2 >= NUM_SEGMENTS) index_2 = 0; } glPopMatrix(); glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); glDisable(GL_LIGHT0); glDisable(GL_LIGHT1); glDisable(GL_FOG); }
/* An explicit control evaluator, taken almost directly from SICP, section * 5.2. list is a flat list of expressions to evaluate. where is a label to * begin at. Return value depends on where. */ NODE *evaluator(NODE *list, enum labels where) { /* registers */ NODE *exp = NIL, /* the current expression */ *val = NIL, /* the value of the last expression */ *proc = NIL, /* the procedure definition */ *argl = NIL, /* evaluated argument list */ *unev = NIL, /* list of unevaluated expressions */ *stack = NIL, /* register stack */ *parm = NIL, /* the current formal */ *catch_tag = NIL, *arg = NIL; /* the current actual */ /* registers that don't get reference counted, so we pretend they're ints */ FIXNUM vsp = 0, /* temp ptr into var_stack */ cont = 0, /* where to go next */ formals = (FIXNUM)NIL; /* list of formal parameters */ int i, nargs; BOOLEAN tracing; /* are we tracing the current procedure? */ FIXNUM oldtailcall; /* in case of reentrant use of evaluator */ FIXNUM repcount; /* count for repeat */ FIXNUM old_ift_iff; oldtailcall = tailcall; old_ift_iff = ift_iff_flag; save2(var,this_line); assign(var, var_stack); save2(fun,ufun); cont = (FIXNUM)all_done; numsave((FIXNUM)cont); newcont(where); goto fetch_cont; begin_line: ref(list); assign(this_line, list); newcont(end_line); begin_seq: make_tree(list); if (!is_tree(list)) { assign(val, UNBOUND); goto fetch_cont; } assign(unev, tree__tree(list)); assign(val, UNBOUND); goto eval_sequence; end_line: if (val != UNBOUND) { if (NOT_THROWING) err_logo(DK_WHAT, val); deref(val); } val = NIL; deref(list); goto fetch_cont; /* ----------------- EVAL ---------------------------------- */ tail_eval_dispatch: tailcall = 1; eval_dispatch: switch (nodetype(exp)) { case QUOTE: /* quoted literal */ assign(val, node__quote(exp)); goto fetch_cont; case COLON: /* variable */ assign(val, valnode__colon(exp)); while (val == UNBOUND && NOT_THROWING) assign(val, err_logo(NO_VALUE, node__colon(exp))); goto fetch_cont; case CONS: /* procedure application */ if (tailcall == 1 && is_macro(car(exp)) && is_list(procnode__caseobj(car(exp)))) { /* tail call to user-defined macro must be treated as non-tail * because the expression returned by the macro * remains to be evaluated in the caller's context */ assign(unev, NIL); goto non_tail_eval; } assign(fun, car(exp)); if (cdr(exp) != NIL) goto ev_application; else goto ev_no_args; default: assign(val, exp); /* self-evaluating */ goto fetch_cont; } ev_no_args: /* Evaluate an application of a procedure with no arguments. */ assign(argl, NIL); goto apply_dispatch; /* apply the procedure */ ev_application: /* Evaluate an application of a procedure with arguments. */ assign(unev, cdr(exp)); assign(argl, NIL); mixsave(tailcall,var); num2save(val_status,ift_iff_flag); save2(didnt_get_output,didnt_output_name); eval_arg_loop: if (unev == NIL) goto eval_args_done; assign(exp, car(unev)); if (exp == Not_Enough_Node) { if (NOT_THROWING) err_logo(NOT_ENOUGH, NIL); goto eval_args_done; } save(argl); save2(unev,fun); save2(ufun,last_ufun); save2(this_line,last_line); assign(var, var_stack); tailcall = -1; val_status = 1; assign(didnt_get_output, cons_list(0,fun,ufun,this_line,END_OF_LIST)); assign(didnt_output_name, NIL); newcont(accumulate_arg); goto eval_dispatch; /* evaluate the current argument */ accumulate_arg: /* Put the evaluated argument into the argl list. */ reset_args(var); restore2(this_line,last_line); restore2(ufun,last_ufun); assign(last_call, fun); restore2(unev,fun); restore(argl); while (NOT_THROWING && val == UNBOUND) { assign(val, err_logo(DIDNT_OUTPUT, NIL)); } push(val, argl); pop(unev); goto eval_arg_loop; eval_args_done: restore2(didnt_get_output,didnt_output_name); num2restore(val_status,ift_iff_flag); mixrestore(tailcall,var); if (stopping_flag == THROWING) { assign(val, UNBOUND); goto fetch_cont; } assign(argl, reverse(argl)); /* --------------------- APPLY ---------------------------- */ apply_dispatch: /* Load in the procedure's definition and decide whether it's a compound * procedure or a primitive procedure. */ proc = procnode__caseobj(fun); if (is_macro(fun)) { num2save(val_status,tailcall); val_status = 1; newcont(macro_return); } if (proc == UNDEFINED) { if (ufun != NIL) { untreeify_proc(ufun); } if (NOT_THROWING) assign(val, err_logo(DK_HOW, fun)); else assign(val, UNBOUND); goto fetch_cont; } if (is_list(proc)) goto compound_apply; /* primitive_apply */ if (NOT_THROWING) assign(val, (*getprimfun(proc))(argl)); else assign(val, UNBOUND); #define do_case(x) case x: goto x; fetch_cont: { enum labels x = (enum labels)cont; cont = (FIXNUM)car(stack); numpop(&stack); switch (x) { do_list(do_case) default: abort(); } } compound_apply: #ifdef mac check_mac_stop(); #endif #ifdef ibm check_ibm_stop(); #endif if (tracing = flag__caseobj(fun, PROC_TRACED)) { for (i = 0; i < trace_level; i++) print_space(writestream); trace_level++; ndprintf(writestream, "( %s ", fun); } /* Bind the actuals to the formals */ vsp = (FIXNUM)var_stack; /* remember where we came in */ for (formals = (FIXNUM)formals__procnode(proc); formals != (FIXNUM)NIL; formals = (FIXNUM)cdr((NODE *)formals)) { parm = car((NODE *)formals); if (nodetype(parm) == INT) break; /* default # args */ if (argl != NIL) { arg = car(argl); if (tracing) { print_node(writestream, maybe_quote(arg)); print_space(writestream); } } else arg = UNBOUND; if (nodetype(parm) == CASEOBJ) { if (not_local(parm,(NODE *)vsp)) { push(parm, var_stack); setobject(var_stack, valnode__caseobj(parm)); } tell_shadow(parm); setvalnode__caseobj(parm, arg); } else if (nodetype(parm) == CONS) { /* parm is optional or rest */ if (not_local(car(parm),(NODE *)vsp)) { push(car(parm), var_stack); setobject(var_stack, valnode__caseobj(car(parm))); } tell_shadow(car(parm)); if (cdr(parm) == NIL) { /* parm is rest */ setvalnode__caseobj(car(parm), argl); break; } if (arg == UNBOUND) { /* use default */ save2(fun,var); save2(ufun,last_ufun); save2(this_line,last_line); save2(didnt_output_name,didnt_get_output); num2save(ift_iff_flag,val_status); assign(var, var_stack); tailcall = -1; val_status = 1; mixsave(formals,argl); numsave(vsp); assign(list, cdr(parm)); if (NOT_THROWING) make_tree(list); else assign(list, NIL); if (!is_tree(list)) { assign(val, UNBOUND); goto set_args_continue; } assign(unev, tree__tree(list)); assign(val, UNBOUND); newcont(set_args_continue); goto eval_sequence; set_args_continue: numrestore(vsp); mixrestore(formals,argl); parm = car((NODE *)formals); reset_args(var); num2restore(ift_iff_flag,val_status); restore2(didnt_output_name,didnt_get_output); restore2(this_line,last_line); restore2(ufun,last_ufun); restore2(fun,var); arg = val; } setvalnode__caseobj(car(parm), arg); } if (argl != NIL) pop(argl); } if (check_throwing) { assign(val, UNBOUND); goto fetch_cont; } vsp = 0; if (tracing = flag__caseobj(fun, PROC_TRACED)) { if (NOT_THROWING) print_char(writestream, ')'); new_line(writestream); save(fun); newcont(compound_apply_continue); } assign(val, UNBOUND); assign(last_ufun, ufun); assign(ufun, fun); assign(last_line, this_line); assign(this_line, NIL); proc = procnode__caseobj(fun); assign(list, bodylist__procnode(proc)); /* get the body ... */ make_tree_from_body(list); if (!is_tree(list)) { goto fetch_cont; } assign(unev, tree__tree(list)); if (NOT_THROWING) stopping_flag = RUN; assign(output_node, UNBOUND); if (val_status == 1) val_status = 2; else if (val_status == 5) val_status = 3; else val_status = 0; eval_sequence: /* Evaluate each expression in the sequence. Stop as soon as * val != UNBOUND. */ if (!RUNNING || val != UNBOUND) { goto fetch_cont; } if (nodetype(unev) == LINE) { assign(this_line, unparsed__line(unev)); if (flag__caseobj(ufun, PROC_STEPPED)) { char junk[20]; if (tracing) { int i = 1; while (i++ < trace_level) print_space(stdout); } print_node(stdout, this_line); ndprintf(stdout, " >>> "); input_blocking++; #ifndef TIOCSTI if (!setjmp(iblk_buf)) #endif #ifdef __ZTC__ ztc_getcr(); #else fgets(junk, 19, stdin); #endif input_blocking = 0; update_coords('\n'); } } assign(exp, car(unev)); pop(unev); if (is_list(exp) && (is_tailform(procnode__caseobj(car(exp))))) { if (nameis(car(exp),Output) || nameis(car(exp),Op)) { assign(didnt_get_output, cons_list(0,car(exp),ufun,this_line,END_OF_LIST)); assign(didnt_output_name, NIL); if (val_status == 2 || val_status == 3) { val_status = 1; assign(exp, cadr(exp)); goto tail_eval_dispatch; } else if (ufun == NIL) { err_logo(AT_TOPLEVEL,car(exp)); assign(val, UNBOUND); goto fetch_cont; } else if (val_status < 4) { val_status = 1; assign(exp, cadr(exp)); assign(unev, NIL); goto non_tail_eval; /* compute value then give error */ } } else if (nameis(car(exp),Stop)) { if (ufun == NIL) { err_logo(AT_TOPLEVEL,car(exp)); assign(val, UNBOUND); goto fetch_cont; } else if (val_status == 0 || val_status == 3) { assign(val, UNBOUND); goto fetch_cont; } else if (val_status < 4) { assign(didnt_output_name, fun); assign(val, UNBOUND); goto fetch_cont; } } else { /* maybeoutput */ assign(exp, cadr(exp)); val_status = 5; goto tail_eval_dispatch; } } if (unev == NIL) { if (val_status == 2 || val_status == 4) { assign(didnt_output_name, fun); assign(unev, UNBOUND); goto non_tail_eval; } else { goto tail_eval_dispatch; } } if (is_list(car(unev)) && nameis(car(car(unev)),Stop)) { if ((val_status == 0 || val_status == 3) && ufun != NIL) { goto tail_eval_dispatch; } else if (val_status < 4) { assign(didnt_output_name, fun); goto tail_eval_dispatch; } } non_tail_eval: save2(unev,fun); num2save(ift_iff_flag,val_status); save2(ufun,last_ufun); save2(this_line,last_line); save(var); assign(var, var_stack); tailcall = 0; newcont(eval_sequence_continue); goto eval_dispatch; eval_sequence_continue: reset_args(var); restore(var); restore2(this_line,last_line); restore2(ufun,last_ufun); if (dont_fix_ift) { num2restore(dont_fix_ift,val_status); dont_fix_ift = 0; } else num2restore(ift_iff_flag,val_status); restore2(unev,fun); if (stopping_flag == MACRO_RETURN) { if (unev == UNBOUND) assign(unev, NIL); assign(unev, append(val, unev)); assign(val, UNBOUND); stopping_flag = RUN; if (unev == NIL) goto fetch_cont; } else if (val_status < 4) { if (STOPPING || RUNNING) assign(output_node, UNBOUND); if (stopping_flag == OUTPUT || STOPPING) { stopping_flag = RUN; assign(val, output_node); if (val != UNBOUND && val_status < 2 && NOT_THROWING) { assign(didnt_output_name,Output); err_logo(DIDNT_OUTPUT,Output); } if (val == UNBOUND && val_status == 1 && NOT_THROWING) { assign(didnt_output_name,Stop); err_logo(DIDNT_OUTPUT,Output); } goto fetch_cont; } } if (val != UNBOUND) { err_logo((unev == NIL ? DK_WHAT_UP : DK_WHAT), val); assign(val, UNBOUND); } if (NOT_THROWING && (unev == NIL || unev == UNBOUND)) { if (val_status != 4) err_logo(DIDNT_OUTPUT,NIL); goto fetch_cont; } goto eval_sequence; compound_apply_continue: /* Only get here if tracing */ restore(fun); --trace_level; if (NOT_THROWING) { for (i = 0; i < trace_level; i++) print_space(writestream); print_node(writestream, fun); if (val == UNBOUND) ndprintf(writestream, " stops\n"); else { ref(val); ndprintf(writestream, " outputs %s\n", maybe_quote(val)); deref(val); } } goto fetch_cont; /* --------------------- MACROS ---------------------------- */ macro_return: num2restore(val_status,tailcall); while (!is_list(val) && NOT_THROWING) { assign(val,err_logo(ERR_MACRO,val)); } if (NOT_THROWING) { if (is_cont(val)) { newcont(cont__cont(val)); val->n_car = NIL; assign(val, val__cont(val)); goto fetch_cont; } macro_reval: if (tailcall == 0) { make_tree(val); stopping_flag = MACRO_RETURN; if (!is_tree(val)) assign(val, NIL); else assign(val, tree__tree(val)); goto fetch_cont; } assign(list,val); goto begin_seq; } assign(val, UNBOUND); goto fetch_cont; runresult_continuation: assign(list, val); newcont(runresult_followup); val_status = 5; goto begin_seq; runresult_followup: if (val == UNBOUND) { assign(val, NIL); } else { assign(val, cons(val, NIL)); } goto fetch_cont; repeat_continuation: assign(list, cdr(val)); repcount = getint(car(val)); repeat_again: assign(val, UNBOUND); if (repcount == 0) goto fetch_cont; mixsave(repcount,list); num2save(val_status,tailcall); val_status = 4; newcont(repeat_followup); goto begin_seq; repeat_followup: if (val != UNBOUND && NOT_THROWING) { ref(val); err_logo(DK_WHAT, val); unref(val); } num2restore(val_status,tailcall); mixrestore(repcount,list); if (val_status < 4 && tailcall != 0) { if (STOPPING || RUNNING) assign(output_node, UNBOUND); if (stopping_flag == OUTPUT || STOPPING) { stopping_flag = RUN; assign(val, output_node); if (val != UNBOUND && val_status < 2) { err_logo(DK_WHAT_UP,val); } goto fetch_cont; } } if (repcount > 0) /* negative means forever */ --repcount; #ifdef mac check_mac_stop(); #endif #ifdef ibm check_ibm_stop(); #endif if (RUNNING) goto repeat_again; assign(val, UNBOUND); goto fetch_cont; catch_continuation: assign(list, cdr(val)); assign(catch_tag, car(val)); if (compare_node(catch_tag,Error,TRUE) == 0) { push(Erract, var_stack); setobject(var_stack, valnode__caseobj(Erract)); setvalnode__caseobj(Erract, UNBOUND); } save(catch_tag); save2(didnt_output_name,didnt_get_output); num2save(val_status,tailcall); newcont(catch_followup); val_status = 5; goto begin_seq; catch_followup: num2restore(val_status,tailcall); restore2(didnt_output_name,didnt_get_output); restore(catch_tag); if (val_status < 4 && tailcall != 0) { if (STOPPING || RUNNING) assign(output_node, UNBOUND); if (stopping_flag == OUTPUT || STOPPING) { stopping_flag = RUN; assign(val, output_node); if (val != UNBOUND && val_status < 2) { err_logo(DK_WHAT_UP,val); } } } if (stopping_flag == THROWING && compare_node(throw_node, catch_tag, TRUE) == 0) { throw_node = reref(throw_node, UNBOUND); stopping_flag = RUN; assign(val, output_node); } goto fetch_cont; begin_apply: /* This is for lapply. */ assign(fun, car(val)); while (nodetype(fun) == ARRAY && NOT_THROWING) assign(fun, err_logo(APPLY_BAD_DATA, fun)); assign(argl, cadr(val)); assign(val, UNBOUND); while (!is_list(argl) && NOT_THROWING) assign(argl, err_logo(APPLY_BAD_DATA, argl)); if (NOT_THROWING && fun != NIL) { if (is_list(fun)) { /* template */ if (is_list(car(fun)) && cdr(fun) != NIL) { /* lambda form */ formals = (FIXNUM)car(fun); numsave(tailcall); tailcall = 0; llocal((NODE *)formals); /* bind the formals locally */ numrestore(tailcall); for ( ; formals && argl && NOT_THROWING; formals = (FIXNUM)cdr((NODE *)formals), assign(argl, cdr(argl))) setvalnode__caseobj(car((NODE *)formals), car(argl)); assign(val, cdr(fun)); goto macro_reval; } else { /* question-mark form */ save(qm_list); assign(qm_list, argl); assign(list, fun); make_tree(list); if (list == NIL || !is_tree(list)) { goto qm_failed; } assign(unev, tree__tree(list)); save2(didnt_output_name,didnt_get_output); num2save(val_status,tailcall); newcont(qm_continue); val_status = 5; goto eval_sequence; qm_continue: num2restore(val_status,tailcall); restore2(didnt_output_name,didnt_get_output); if (val_status < 4 && tailcall != 0) { if (STOPPING || RUNNING) assign(output_node, UNBOUND); if (stopping_flag == OUTPUT || STOPPING) { stopping_flag = RUN; assign(val, output_node); if (val != UNBOUND && val_status < 2) { err_logo(DK_WHAT_UP,val); } } } qm_failed: restore(qm_list); goto fetch_cont; } } else { /* name of procedure to apply */ int min, max, n; NODE *arg; assign(fun, intern(fun)); if (procnode__caseobj(fun) == UNDEFINED && NOT_THROWING && fun != Null_Word) silent_load(fun, NULL); /* try ./<fun>.lg */ if (procnode__caseobj(fun) == UNDEFINED && NOT_THROWING && fun != Null_Word) silent_load(fun, logolib); /* try <logolib>/<fun> */ proc = procnode__caseobj(fun); while (proc == UNDEFINED && NOT_THROWING) { assign(val, err_logo(DK_HOW_UNREC, fun)); } if (NOT_THROWING) { if (nodetype(proc) == CONS) { min = getint(minargs__procnode(proc)); max = getint(maxargs__procnode(proc)); } else { if (getprimdflt(proc) < 0) { /* special form */ err_logo(DK_HOW_UNREC, fun); /* can't apply */ goto fetch_cont; } else { min = getprimmin(proc); max = getprimmax(proc); } } for (n = 0, arg = argl; arg != NIL; n++, arg = cdr(arg)); if (n < min) { err_logo(NOT_ENOUGH, NIL); } else if (n > max && max >= 0) { err_logo(TOO_MUCH, NIL); } else { goto apply_dispatch; } } } } goto fetch_cont; all_done: tailcall = oldtailcall; ift_iff_flag = old_ift_iff; restore2(fun,ufun); reset_args(var); restore2(var,this_line); deref(argl);deref(unev);deref(stack);deref(catch_tag);deref(exp); return(val); }
int main(){ uint32_t size = 0; uint32_t iters = 0; FILE * fp; FILE * fp2; FILE * fp3; char * line = NULL; size_t len = 0; ssize_t read; fp = fopen("HW1_P2.in", "r"); fp2 = fopen("HW1_P3.out","w"); fp3 = fopen("HW1_P3_DataToPlot.in", "w"); //Check if the file exists if (fp == NULL) exit(EXIT_FAILURE); while ((read = getline(&line, &len, fp)) != -1) { char *token; char *rest = line; token = strtok_r(rest, ",", &rest); size = (uint32_t)atoi(token); token = strtok_r(rest, ",", &rest); iters = (uint32_t)atoi(token); //printf("size:%u\n",size); //printf("iters:%u\n",iters); //Initialize pointers to arrays double avg_avgtimes = 0; double avgtimes[TIMES_PER_MEASUREMENTS] = {0}; for (uint32_t i=0;i<TIMES_PER_MEASUREMENTS;++i){ srand(size); //Initialize arrays to zero Float * x = calloc(size,sizeof(Float)); Float * y = calloc(size,sizeof(Float)); Float * z = calloc(size,sizeof(Float)); Float * vx = calloc(size,sizeof(Float)); Float * vy = calloc(size,sizeof(Float)); Float * vz = calloc(size,sizeof(Float)); //Generate our random arrays generate_random_list(size,coord_bound,x); generate_random_list(size,coord_bound,x); generate_random_list(size,coord_bound,y); generate_random_list(size,coord_bound,z); generate_random_list(size,move_bound,vx); generate_random_list(size,move_bound,vy); generate_random_list(size,move_bound,vz); clock_t begin, end; double time_spent; begin = clock(); for (uint32_t i=0;i<iters;++i){ update_coords(x,y,z,vx,vy,vz,size); } end = clock(); time_spent = (double)(end - begin) / CLOCKS_PER_SEC; Float chksum = sum_array(x,size) + sum_array(y,size) + sum_array(z,size); double avgtime = 1000000 * time_spent / (size * iters); avgtimes[i] = avgtime; //write detailed ouput fprintf(fp2,"size: %u, iters: %u\n",size,iters); fprintf(fp2,"total time:%f\n",time_spent); fprintf(fp2,"Mean time per coordinate: %f\n",avgtime); fprintf(fp2,"Final checksum is: %f\n",chksum); //free memory free(x); free(y); free(z); free(vx); free(vy); free(vz); } //write output for the purpose of drawing a graph avg_avgtimes = sum_array(avgtimes,TIMES_PER_MEASUREMENTS)/TIMES_PER_MEASUREMENTS; fprintf(fp3,"%u,%f\n",size,avg_avgtimes); } //close files fclose(fp); fclose(fp2); fclose(fp3); if (line) free(line); return 0; }
int rd_getc(FILE *strm) { int c; #ifdef WIN32 MSG msg; #endif #ifndef WIN32 /* skip this section ... */ #ifdef __RZTC__ if (strm == stdin) zflush(); c = ztc_getc(strm); #else c = getc(strm); #endif if (strm == stdin && c != EOF) update_coords(c); #ifndef mac if (c == '\r') return rd_getc(strm); #endif #ifdef ibm if (c == 17 && interactive && strm==stdin) { /* control-q */ to_pending = 0; err_logo(STOP_ERROR,NIL); if (input_blocking) { #ifdef SIG_TAKES_ARG logo_stop(0); #else logo_stop(); #endif } } if (c == 23 && interactive && strm==stdin) { /* control-w */ #ifndef __RZTC__ getc(strm); /* eat up the return */ #endif #ifdef SIG_TAKES_ARG logo_pause(0); #else logo_pause(); #endif return(rd_getc(strm)); } #endif #else /* WIN32 */ if (strm == stdin) { if (winPasteText && !line_avail) winDoPaste(); if (!line_avail) { win32_text_cursor(); while (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); if (line_avail) break; } } c = read_line[read_index++]; if (c == 17 && interactive && strm==stdin) { /* control-q */ to_pending = 0; err_logo(STOP_ERROR,NIL); line_avail = 0; free(read_line); if (input_blocking) logo_stop(0); return('\n'); } if (c == 23 && interactive && strm==stdin) { /* control-w */ line_avail = 0; free(read_line); logo_pause(0); return(rd_getc(strm)); } if (c == '\n') { line_avail = 0; free(read_line); } } else /* reading from a file */ c = getc(strm); #endif /* WIN32 */ #ifdef ecma return((c == EOF) ? c : ecma_clear(c)); #else return(c); #endif }