static int thread_proc(void *arg) #endif /* HAVE_PTHREAD */ { struct threadpool *tp = (struct threadpool *) arg; int index; enter_critical_section(tp); index = ++tp->thread_index; for(;;) { tp->wait_count--; if (!tp->wait_count) signal_completion(tp); wait_for_exec(tp); if (tp->thread_die) break; exec_loop(tp, index); } if (!(--tp->wait_count)) signal_completion(tp); leave_critical_section(tp); return 0; }
void tp_exec(threadpool_t pool, LIST *list) { struct threadpool *tp = (struct threadpool *) pool; enter_critical_section(tp); tp->list = list->first; /* tp->wait_count = list->size; */ tp->wait_count = tp->thread_count; signal_exec(tp); exec_loop(tp, 0); if (tp->wait_count) wait_for_completion(tp); leave_critical_section(tp); }
int main(void) { //CTIMER_DECLARE(); #if 0 uint32_t memory = SRAM1_LOC; uint32_t lut = SRAM1_LOC; //while(1); memset((void *)QQ_LOC, 0x01, 0x3000); g_qqueue->writeIndex = 0; g_qqueue->produced = 0; g_qqueue->consumed = 0; while(1) getRLSFrame(&memory, &lut); #endif #if 0 int i = 0x12345678; foo(&i); printf("%d\n", i); while(1); #endif #if 0 int i; uint32_t lut = SRAM1_LOC; uint32_t memory = SRAM1_LOC+0x1000; uint8_t *plut = (uint8_t *)lut; for (i=0; i<0x4000; i++) plut[i] = i%5==0 ? 1 : 0; while(1) getRLSFrame(&memory, &lut); #endif #if 1 _DBG("M0 start\n"); chirpOpen(); exec_init(); frame_init(); rls_init(); #if 0 while(1) { if (g_foo) loop0(); } #endif #if 0 vsync(); #endif #if 0 //while(g_loop); uint8_t type = CAM_GRAB_M1R2; uint32_t memory = SRAM1_LOC; uint16_t offset = 0; uint16_t width = 320; uint16_t height = 200; while(1) { getFrame(&type, &memory, &offset, &offset, &width, &height); i++; if (i%50==0) { _DBD32(i), _CR(); } } #endif //printf("M0 ready\n"); exec_loop(); #endif #if 0 while(1) { CTIMER_START(); syncM1((uint32_t *)&LPC_GPIO_PORT->PIN[1], 0x2000); CTIMER_STOP(); printf("%d\n", CTIMER_GET()); } #endif #if 0 { uint32_t i; uint8_t *lut = (uint8_t *)SRAM1_LOC + 0x10000; uint32_t memory = SRAM1_LOC; uint32_t size = SRAM1_SIZE/2; for (i=0; i<0x10000; i++) lut[i] = 0; lut[0xb400] = 0; lut[0xb401] = 1; lut[0xb402] = 1; lut[0xb403] = 1; lut[0xb404] = 0; lut[0xb405] = 1; lut[0xb406] = 1; lut[0xb407] = 0; lut[0xb408] = 0; lut[0xb409] = 0; while(1) getRLSFrame(&memory, &size); //, (uint32_t *)&lut); } #endif return 0; }
// simEngine API: simengine_runmodel() // // executes the model for the given parameters, states and simulation time EXTERN_C simengine_result *simengine_runmodel(double start_time, double stop_time, unsigned int num_models, double *inputs, double *states, simengine_alloc *alloc){ CDATAFORMAT model_states[NUM_MODELS * NUM_STATES]; CDATAFORMAT parameters[NUM_MODELS * NUM_INPUTS]; unsigned int stateid; unsigned int modelid; unsigned int inputid; unsigned int outputid; // Set up allocation functions if(alloc){ se_alloc.malloc = alloc->malloc; se_alloc.realloc = alloc->realloc; se_alloc.free = alloc->free; } // Create result structure simengine_result *seresult = (simengine_result*)se_alloc.malloc(sizeof(simengine_result)); // Couldn't allocate return structure, return NULL if(!seresult) return NULL; // Check that the number of models matches if(num_models != semeta.num_models){ seresult->status = ERRNUMMDL; seresult->status_message = (char*) simengine_errors[ERRNUMMDL]; seresult->outputs = NULL; seresult->final_states = NULL; seresult->final_time = NULL; return seresult; } // Allocate return structures if(seint.num_outputs){ seresult->outputs = (simengine_output*)se_alloc.malloc(semeta.num_models * seint.num_outputs * sizeof(simengine_output)); } else{ seresult->outputs = NULL; } if(seint.num_states){ seresult->final_states = (double*)se_alloc.malloc(semeta.num_models * seint.num_states * sizeof(double)); } else{ seresult->final_states = NULL; } seresult->final_time = (double*)se_alloc.malloc(semeta.num_models * sizeof(double)); if((seint.num_outputs && !seresult->outputs) || (seint.num_states && !seresult->final_states) ||!seresult->final_time){ seresult->status = ERRMEM; seresult->status_message = (char*) simengine_errors[ERRMEM]; seresult->outputs = NULL; seresult->final_states = NULL; seresult->final_time = NULL; return seresult; } // Copy inputs and state initial values to internal representation for(modelid=0; modelid<semeta.num_models; modelid++){ for(stateid=0;stateid<seint.num_states;stateid++){ model_states[TARGET_IDX(seint.num_states, semeta.num_models, stateid, modelid)] = states[AS_IDX(seint.num_states, semeta.num_models, stateid, modelid)]; } for(inputid=0;inputid<seint.num_inputs;inputid++){ parameters[TARGET_IDX(seint.num_inputs, semeta.num_models, inputid, modelid)] = inputs[AS_IDX(seint.num_inputs, semeta.num_models, inputid, modelid)]; } } // Initialization of output structures for (modelid = 0; modelid < semeta.num_models; ++modelid) { for (outputid = 0; outputid < seint.num_outputs; ++outputid) { seresult->outputs[AS_IDX(seint.num_outputs, semeta.num_models, outputid, modelid)].alloc = START_SIZE; seresult->outputs[AS_IDX(seint.num_outputs, semeta.num_models, outputid, modelid)].num_quantities = seint.output_num_quantities[outputid]; seresult->outputs[AS_IDX(seint.num_outputs, semeta.num_models, outputid, modelid)].num_samples = 0; seresult->outputs[AS_IDX(seint.num_outputs, semeta.num_models, outputid, modelid)].data = (double*)se_alloc.malloc(START_SIZE*seint.output_num_quantities[outputid]*sizeof(double)); } } // Initialize the solver properties solver_props *props = init_solver_props(start_time, stop_time, parameters, model_states, seresult->outputs); // Run the model seresult->status = exec_loop(props); seresult->status_message = (char*) simengine_errors[seresult->status]; // Copy state values back to state initial value structure for(modelid=0; modelid<semeta.num_models; modelid++){ seresult->final_time[modelid] = props->time[modelid]; // Time from the first solver for(stateid=0;stateid<seint.num_states;stateid++){ seresult->final_states[AS_IDX(seint.num_states, semeta.num_models, stateid, modelid)] = model_states[TARGET_IDX(seint.num_states, semeta.num_models, stateid, modelid)]; } } free_solver_props(props); return seresult; }
int main(void) { // pixyInit(SRAM3_LOC, &LR0[0], sizeof(LR0)); #if 0 pixyInit(); cc_init(g_chirpUsb); ser_init(); exec_init(g_chirpUsb); #endif #if 1 /* test loop */ pixyInit(); exec_init(g_chirpUsb); #if 0 int i = 0; cam_setMode(1); while(1) { //uint8_t reg = cam_getRegister(0x0a); g_chirpUsb->service(); cprintf("hello world %d\n", i++); } #endif #if 0 while(1) { uint8_t *frame = (uint8_t *)SRAM1_LOC; int res; res = cam_getFrame(frame, SRAM1_SIZE, CAM_GRAB_M1R2, 0, 0, CAM_RES2_WIDTH, CAM_RES2_HEIGHT); i++; if (i%50==0) { lpc_printf("%d\n", i); } } #endif #endif #if 1 exec_addProg(&g_progBlobs); ptLoadParams(); exec_addProg(&g_progPt); exec_addProg(&g_progVideo, true); exec_loop(); #endif #if 0 //prm_format(); ColorModel model, *model2; uint32_t len; model.m_hue[0].m_slope = 1.0; model.m_hue[0].m_yi = 2.0; model.m_hue[1].m_slope = 3.0; model.m_hue[1].m_yi = 4.0; model.m_sat[0].m_slope = 5.0; model.m_sat[0].m_yi = 6.0; model.m_sat[1].m_slope = 7.0; model.m_sat[1].m_yi = 8.0; prm_add("signature1", "Color signature 1", INTS8(sizeof(ColorModel), &model), END); prm_set("signature1", INTS8(sizeof(ColorModel), &model), END); model.m_hue[0].m_slope = 9.0; model.m_hue[0].m_yi = 10.0; model.m_hue[1].m_slope = 11.0; model.m_hue[1].m_yi = 12.0; model.m_sat[0].m_slope = 13.0; model.m_sat[0].m_yi = 14.0; model.m_sat[1].m_slope = 15.0; model.m_sat[1].m_yi = 16.0; prm_add("signature2", "Color signature 2", INTS8(sizeof(ColorModel), &model), END); prm_set("signature2", INTS8(sizeof(ColorModel), &model), END); prm_get("signature1", &len, &model2, END); model.m_hue[0].m_slope = 17.0; model.m_hue[0].m_yi = 18.0; model.m_hue[1].m_slope = 19.0; model.m_hue[1].m_yi = 20.0; model.m_sat[0].m_slope = 21.0; model.m_sat[0].m_yi = 22.0; model.m_sat[1].m_slope = 23.0; model.m_sat[1].m_yi = 24.0; prm_get("signature1", &len, &model2, END); prm_set("signature1", INTS8(sizeof(ColorModel), &model), END); prm_get("signature1", &len, &model2, END); prm_get("signature2", &len, &model2, END); #endif #if 0 #define DELAY 1000000 rcs_setFreq(100); rcs_setLimits(0, -200, 200); rcs_setLimits(1, -200, 200); while(1) { rcs_setPos(0, 0); delayus(DELAY); rcs_setPos(0, 500); delayus(DELAY); rcs_setPos(0, 1000); delayus(DELAY); rcs_setPos(1, 0); delayus(DELAY); rcs_setPos(1, 500); delayus(DELAY); rcs_setPos(1, 1000); delayus(DELAY); } #endif #if 0 while(1) { g_chirpUsb->service(); handleButton(); } #endif }
// simengine_runmodel() // // executes the model for the given parameters, states and simulation time simengine_result *simengine_runmodel(simengine_opts *opts){ double start_time = opts->start_time; double stop_time = opts->stop_time; unsigned int num_models = opts->num_models; const char *outputs_dirname = opts->outputs_dirname; CDATAFORMAT model_states[PARALLEL_MODELS * NUM_STATES]; unsigned int stateid; unsigned int modelid; unsigned int models_executed; unsigned int models_per_batch; double *progress; int progress_fd; int output_fd; int resuming = 0; int random_initialized = 0; # if defined TARGET_GPU gpu_init(); # endif open_progress_file(outputs_dirname, &progress, &progress_fd, num_models); // Create result structure simengine_result *seresult = (simengine_result*)malloc(sizeof(simengine_result)); // Couldn't allocate return structure, return NULL if(!seresult) return NULL; if(seint.num_states){ seresult->final_states = (double*)malloc(num_models * seint.num_states * sizeof(double)); } else{ seresult->final_states = NULL; } seresult->final_time = (double*)malloc(num_models * sizeof(double)); if((seint.num_states && !seresult->final_states) ||!seresult->final_time){ seresult->status = ERRMEM; seresult->status_message = (char*) simengine_errors[ERRMEM]; seresult->final_states = NULL; seresult->final_time = NULL; return seresult; } init_output_buffers(outputs_dirname, &output_fd); // Run the parallel simulation repeatedly until all requested models have been executed for(models_executed = 0 ; models_executed < num_models; models_executed += PARALLEL_MODELS){ models_per_batch = MIN(num_models - models_executed, PARALLEL_MODELS); // Copy inputs and state initial values to internal representation unsigned int modelid_offset = global_modelid_offset + models_executed; #if NUM_CONSTANT_INPUTS > 0 #if defined TARGET_GPU host_constant_inputs = (CDATAFORMAT *)malloc(PARALLEL_MODELS * NUM_CONSTANT_INPUTS * sizeof(CDATAFORMAT)); #else host_constant_inputs = constant_inputs; #endif #else CDATAFORMAT *host_constant_inputs = NULL; #endif #if NUM_SAMPLED_INPUTS > 0 #if defined TARGET_GPU host_sampled_inputs = (sampled_input_t *)malloc(STRUCT_SIZE * NUM_SAMPLED_INPUTS * sizeof(sampled_input_t)); #else host_sampled_inputs = sampled_inputs; #endif #else sampled_input_t *host_sampled_inputs = NULL; #endif resuming = initialize_states(model_states, outputs_dirname, num_models, models_per_batch, modelid_offset); initialize_inputs(host_constant_inputs, host_sampled_inputs, outputs_dirname, num_models, models_per_batch, modelid_offset, start_time); #if defined TARGET_GPU && NUM_CONSTANT_INPUTS > 0 CDATAFORMAT *g_constant_inputs; cutilSafeCall(cudaGetSymbolAddress((void **)&g_constant_inputs, constant_inputs)); cutilSafeCall(cudaMemcpy(g_constant_inputs, host_constant_inputs, PARALLEL_MODELS * NUM_CONSTANT_INPUTS * sizeof(CDATAFORMAT), cudaMemcpyHostToDevice)); #endif #if defined TARGET_GPU && NUM_SAMPLED_INPUTS > 0 sampled_input_t *g_sampled_inputs; cutilSafeCall(cudaGetSymbolAddress((void **)&g_sampled_inputs, sampled_inputs)); cutilSafeCall(cudaMemcpy(g_sampled_inputs, host_sampled_inputs, STRUCT_SIZE * NUM_SAMPLED_INPUTS * sizeof(sampled_input_t), cudaMemcpyHostToDevice)); #endif // Initialize the solver properties and internal simulation memory structures solver_props *props = init_solver_props(start_time, stop_time, models_per_batch, model_states, models_executed+global_modelid_offset); // Initialize random number generator if (!random_initialized || opts->seeded) { random_init(models_per_batch); random_initialized = 1; } // If no initial states were passed in if(!resuming){ if(seint.num_states > 0){ // Initialize default states in next_states for(modelid=0;modelid<models_per_batch;modelid++){ init_states(props, modelid); // Copy states from next_states to model_states unsigned int iterid; for(iterid=0;iterid<seint.num_iterators;iterid++){ solver_writeback(&props[iterid], modelid); } } } } // Run the model seresult->status = exec_loop(props, outputs_dirname, progress + models_executed, resuming); seresult->status_message = (char*) simengine_errors[seresult->status]; // Copy the final time from simulation for(modelid=0; modelid<models_per_batch; modelid++){ seresult->final_time[models_executed + modelid] = props->time[modelid]; // Time from the first solver } // Free all internal simulation memory and make sure that model_states has the final state values free_solver_props(props, model_states); // Copy state values back to state initial value structure for(modelid=0; modelid<models_per_batch; modelid++){ for(stateid=0;stateid<seint.num_states;stateid++){ seresult->final_states[AS_IDX(seint.num_states, num_models, stateid, models_executed + modelid)] = model_states[TARGET_IDX(seint.num_states, PARALLEL_MODELS, stateid, modelid)]; } } } close_progress_file(progress, progress_fd, num_models); clean_up_output_buffers(output_fd); return seresult; }
int main(void) { //CTIMER_DECLARE(); #if 0 uint32_t memory = SRAM1_LOC; uint32_t lut = SRAM1_LOC; //while(1); memset((void *)QQ_LOC, 0x01, 0x3000); g_qqueue->writeIndex = 0; g_qqueue->produced = 0; g_qqueue->consumed = 0; while(1) getRLSFrame(&memory, &lut); #endif #if 0 int i = 0x12345678; foo(&i); printf("%d\n", i); while(1); #endif #if 0 int i; uint32_t lut = SRAM1_LOC; uint32_t memory = SRAM1_LOC+0x1000; uint8_t *plut = (uint8_t *)lut; for (i=0; i<0x4000; i++) plut[i] = i%5==0 ? 1 : 0; while(1) getRLSFrame(&memory, &lut); #endif #if 1 printf("M0 start\n"); chirpOpen(); exec_init(); frame_init(); rls_init(); //printf("M0 ready\n"); exec_loop(); #endif #if 0 while(1) { CTIMER_START(); syncM1((uint32_t *)&LPC_GPIO_PORT->PIN[1], 0x2000); CTIMER_STOP(); printf("%d\n", CTIMER_GET()); } #endif #if 0 { uint32_t i; uint8_t *lut = (uint8_t *)SRAM1_LOC + 0x10000; uint32_t memory = SRAM1_LOC; uint32_t size = SRAM1_SIZE/2; for (i=0; i<0x10000; i++) lut[i] = 0; lut[0xb400] = 0; lut[0xb401] = 1; lut[0xb402] = 1; lut[0xb403] = 1; lut[0xb404] = 0; lut[0xb405] = 1; lut[0xb406] = 1; lut[0xb407] = 0; lut[0xb408] = 0; lut[0xb409] = 0; while(1) getRLSFrame(&memory, &size); //, (uint32_t *)&lut); } #endif }
// simEngine API: simengine_runmodel() // // executes the model for the given parameters, states and simulation time EXTERN_C simengine_result *simengine_runmodel(double start_time, double stop_time, unsigned int num_models, double *inputs, double *states, simengine_alloc *alloc){ CDATAFORMAT model_states[PARALLEL_MODELS * NUM_STATES]; CDATAFORMAT parameters[PARALLEL_MODELS * NUM_INPUTS]; unsigned int stateid; unsigned int modelid; unsigned int inputid; unsigned int outputid; int models_executed; int models_per_batch; // Seed the entropy source seed_entropy_with_time(); // Set up allocation functions if(alloc){ se_alloc.malloc = alloc->malloc; se_alloc.realloc = alloc->realloc; se_alloc.free = alloc->free; } // Create result structure simengine_result *seresult = (simengine_result*)se_alloc.malloc(sizeof(simengine_result)); // Couldn't allocate return structure, return NULL if(!seresult) return NULL; // Allocate return structures if(seint.num_outputs){ seresult->outputs = (simengine_output*)se_alloc.malloc(num_models * seint.num_outputs * sizeof(simengine_output)); } else{ seresult->outputs = NULL; } if(seint.num_states){ seresult->final_states = (double*)se_alloc.malloc(num_models * seint.num_states * sizeof(double)); } else{ seresult->final_states = NULL; } seresult->final_time = (double*)se_alloc.malloc(num_models * sizeof(double)); if((seint.num_outputs && !seresult->outputs) || (seint.num_states && !seresult->final_states) ||!seresult->final_time){ seresult->status = ERRMEM; seresult->status_message = (char*) simengine_errors[ERRMEM]; seresult->outputs = NULL; seresult->final_states = NULL; seresult->final_time = NULL; return seresult; } // Run the parallel simulation repeatedly until all requested models have been executed for(models_executed = 0 ; models_executed < num_models; models_executed += PARALLEL_MODELS){ models_per_batch = MIN(num_models - models_executed, PARALLEL_MODELS); // Copy inputs and state initial values to internal representation for(modelid=0; modelid<models_per_batch; modelid++){ for(stateid=0;stateid<seint.num_states;stateid++){ model_states[TARGET_IDX(seint.num_states, PARALLEL_MODELS, stateid, modelid)] = states[AS_IDX(seint.num_states, num_models, stateid, models_executed + modelid)]; } for(inputid=0;inputid<seint.num_inputs;inputid++){ parameters[TARGET_IDX(seint.num_inputs, PARALLEL_MODELS, inputid, modelid)] = inputs[AS_IDX(seint.num_inputs, num_models, inputid, models_executed + modelid)]; } } // Initialization of output structures for (modelid = 0; modelid < models_per_batch; ++modelid) { for (outputid = 0; outputid < seint.num_outputs; ++outputid) { seresult->outputs[AS_IDX(seint.num_outputs, num_models, outputid, models_executed + modelid)].alloc = START_SIZE; seresult->outputs[AS_IDX(seint.num_outputs, num_models, outputid, models_executed + modelid)].num_quantities = seint.output_num_quantities[outputid]; seresult->outputs[AS_IDX(seint.num_outputs, num_models, outputid, models_executed + modelid)].num_samples = 0; seresult->outputs[AS_IDX(seint.num_outputs, num_models, outputid, models_executed + modelid)].data = (double*)se_alloc.malloc(START_SIZE*seint.output_num_quantities[outputid]*sizeof(double)); } } // Initialize the solver properties and internal simulation memory structures solver_props *props = init_solver_props(start_time, stop_time, models_per_batch, parameters, model_states, &seresult->outputs[AS_IDX(seint.num_outputs, num_models, 0, models_executed)]); // Run the model seresult->status = exec_loop(props); seresult->status_message = (char*) simengine_errors[seresult->status]; // Copy the final time from simulation for(modelid=0; modelid<models_per_batch; modelid++){ seresult->final_time[models_executed + modelid] = props->time[modelid]; // Time from the first solver } // Free all internal simulation memory and make sure that model_states has the final state values free_solver_props(props, model_states); // Copy state values back to state initial value structure for(modelid=0; modelid<models_per_batch; modelid++){ for(stateid=0;stateid<seint.num_states;stateid++){ seresult->final_states[AS_IDX(seint.num_states, num_models, stateid, models_executed + modelid)] = model_states[TARGET_IDX(seint.num_states, PARALLEL_MODELS, stateid, modelid)]; } } } return seresult; }
int main(void) { uint16_t major, minor, build; char *type; int i, res, count, count2; volatile uint32_t d; // insert a small delay so power supply can stabilize for (d=0; d<2500000; d++); #ifdef KEIL pixyInit(SRAM3_LOC, &LR0[0], sizeof(LR0)); #else pixyInit(); #endif #if 0 i = 0; char *foo; while(1) { foo = new (std::nothrow) char[128]; if (foo==NULL) { _DBG("full\n"); break; } else { _DBH32((int)foo); _DBG(" "); _DBH32(i); _DBG("\n"); } i++; } while(1); #endif // main init of hardware plus a version-dependent number for the parameters that will // force a format of parameter between version numbers. #ifndef LEGO rcs_init(); #endif cc_init(g_chirpUsb); ser_init(); exec_init(g_chirpUsb); #if 0 exec_addProg(&g_progBlobs); ptLoadParams(); exec_addProg(&g_progPt); exec_addProg(&g_progVideo, true); #if 0 cam_setMode(CAM_MODE1); while(1) periodic(); #endif #endif #if 1 // load programs exec_addProg(&g_progBlobs); #ifndef LEGO // need to call this to get the pan/tilt parameters to display. // We can make some properties modal, meaning they are only diaplayed when the program is running. // We might want to do this here, but this is good for now. ptLoadParams(); exec_addProg(&g_progPt); #endif #if 0 chaseLoadParams(); exec_addProg(&g_progChase); #endif exec_addProg(&g_progVideo, true); #if 1 // this code formats if the version has changed for (i=0, count=0, count2=0; i<25; i++) { res = prm_get("fwver", &major, &minor, &build, END); if (res>=0 && major==FW_MAJOR_VER && minor==FW_MINOR_VER && build==FW_BUILD_VER) count++; res = prm_get("fwtype", &type, END); if (res>=0 && strcmp(type, FW_TYPE)==0) count2++; } if (count==0 || count2==0) prm_format(); #endif // check version prm_add("fwver", PRM_FLAG_INTERNAL, "", UINT16(FW_MAJOR_VER), UINT16(FW_MINOR_VER), UINT16(FW_BUILD_VER), END); prm_add("fwtype", PRM_FLAG_INTERNAL, "", STRING(FW_TYPE), END); exec_loop(); #endif #if 0 #define DELAY 1000000 rcs_setFreq(100); rcs_setLimits(0, -200, 200); rcs_setLimits(1, -200, 200); while(1) { rcs_setPos(0, 0); delayus(DELAY); rcs_setPos(0, 500); delayus(DELAY); rcs_setPos(0, 1000); delayus(DELAY); rcs_setPos(1, 0); delayus(DELAY); rcs_setPos(1, 500); delayus(DELAY); rcs_setPos(1, 1000); delayus(DELAY); } #endif #if 0 while(1) { g_chirpUsb->service(); handleButton(); } #endif }