// // Loader Interface // int create(void) { if (!states) { states = kh_init(m32); } lua_State* l = luaL_newstate(); openlualibs(l); regluafuncs(l); struct instance *inst = instance_init(l); // Find an unused key int ret = 0; int id = -1; khint_t key; do { id = _nextid++; key = kh_put(m32, states, id, &ret); } while (0 == ret); if (ret > 0) { kh_value(states, key) = inst; return id; } else { return 0; } }
static void service_instance_add(struct service *s, struct blob_attr *attr) { struct service_instance *in; if (blobmsg_type(attr) != BLOBMSG_TYPE_TABLE) return; in = calloc(1, sizeof(*in)); if (!in) return; instance_init(in, s, attr); vlist_add(&s->instances, &in->node, (void *) in->name); }
static void nv50_draw_arrays_instanced(struct pipe_context *pipe, unsigned mode, unsigned start, unsigned count, unsigned startInstance, unsigned instanceCount) { struct nv50_context *nv50 = nv50_context(pipe); struct nouveau_channel *chan = nv50->screen->tesla->channel; struct nouveau_grobj *tesla = nv50->screen->tesla; struct instance a[16]; unsigned prim = nv50_prim(mode); instance_init(nv50, a, startInstance); if (!nv50_state_validate(nv50, 10 + 16*3)) return; if (nv50->vbo_fifo) { nv50_push_elements_instanced(pipe, NULL, 0, 0, mode, start, count, startInstance, instanceCount); return; } BEGIN_RING(chan, tesla, NV50TCL_CB_ADDR, 2); OUT_RING (chan, NV50_CB_AUX | (24 << 8)); OUT_RING (chan, startInstance); while (instanceCount--) { if (AVAIL_RING(chan) < (7 + 16*3)) { FIRE_RING(chan); if (!nv50_state_validate(nv50, 7 + 16*3)) { assert(0); return; } } instance_step(nv50, a); BEGIN_RING(chan, tesla, NV50TCL_VERTEX_BEGIN, 1); OUT_RING (chan, prim); BEGIN_RING(chan, tesla, NV50TCL_VERTEX_BUFFER_FIRST, 2); OUT_RING (chan, start); OUT_RING (chan, count); BEGIN_RING(chan, tesla, NV50TCL_VERTEX_END, 1); OUT_RING (chan, 0); prim |= (1 << 28); } }
static void init_global(global_t *g,int id) { if (id == 0) { #ifdef TIMELIMIT /* Starting time */ g->start = timeofday() ; #endif /* Global barrier */ barrier_init(&g->gb,AVAIL) ; /* Align to cache line */ uintptr_t x = (uintptr_t)(g->mem) ; x += LINE-1 ; x /= LINE ; x *= LINE ; intmax_t *m = (intmax_t *)x ; /* Instance contexts */ for (int k = 0 ; k < NEXE ; k++) { instance_init(&g->ctx[k],k,m) ; m += NVARS*LINESZ ; } mbar() ; g->go = 1 ; } else { while (g->go == 0) ; mbar() ; } }
int main(int argc, char *argv[]) { fcs_dbm_variant_type_t local_variant = FCS_DBM_VARIANT_2FC_FREECELL; const long delta_limit = 100000; const int max_num_elements_in_cache = 8000000; const char *filename = argv[1]; FILE *const fh = fopen(filename, "r"); if (fh == NULL) { fc_solve_err("Could not open file '%s' for input.\n", filename); } const fcs_user_state_str_t user_state = read_state(fh); fcs_state_keyval_pair_t init_state_pair; fc_solve_initial_user_state_to_c( user_state.s, &init_state_pair, FREECELLS_NUM, STACKS_NUM, 1, NULL); fcs_dbm_solver_instance_t instance; instance_init( &instance, local_variant, &init_state_pair, max_num_elements_in_cache); #define LOG_FILENAME "fc-solve-pseudo-dfs.log.txt" { FILE *const last_line_fh = popen(("tail -1 " LOG_FILENAME), "r"); if (last_line_fh) { long count_num_processed; if (fscanf(last_line_fh, "At %ld iterations Coords=[", &count_num_processed) == 1) { instance__load_coords_from_fh(&instance, last_line_fh); /* * instance__inspect_new_state increments count_num_processed * so let's set it after loading the coordinates. * */ instance.count_num_processed = count_num_processed; } } pclose(last_line_fh); } instance.max_count_num_processed = instance.count_num_processed + delta_limit; while (instance.max_count_num_processed % delta_limit != 0) { instance.max_count_num_processed += delta_limit - (instance.max_count_num_processed % delta_limit); } while (instance.should_terminate == DONT_TERMINATE) { instance_run(&instance); FILE *const log_fh = fopen(LOG_FILENAME, "at"); instance__print_coords_to_log(&instance, log_fh); fclose(log_fh); instance.max_count_num_processed = instance.count_num_processed + delta_limit; } if (instance.should_terminate == SOLUTION_FOUND_TERMINATE) { printf("%s\n", "Solution was found."); } else { printf("%s\n", "I could not solve it."); } instance_free(&instance); return 0; }
uint32 inittestapplication(void) { uint32 devID; instanceConfig_t instConfig; int i, result; SPI_ConfigFastRate(SPI_BaudRatePrescaler_16); //max SPI before PLLs configured is ~4M i = 10; //this is called here to wake up the device (i.e. if it was in sleep mode before the restart) devID = instancereaddeviceid(); printf("devID %08X\r\n", devID); //if the read of devide ID fails, the DW1000 could be asleep if (DWT_DEVICE_ID != devID) { // port_SPIx_clear_chip_select(); //CS low // Sleep(1); //200 us to wake up then waits 5ms for DW1000 XTAL to stabilise // port_SPIx_set_chip_select(); //CS high // Sleep(7); printf("asleep...wakeup!\r\n"); pio_set_pin_high(DW_WAKEUP_PIO_IDX); Sleep(1); pio_set_pin_low(DW_WAKEUP_PIO_IDX); Sleep(7); devID = instancereaddeviceid(); printf("devID %08X\r\n", devID); // SPI not working or Unsupported Device ID if (DWT_DEVICE_ID != devID) { return (-1); } //clear the sleep bit - so that after the hard reset below the DW does not go into sleep dwt_softreset(); } //reset the DW1000 by driving the RSTn line low reset_DW1000(); result = instance_init(); if (0 > result) return (-2); // Some failure has occurred SPI_ConfigFastRate(SPI_BaudRatePrescaler_4); //increase SPI to max devID = instancereaddeviceid(); printf("devID %08X\r\n", devID); if (DWT_DEVICE_ID != devID) // Means it is NOT MP device { // SPI not working or Unsupported Device ID return (-3); } if (is_tag) { instance_mode = TAG; led_on(LED_PC7); } else { instance_mode = ANCHOR; #if (DR_DISCOVERY == 1) led_on(LED_PC6); #else if(instance_anchaddr & 0x1) led_on(LED_PC6); if(instance_anchaddr & 0x2) led_on(LED_PC7); #endif } instancesetrole(instance_mode); // Set this instance role if (use_fast2wr) //if fast ranging then initialise instance for fast ranging application { instance_init_f(instance_mode); //initialise Fast 2WR specific data //when using fast ranging the channel config is either mode 2 or mode 6 //default is mode 2 dr_mode = decarangingmode(); if ((dr_mode & 0x1) == 0) dr_mode = 1; } else { instance_init_s(instance_mode); dr_mode = decarangingmode(); } instConfig.channelNumber = chConfig[dr_mode].channel; instConfig.preambleCode = chConfig[dr_mode].preambleCode; instConfig.pulseRepFreq = chConfig[dr_mode].prf; instConfig.pacSize = chConfig[dr_mode].pacSize; instConfig.nsSFD = chConfig[dr_mode].nsSFD; instConfig.sfdTO = chConfig[dr_mode].sfdTO; instConfig.dataRate = chConfig[dr_mode].datarate; instConfig.preambleLen = chConfig[dr_mode].preambleLength; instance_config(&instConfig); // Set operating channel etc #if (DR_DISCOVERY == 0) addressconfigure(); // set up initial payload configuration #endif instancesettagsleepdelay(POLL_SLEEP_DELAY, BLINK_SLEEP_DELAY); //set the Tag sleep time //if TA_SW1_2 is on use fast ranging (fast 2wr) if (use_fast2wr) { //Fast 2WR specific config //configure the delays/timeouts instance_config_f(); } else //use default ranging modes { // NOTE: this is the delay between receiving the blink and sending the ranging init message // The anchor ranging init response delay has to match the delay the tag expects // the tag will then use the ranging response delay as specified in the ranging init message // use this to set the long blink response delay (e.g. when ranging with a PC anchor that wants to use the long response times != 150ms) if (use_long_blink_delay) { instancesetblinkreplydelay(FIXED_LONG_BLINK_RESPONSE_DELAY); } else //this is for ARM to ARM tag/anchor (using normal response times 150ms) { instancesetblinkreplydelay(FIXED_REPLY_DELAY); } //set the default response delays instancesetreplydelay(FIXED_REPLY_DELAY, 0); } // return devID; return 0; }
uint32 inittestapplication(uint8 s1switch) { uint32 devID ; instanceConfig_t instConfig; int result; SPI_ConfigFastRate(SPI_BaudRatePrescaler_32); //max SPI before PLLs configured is ~4M //this is called here to wake up the device (i.e. if it was in sleep mode before the restart) devID = instancereaddeviceid() ; if(DWT_DEVICE_ID != devID) //if the read of device ID fails, the DW1000 could be asleep { port_SPIx_clear_chip_select(); //CS low Sleep(1); //200 us to wake up then waits 5ms for DW1000 XTAL to stabilise port_SPIx_set_chip_select(); //CS high Sleep(7); devID = instancereaddeviceid() ; // SPI not working or Unsupported Device ID if(DWT_DEVICE_ID != devID) return(-1) ; //clear the sleep bit - so that after the hard reset below the DW does not go into sleep dwt_softreset(); } //reset the DW1000 by driving the RSTn line low reset_DW1000(); result = instance_init() ; if (0 > result) return(-1) ; // Some failure has occurred SPI_ConfigFastRate(SPI_BaudRatePrescaler_4); //increase SPI to max devID = instancereaddeviceid() ; if (DWT_DEVICE_ID != devID) // Means it is NOT MP device { // SPI not working or Unsupported Device ID return(-1) ; } if(s1switch & SWS1_ANC_MODE) { instance_mode = ANCHOR; led_on(LED_PC6); } else { instance_mode = TAG; led_on(LED_PC7); } instancesetrole(instance_mode) ; // Set this instance role instance_init_s(instance_mode); dr_mode = decarangingmode(s1switch); instConfig.channelNumber = chConfig[dr_mode].channel ; instConfig.preambleCode = chConfig[dr_mode].preambleCode ; instConfig.pulseRepFreq = chConfig[dr_mode].prf ; instConfig.pacSize = chConfig[dr_mode].pacSize ; instConfig.nsSFD = chConfig[dr_mode].nsSFD ; instConfig.sfdTO = chConfig[dr_mode].sfdTO ; instConfig.dataRate = chConfig[dr_mode].datarate ; instConfig.preambleLen = chConfig[dr_mode].preambleLength ; instance_config(&instConfig) ; // Set operating channel etc instancesettagsleepdelay(POLL_SLEEP_DELAY, BLINK_SLEEP_DELAY); //set the Tag sleep time instance_init_timings(); return devID; }
int main(int argc , char ** argv) { int ret; int i; struct config_instance_t * inst; char dir_name[128]; if( argc != 7 || str_unequal(argv[1] , "-p") || file_unexist(argv[2]) || str_unequal(argv[3] , "-t") || isnotnumber(argv[4]) || str_unequal(argv[5] , "-c") ){ usage(); exit(0); } resource_init(); sprintf(sync_work_dir , "%s" , argv[2]); sync_period = atoi(argv[4]); sprintf(config_file , "%s" , argv[6]); memset(dir_name, 0, 128); sprintf(dir_name, "%s/lock/", sync_work_dir); if (access(dir_name, F_OK)){ ret = mkdir(dir_name, 0777); if (ret < 0){ print_error("Create directory %s error" , dir_name); return ret; } } memset(dir_name, 0, 128); sprintf(dir_name, "%s/send/", sync_work_dir); if (access(dir_name, F_OK)){ ret = mkdir(dir_name, 0777); if (ret < 0){ print_error("Create directory %s error" , dir_name); return ret; } } ret = config_init(config_file); if(ret < 0){ print_error("config file init fail\n"); exit(0); } for(i = 0 ; i < INSTANCE_MAX_CNT ; i++){ inst = instance_base + i; if(inst->use == 0) continue; instance_init(inst); } while(1){ sleep(3600); } return(0); }