void DestroyGrid (long my_id, time_info *local_time, long time_all) { box *b_scan, *tb; particle *p; long i; long particle_cost; unsigned long start = 0, finish; if (time_all) CLOCK(start); b_scan = Local[my_id].Childless_Partition; MY_NUM_PARTICLES = 0; while (b_scan != NULL) { tb = b_scan; b_scan = b_scan->next; particle_cost = tb->cost / tb->num_particles; for (i = 0; i < tb->num_particles; i++) { if (MY_MAX_PARTICLES <= MY_NUM_PARTICLES) { LockedPrint("ERROR (P%d) : Too many particles in local array\n", my_id); exit(-1); } p = tb->particles[i]; p->cost = particle_cost; MY_PARTICLES[MY_NUM_PARTICLES++] = p; } } if (my_id == 0) Grid = NULL; if (time_all) { CLOCK(finish); local_time[MY_TIME_STEP].other_time += finish - start; } }
void display_other_heuristics(tm_topology_t *topology,int N,double **comm,double **arch){ CLOCK_T time1,time0; double duration; int *sol; sol=(int*)malloc(sizeof(int)*N); map_Packed(topology,N,sol); printf("Packed: "); print_sol(N,sol,comm,arch); map_RR(N,sol); printf("RR: "); print_sol(N,sol,comm,arch); CLOCK(time0); map_MPIPP(topology,1,N,sol,comm,arch); CLOCK(time1); duration=CLOCK_DIFF(time1,time0); printf("MPIPP-1-D:%f\n",duration); printf("MPIPP-1: "); print_sol(N,sol,comm,arch); CLOCK(time0); map_MPIPP(topology,5,N,sol,comm,arch); CLOCK(time1); duration=CLOCK_DIFF(time1,time0); printf("MPIPP-5-D:%f\n",duration); printf("MPIPP-5: "); print_sol(N,sol,comm,arch); free(sol); }
void firmware() { display_init(); gfx_init_ctxt(&gfx_ctxt, display_init_framebuffer(), 720, 1280, 768); gfx_clear_color(&gfx_ctxt, 0xFF000000); gfx_con_init(&gfx_con, &gfx_ctxt); gfx_con_setcol(&gfx_con, DEFAULT_TEXT_COL, 0, 0); while (!sdMount()) { error("Failed to init SD card!\n"); print("Press POWER to power off, any other key to retry\n"); if (btn_wait() & BTN_POWER) i2c_send_byte(I2C_5, 0x3C, MAX77620_REG_ONOFFCNFG1, MAX77620_ONOFFCNFG1_PWR_OFF); btn_wait(); } if(PMC(APBDEV_PMC_SCRATCH49) != 69 && fopen("/ReiNX.bin", "rb")) { fread((void*)PAYLOAD_ADDR, fsize(), 1); fclose(); sdUnmount(); display_end(); CLOCK(CLK_RST_CONTROLLER_CLK_OUT_ENB_V) |= 0x400; // Enable AHUB clock. CLOCK(CLK_RST_CONTROLLER_CLK_OUT_ENB_Y) |= 0x40; // Enable APE clock. PMC(APBDEV_PMC_SCRATCH49) = 69; ((void (*)())PAYLOAD_ADDR)(); } SYSREG(AHB_AHB_SPARE_REG) = (volatile vu32)0xFFFFFF9F; PMC(APBDEV_PMC_SCRATCH49) = 0; print("Welcome to ReiNX %s!\n", VERSION); loadFirm(); drawSplash(); launch(); }
void PalEvidence(char* tpal,char* pal) { const int SPEED = 4; int log = 1,i; int t; while(log) { t = CLOCK(); while(CLOCK() < t + 1); log = 0; for(i = 0; i < 256; i++) { tpal[3*i + 0] += SPEED; tpal[3*i + 1] += SPEED; tpal[3*i + 2] += SPEED; if(tpal[3*i + 0] >= pal[3*i + 0]) tpal[3*i + 0] = pal[3*i + 0]; else log = 1; if(tpal[3*i + 1] >= pal[3*i + 1]) tpal[3*i + 1] = pal[3*i + 1]; else log = 1; if(tpal[3*i + 2] >= pal[3*i + 2]) tpal[3*i + 2] = pal[3*i + 2]; else log = 1; } XGR_SetPal(tpal,0,255); XGR_Flush(0,0,XGR_MAXX,XGR_MAXY); xtClearMessageQueue(); } }
int main(int argc, char **argv) { int n,i,j; double **a; double *b, count=1.0; unsigned int t1,t2; MAIN_INITENV if (argc!=2) { printf("Usage: bksb <size>\nAborting...\n"); exit(0); } n = atoi(argv[1]); a = (double**)G_MALLOC(n*sizeof(double*)); for(i = 0; i < n; i++) { a[i] = (double*)G_MALLOC(n*sizeof(double)); for(j = i;j < n;j++) { a[i][j] = count; count++; } } b = (double*)G_MALLOC(n*sizeof(double)); for(i = 0; i < n; i++) { b[i] = count; count++; } CLOCK(t1) bksb(a,b,n); CLOCK(t2) printf("Elapsed: %u microseconds\n",t2-t1); for(i = 0; i < n; i++) printf("%lf ", b[i]); printf("\n"); MAIN_END return 0; }
void clock_disable(const clock_t *clk) { //Put clock into reset. CLOCK(clk->reset) = (CLOCK(clk->reset) & ~(1 << clk->index)) | (1 << clk->index); //Disable. CLOCK(clk->enable) &= ~(1 << clk->index); }
void mc_enable_ahb_redirect() { CLOCK(0x3A4) = CLOCK(0x3A4) & 0xFFF7FFFF | 0x80000; //MC(MC_IRAM_REG_CTRL) &= 0xFFFFFFFE; MC(MC_IRAM_BOM) = 0x40000000; MC(MC_IRAM_TOM) = 0x4003F000; }
void ConstructGrid (long my_id, time_info *local_time, long time_all) { unsigned long init = 0, start = 0, finish; if (time_all) CLOCK(init); DetermineGridSize(my_id); /* Finds the four corners of the grid. */ FreeBoxes(my_id); InitPartition(my_id); if (time_all) CLOCK(start); if (MY_NUM_PARTICLES > 0) { ConstructLocalGrid(my_id); /* Each processor constructs their own tree based on only their particles */ MergeLocalGrid(my_id); /* The processors combine their trees into one global tree. This step contains communication between processors. */ } BARRIER(G_Memory->synch, Number_Of_Processors); CleanupGrid(my_id); if (time_all) CLOCK(finish); if (time_all) { local_time[MY_TIME_STEP].other_time = start - init; local_time[MY_TIME_STEP].construct_time = finish - start; } }
int main (int argc, string argv[]) #endif { #ifndef SIM_SOCLIB long c; while ((c = getopt(argc, argv, "h")) != -1) { switch(c) { case 'h': Help(); exit(-1); break; default: fprintf(stderr, "Only valid option is \"-h\".\n"); exit(-1); break; } } #endif Global = NULL; initparam(defv); startrun(); initoutput(); tab_init(); Global->tracktime = 0; Global->partitiontime = 0; Global->treebuildtime = 0; Global->forcecalctime = 0; Global->current_id = 0; CLOCK(Global->computestart); printf("COMPUTESTART = %12lu\n",Global->computestart); CREATE(SlaveStart, NPROC); WAIT_FOR_END(NPROC); CLOCK(Global->computeend); printf("COMPUTEEND = %12lu\n",Global->computeend); printf("COMPUTETIME = %12lu\n",Global->computeend - Global->computestart); printf("TRACKTIME = %12lu\n",Global->tracktime); printf("PARTITIONTIME = %12lu\t%5.2f\n",Global->partitiontime, ((float)Global->partitiontime)/Global->tracktime); printf("TREEBUILDTIME = %12lu\t%5.2f\n",Global->treebuildtime, ((float)Global->treebuildtime)/Global->tracktime); printf("FORCECALCTIME = %12lu\t%5.2f\n",Global->forcecalctime, ((float)Global->forcecalctime)/Global->tracktime); printf("RESTTIME = %12lu\t%5.2f\n", Global->tracktime - Global->partitiontime - Global->treebuildtime - Global->forcecalctime, ((float)(Global->tracktime-Global->partitiontime- Global->treebuildtime-Global->forcecalctime))/ Global->tracktime); MAIN_END; }
int main(int argc,char **argv) { int i,j,p,n; double **a,*b, count=1.0; unsigned int t1,t2; MAIN_INITENV if (argc!=3) { printf("Usage: pbksb P N\nAborting...\n"); exit(0); } gm = (GM*)G_MALLOC(sizeof(GM)); p = gm->p = atoi(argv[1]); gm->n = atoi(argv[2]); assert(p > 0); assert(p <= 8); n = gm->n; a = gm->a = (double**)G_MALLOC(n*sizeof(double*)); for(i = 0; i < n; i++) { a[i] = (double*)G_MALLOC(n*sizeof(double)); for(j = i;j < n;j++){ a[i][j] = count; count++; } } //----------------------------------------------- // Create 1D array a_prime and map a to a_prime //----------------------------------------------- gm->a_prime = (double*)G_MALLOC((n+1)*n/2*sizeof(double)) mapping(); b = gm->b = (double*)G_MALLOC(n*sizeof(double)); for(i = 0; i < n; i++) { b[i] = count; count++; } gm->pse = (char*)G_MALLOC(n*sizeof(char)); for(i = 0; i < n; i++) CLEARPAUSE(gm->pse[i]) for(i = 0; i < p-1; i++) CREATE(pbksb) CLOCK(t1) pbksb(); WAIT_FOR_END(p-1) CLOCK(t2) printf("Elapsed: %u us\n",t2-t1); for(i = 0; i < n; i++) printf("%lf ", gm->b[i]); printf("\n"); for(i = 0; i < n; i++) G_FREE(a[i],n*sizeof(double)) G_FREE(a,n*sizeof(double*)) G_FREE(b,n*sizeof(double)) G_FREE(gm->a_prime, (n+1)*n/2*sizeof(double)) MAIN_END return 0; }
void CServer::DoPulse() { UNCLOCK( "Top", "Other" ); if ( m_pGame ) { CLOCK( "Top", "Game->DoPulse" ); m_pGame->DoPulse (); UNCLOCK( "Top", "Game->DoPulse" ); } CLOCK( "Top", "Other" ); }
void PartitionGrid (long my_id, time_info *local_time, long time_all) { unsigned long start = 0, finish; if (time_all) CLOCK(start); if (Partition_Flag == COST_ZONES) CostZones(my_id); if (time_all) { CLOCK(finish); local_time[MY_TIME_STEP].partition_time = finish - start; } }
static void _clock_sdmmc_clear_reset(u32 id) { switch (id) { case SDMMC_1: CLOCK(CLK_RST_CONTROLLER_RST_DEV_L_CLR) = L_CLR_SDMMC1_RST; case SDMMC_2: CLOCK(CLK_RST_CONTROLLER_RST_DEV_L_CLR) = L_CLR_SDMMC2_RST; case SDMMC_3: CLOCK(CLK_RST_CONTROLLER_RST_DEV_U_CLR) = U_CLR_SDMMC3_RST; case SDMMC_4: CLOCK(CLK_RST_CONTROLLER_RST_DEV_L_CLR) = L_CLR_SDMMC4_RST; } }
static void _clock_sdmmc_clear_enable(u32 id) { switch (id) { case SDMMC_1: CLOCK(CLK_RST_CONTROLLER_CLK_ENB_L_CLR) = L_CLR_CLK_ENB_SDMMC1; case SDMMC_2: CLOCK(CLK_RST_CONTROLLER_CLK_ENB_L_CLR) = L_CLR_CLK_ENB_SDMMC2; case SDMMC_3: CLOCK(CLK_RST_CONTROLLER_CLK_ENB_U_CLR) = U_CLR_CLK_ENB_SDMMC3; case SDMMC_4: CLOCK(CLK_RST_CONTROLLER_CLK_ENB_L_CLR) = L_CLR_CLK_ENB_SDMMC4; } }
static int _clock_sdmmc_is_reset(u32 id) { switch (id) { case SDMMC_1: return CLOCK(CLK_RST_CONTROLLER_RST_DEVICES_L) & L_SWR_SDMMC1_RST; case SDMMC_2: return CLOCK(CLK_RST_CONTROLLER_RST_DEVICES_L) & L_SWR_SDMMC2_RST; case SDMMC_3: return CLOCK(CLK_RST_CONTROLLER_RST_DEVICES_U) & U_SWR_SDMMC3_RST; case SDMMC_4: return CLOCK(CLK_RST_CONTROLLER_RST_DEVICES_L) & L_SWR_SDMMC4_RST; } return 0; }
static int _clock_sdmmc_is_enabled(u32 id) { switch (id) { case SDMMC_1: return CLOCK(CLK_RST_CONTROLLER_CLK_OUT_ENB_L) & L_CLK_ENB_SDMMC1; case SDMMC_2: return CLOCK(CLK_RST_CONTROLLER_CLK_OUT_ENB_L) & L_CLK_ENB_SDMMC2; case SDMMC_3: return CLOCK(CLK_RST_CONTROLLER_CLK_OUT_ENB_U) & U_CLK_ENB_SDMMC3; case SDMMC_4: return CLOCK(CLK_RST_CONTROLLER_CLK_OUT_ENB_L) & L_CLK_ENB_SDMMC4; } return 0; }
void mc_enable() { CLOCK(CLK_RST_CONTROLLER_CLK_SOURCE_EMC) = CLOCK(CLK_RST_CONTROLLER_CLK_SOURCE_EMC) & 0x1FFFFFFF | 0x40000000; //Enable MIPI CAL clock. CLOCK(CLK_RST_CONTROLLER_CLK_ENB_H_SET) = CLOCK(CLK_RST_CONTROLLER_CLK_ENB_H_SET) & 0xFDFFFFFF | 0x2000000; //Enable MC clock. CLOCK(CLK_RST_CONTROLLER_CLK_ENB_H_SET) = CLOCK(CLK_RST_CONTROLLER_CLK_ENB_H_SET) & 0xFFFFFFFE | 1; //Enable EMC DLL clock. CLOCK(CLK_RST_CONTROLLER_CLK_ENB_X_SET) = CLOCK(CLK_RST_CONTROLLER_CLK_ENB_X_SET) & 0xFFFFBFFF | 0x4000; CLOCK(CLK_RST_CONTROLLER_RST_DEV_H_SET) = 0x2000001; //Clear EMC and MC reset. sleep(5); }
void acorn_vib_device::device_add_mconfig(machine_config &config) { INPUT_MERGER_ANY_HIGH(config, m_irqs).output_handler().set(FUNC(acorn_vib_device::irq_w)); VIA6522(config, m_via6522, XTAL(1'000'000)); m_via6522->writepa_handler().set("cent_data_out", FUNC(output_latch_device::bus_w)); m_via6522->ca2_handler().set(m_centronics, FUNC(centronics_device::write_strobe)); m_via6522->irq_handler().set(m_irqs, FUNC(input_merger_device::in_w<0>)); CENTRONICS(config, m_centronics, centronics_devices, "printer"); m_centronics->ack_handler().set(m_via6522, FUNC(via6522_device::write_ca1)); m_centronics->busy_handler().set(m_via6522, FUNC(via6522_device::write_pa7)); output_latch_device ¢_data_out(OUTPUT_LATCH(config, "cent_data_out")); m_centronics->set_output_latch(cent_data_out); I8255(config, m_ppi8255, 0); ACIA6850(config, m_acia, 0); m_acia->txd_handler().set(m_rs232, FUNC(rs232_port_device::write_txd)); m_acia->rts_handler().set(m_rs232, FUNC(rs232_port_device::write_rts)); m_acia->irq_handler().set(m_irqs, FUNC(input_merger_device::in_w<1>)); RS232_PORT(config, m_rs232, default_rs232_devices, nullptr); m_rs232->rxd_handler().set(m_acia, FUNC(acia6850_device::write_rxd)); m_rs232->cts_handler().set(m_acia, FUNC(acia6850_device::write_cts)); m_rs232->dcd_handler().set(m_acia, FUNC(acia6850_device::write_dcd)); CLOCK(config, m_acia_clock, 1.8432_MHz_XTAL); m_acia_clock->signal_handler().set(FUNC(acorn_vib_device::write_acia_clock)); }
void selz80_state::selz80(machine_config &config) { /* basic machine hardware */ Z80(config, m_maincpu, XTAL(4'000'000)); // it's actually a 5MHz XTAL with a NEC uPD780C-1 cpu m_maincpu->set_addrmap(AS_PROGRAM, &selz80_state::selz80_mem); m_maincpu->set_addrmap(AS_IO, &selz80_state::selz80_io); MCFG_MACHINE_RESET_OVERRIDE(selz80_state, selz80 ) /* video hardware */ config.set_default_layout(layout_selz80); /* Devices */ CLOCK(config, m_clock, 153600); m_clock->signal_handler().set("uart", FUNC(i8251_device::write_txc)); m_clock->signal_handler().append("uart", FUNC(i8251_device::write_rxc)); i8251_device &uart(I8251(config, "uart", 0)); uart.txd_handler().set("rs232", FUNC(rs232_port_device::write_txd)); uart.dtr_handler().set("rs232", FUNC(rs232_port_device::write_dtr)); uart.rts_handler().set("rs232", FUNC(rs232_port_device::write_rts)); rs232_port_device &rs232(RS232_PORT(config, "rs232", default_rs232_devices, nullptr)); rs232.rxd_handler().set("uart", FUNC(i8251_device::write_rxd)); rs232.dsr_handler().set("uart", FUNC(i8251_device::write_dsr)); rs232.cts_handler().set("uart", FUNC(i8251_device::write_cts)); i8279_device &kbdc(I8279(config, "i8279", 5000000 / 2)); // based on divider kbdc.out_sl_callback().set(FUNC(selz80_state::scanlines_w)); // scan SL lines kbdc.out_disp_callback().set(FUNC(selz80_state::digit_w)); // display A&B kbdc.in_rl_callback().set(FUNC(selz80_state::kbd_r)); // kbd RL lines kbdc.in_shift_callback().set_constant(1); // Shift key kbdc.in_ctrl_callback().set_constant(1); }
void idsa_state::idsa(machine_config &config) { /* basic machine hardware */ Z80(config, m_maincpu, XTAL(8'000'000) / 2); m_maincpu->set_addrmap(AS_PROGRAM, &idsa_state::maincpu_map); m_maincpu->set_addrmap(AS_IO, &idsa_state::maincpu_io_map); clock_device &irqclock(CLOCK(config, "irqclock", XTAL(8'000'000) / 4)); irqclock.signal_handler().set(FUNC(idsa_state::clock_w)); /* video hardware */ //config.set_default_layout() /* sound hardware */ genpin_audio(config); SPEAKER(config, "lspeaker").front_left(); SPEAKER(config, "rspeaker").front_right(); SP0256(config, m_speech, 3120000); // unknown variant m_speech->add_route(ALL_OUTPUTS, "lspeaker", 1.5); ay8910_device &aysnd1(AY8910(config, "aysnd1", 2000000)); // 2Mhz according to pinmame, schematic omits the clock line aysnd1.port_a_write_callback().set(FUNC(idsa_state::ay1_a_w)); aysnd1.port_b_write_callback().set(FUNC(idsa_state::ay1_b_w)); aysnd1.add_route(ALL_OUTPUTS, "lspeaker", 0.75); ay8910_device &aysnd2(AY8910(config, "aysnd2", 2000000)); aysnd2.port_a_write_callback().set(FUNC(idsa_state::ay2_a_w)); aysnd2.port_b_write_callback().set(FUNC(idsa_state::ay2_b_w)); aysnd2.add_route(ALL_OUTPUTS, "rspeaker", 0.75); }
/************************************************************************************** * Function Name: pinPage * * Description: * Pin the page with the requested pageNum in the BUffer Pool * If the page is not in the Buffer Pool, load it from the file to the Buffer Pool * * Parameters: * BM_BufferPool * const bm: Buffer Pool Handler * BM_PageHandle * const page: Buffer Page Handler * PageNumber pageNum: the page number of the requested page * * Return: * RC: return code * * Author: * Jie Zhou <*****@*****.**> * * History: * Date Name Content * ---------- ---------------------------------- ---------------------------- * 2015-03-17 Jie Zhou <*****@*****.**> Initialization * 2015-03-20 Xin Su <*****@*****.**> Modify the logic of pinning the requested page * Add comments **************************************************************************************/ RC pinPage(BM_BufferPool * const bm, BM_PageHandle * const page, const PageNumber pageNum) { RC rc = -99; // init the return code if (bm->strategy == RS_FIFO) { rc = FIFO(bm, page, pageNum); // Because the searchPage() in the FIFO() returns a different return code (RC_PAGE_FOUND) // when it completes without errors from the return code (RC_OK) returned by appendPage() and replacePage(), // so it should be reset to RC_OK when searchPage() is executed and returned successfully if (rc == RC_PAGE_FOUND) { rc = RC_OK; } } else if (bm->strategy == RS_LRU) { rc = LRU(bm, page, pageNum); } else if (bm->strategy == RS_CLOCK) { rc = CLOCK(bm, page, pageNum); } else if (bm->strategy == RS_LFU) { // Replacement strategy is not implemented yet return RC_RS_NOT_IMPLEMENTED; } else if (bm->strategy == RS_LRU_K) { // Replacement strategy is not implemented yet return RC_RS_NOT_IMPLEMENTED; } return rc; } // pinPage
static void lookup_callback(isc_task_t *task, isc_event_t *ev) { client_t *client; client = ev->ev_arg; INSIST(client->find == ev->ev_sender); printf("NAME %s:\n\tTask %p got event %p type %08x from %p, client %p\n\terr4: %s err6: %s\n", client->target, task, ev, ev->ev_type, client->find, client, isc_result_totext(client->find->result_v4), isc_result_totext(client->find->result_v6)); isc_event_free(&ev); ev = NULL; CLOCK(); dns_adb_dumpfind(client->find, stderr); dns_adb_destroyfind(&client->find); ISC_LIST_UNLINK(clients, client, link); free_client(&client); CUNLOCK(); }
void z80ne_state::z80ne(machine_config &config) { /* basic machine hardware */ Z80(config, m_maincpu, Z80NE_CPU_SPEED_HZ); m_maincpu->set_addrmap(AS_PROGRAM, &z80ne_state::z80ne_mem); m_maincpu->set_addrmap(AS_IO, &z80ne_state::z80ne_io); MCFG_MACHINE_START_OVERRIDE(z80ne_state,z80ne) MCFG_MACHINE_RESET_OVERRIDE(z80ne_state,z80ne) AY31015(config, m_uart); CLOCK(config, m_uart_clock, 4800); m_uart_clock->signal_handler().set(FUNC(z80ne_state::lx385_uart_tx_clock_w)); m_uart_clock->signal_handler().append(m_uart, FUNC(ay31015_device::write_rcp)); CASSETTE(config, m_cassette1); m_cassette1->set_default_state(CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_ENABLED); m_cassette1->set_interface("z80ne_cass"); CASSETTE(config, m_cassette2); m_cassette2->set_default_state(CASSETTE_STOPPED | CASSETTE_MOTOR_ENABLED | CASSETTE_SPEAKER_ENABLED); m_cassette2->set_interface("z80ne_cass"); config.set_default_layout(layout_z80ne); /* internal ram */ RAM(config, m_ram).set_default_size("32K"); // all known tapes require LX.388 expansion //SOFTWARE_LIST(config, "cass_list").set_original("z80ne_cass"); }
int main (int argc, char **argv) { int i, j, p, n; int total; char **maxBoard; char **initialBoard; unsigned int t1, t2, t3; MAIN_INITENV //Enforce arguments if (argc != 2) { printf("Usage: nqueens-seq <N>\nAborting.\n"); exit(0); } gm = (GM*)G_MALLOC(sizeof(GM)); gm->p = 8; gm->n = atoi(argv[1]); n = gm->n; gm->total = 0; gm->maxBoard = (char**)G_MALLOC(n*sizeof(char*)); gm->initialBoard = (char**)G_MALLOC(n*sizeof(char*)); gm->global_max_profit = 0; for (i = 0; i < n; i++) { gm->maxBoard[i] = (char*)G_MALLOC(n*sizeof(char)); gm->initialBoard[i] = (char*)G_MALLOC(n*sizeof(char)); for (j = i; j < n; j++) { gm->maxBoard[i][j] = 0; gm->initialBoard[i][j] = 0; } } CLOCK(t1) for(i = 0; i < n; i++) CREATE(nqueens_wrapper) WAIT_FOR_END(n); CLOCK(t2) printf("Printing maximum profit board\n"); printBoard(gm->maxBoard, gm->global_max_profit); CLOCK(t3) printf("Computation time: %u microseconds\n", t2-t1); printf("Printing time: %u microseconds\n", t3-t2); MAIN_END return 0; }
VOID StartRayTrace() { INT pid; /* Our internal process id number. */ UINT begin; UINT end; THREAD_INIT_FREE(); LOCK(gm->pidlock) pid = gm->pid++; UNLOCK(gm->pidlock) BARINCLUDE(gm->start); if ((pid == 0) || (dostats)) CLOCK(begin); /* POSSIBLE ENHANCEMENT: Here's where one might lock processes down to processors if need be */ InitWorkPool(pid); InitRayTreeStack(Display.maxlevel, pid); /* * Wait for all processes to be created, initialize their work * pools, and arrive at this point; then proceed. This BARRIER * is absolutely required. Read comments in PutJob before * moving this barrier. */ BARRIER(gm->start, gm->nprocs) /* POSSIBLE ENHANCEMENT: Here's where one would RESET STATISTICS and TIMING if one wanted to measure only the parallel part */ // Reset Models CarbonEnableModels(); RayTrace(pid); if ((pid == 0) || (dostats)) { CLOCK(end); gm->partime[pid] = (end - begin) & 0x7FFFFFFF; if (pid == 0) gm->par_start_time = begin; } }
void mc_disable_ahb_redirect() { MC(MC_IRAM_BOM) = 0xFFFFF000; MC(MC_IRAM_TOM) = 0; //Disable IRAM_CFG_WRITE_ACCESS (sticky). //MC(MC_IRAM_REG_CTRL) = MC(MC_IRAM_REG_CTRL) & 0xFFFFFFFE | 1; CLOCK(0x3A4) &= 0xFFF7FFFF; }
void ConstructLists (long my_id, time_info *local_time, long time_all) { unsigned long start, finish; if (time_all) CLOCK(start); PartitionIterate(my_id, ConstructGridLists, TOP); BARRIER(G_Memory->synch, Number_Of_Processors); PartitionIterate(my_id, ConstructInteractionLists, BOTTOM); if (time_all) CLOCK(finish); if (time_all) { local_time[MY_TIME_STEP].list_time = finish - start; } }
void CPlayer::MaybeUpdateOthersNearList ( void ) { // If too long since last update if ( m_UpdateNearListTimer.Get () > (uint)g_TickRateSettings.iNearListUpdate * 9 / 10 ) { CLOCK( "RelayPlayerPuresync", "UpdateNearList_Timer" ); UpdateOthersNearList (); UNCLOCK( "RelayPlayerPuresync", "UpdateNearList_Timer" ); } else // or player has moved too far if ( ( m_vecUpdateNearLastPosition - GetPosition () ).LengthSquared () > MOVEMENT_UPDATE_THRESH * MOVEMENT_UPDATE_THRESH ) { CLOCK( "RelayPlayerPuresync", "UpdateNearList_Movement" ); UpdateOthersNearList (); UNCLOCK( "RelayPlayerPuresync", "UpdateNearList_Movement" ); } }
void get_time(){ clock_num++; if(clock_num>MAX_CLOCK-1) return; CLOCK(time_tab[clock_num]); }
void nx_hwinit() { enable_clocks(); clock_enable_se(); clock_enable_fuse(1); fuse_disable_program(); mc_enable(); config_oscillators(); _REG(0x70000000, 0x40) = 0; config_gpios(); clock_enable_i2c(I2C_1); clock_enable_i2c(I2C_5); clock_enable(&clock_unk1); clock_enable(&clock_unk2); i2c_init(I2C_1); i2c_init(I2C_5); //Config PMIC (TODO: use max77620.h) i2c_send_byte(I2C_5, 0x3C, 4, 0x40); i2c_send_byte(I2C_5, 0x3C, 0x41, 0x78); i2c_send_byte(I2C_5, 0x3C, 0x43, 0x38); i2c_send_byte(I2C_5, 0x3C, 0x44, 0x3A); i2c_send_byte(I2C_5, 0x3C, 0x45, 0x38); i2c_send_byte(I2C_5, 0x3C, 0x4A, 0xF); i2c_send_byte(I2C_5, 0x3C, 0x4E, 0xC7); i2c_send_byte(I2C_5, 0x3C, 0x4F, 0x4F); i2c_send_byte(I2C_5, 0x3C, 0x50, 0x29); i2c_send_byte(I2C_5, 0x3C, 0x52, 0x1B); i2c_send_byte(I2C_5, 0x3C, 0x16, 42); //42 = (1000 * 1125 - 600000) / 12500 config_pmc_scratch(); CLOCK(CLK_RST_CONTROLLER_SCLK_BURST_POLICY) = CLOCK(CLK_RST_CONTROLLER_SCLK_BURST_POLICY) & 0xFFFF8888 | 0x3333; mc_config_carveout(); sdram_init(); }