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