extern void print_current_state() { print_board(HORIZONTAL); printf("\n"); print_board_info(HORIZONTAL); g_print = 0; }
static void __init mv_init(void) { /* init the Board environment */ mvBoardEnvInit(); /* init the controller environment */ if (mvCtrlEnvInit() ) { printk( "Controller env initialization failed.\n" ); return; } /* Init the CPU windows setting and the access protection windows. */ if (mvCpuIfInit(mv_sys_map())) { printk( "Cpu Interface initialization failed.\n" ); return; } #if defined (CONFIG_MV78XX0_Z0) mvCpuIfBridgeReorderWAInit(); #endif /* Init Tclk & SysClk */ mvTclk = mvBoardTclkGet(); mvSysclk = mvBoardSysClkGet(); support_wait_for_interrupt = 1; #ifdef CONFIG_JTAG_DEBUG support_wait_for_interrupt = 0; /* for Lauterbach */ #endif mv_vfp_init(); elf_hwcap &= ~HWCAP_JAVA; serial_initialize(); /* At this point, the CPU windows are configured according to default definitions in mvSysHwConfig.h */ /* and cpuAddrWinMap table in mvCpuIf.c. Now it's time to change defaults for each platform. */ mvCpuIfAddrDecShow(whoAmI()); print_board_info(); }
// see .h file for usage bool ldp::pre_search(const char* pszFrame, bool block_until_search_finishes) { char frame[FRAME_ARRAY_SIZE] = { 0 }; Uint16 frame_number = 0; // frame to search to bool result = false; char s1[81] = { 0 }; // safety check, if they try to search without checking the search result ... if (m_status == LDP_SEARCHING) { printline("LDP : tried to search without checking for search result first! that's bad!"); printline(frame); // this is definitely a Daphne bug if this happens, so log it! m_bug_log.push_back("LDP.CPP, pre_search() : tried to search without checking for search result first!"); return false; } // end safety check // Get the frame that we are on now, before we do the seek // This is needed in order to calculate artificial seek delay // We must do this before we change 'm_status' due to the way get_current_frame is designed m_last_seeked_frame = m_uCurrentFrame; // we copy here so that we can safely null-terminate strncpy(frame, pszFrame, 5); frame[5] = 0; // terminate the string ... frame_number = (Uint16) atoi(frame); // If we're seeking to the frame we're already on, then don't seek // This optimizes performance for many games and especially improves the coin insert delay // for Dragon's Lair 2. if ((m_status == LDP_PAUSED) && (frame_number == m_uCurrentFrame)) { printline("LDP NOTE: ignoring seek because we're already on that frame"); m_status = LDP_PAUSED; // just to be safe return true; } m_status = LDP_SEARCHING; // searching can take a while // If we need to alter the frame # before searching if (need_frame_conversion()) { Uint16 unadjusted_frame = frame_number; frame_number = (Uint16) do_frame_conversion(frame_number); framenum_to_frame(frame_number, frame); sprintf(s1, "Search to %d (formerly %d) received", frame_number, unadjusted_frame); } else { sprintf(s1, "Search to %d received", frame_number); } outstr(s1); // notify us if we're still using outdated blocking searching if (block_until_search_finishes) outstr(" [blocking] "); // if it's Dragon's Lair/Space Ace, print the board we are on if ((g_game->get_game_type() == GAME_LAIR) || (g_game->get_game_type() == GAME_DLE1) || (g_game->get_game_type() == GAME_DLE2) || (g_game->get_game_type() == GAME_ACE)) { Uint8 *cpumem = get_cpu_mem(0); // get the memory for the first (and only) outstr(" - "); print_board_info(cpumem[0xA00E], cpumem[0xA00F], cpumem[Z80_GET_IY]); } else { newline(); } // If the user requested a delay before seeking, make it now if (search_latency > 0) { #ifdef DEBUG // search latency needs to be reworked so that think() is getting called ... assert(false); #endif // make_delay(get_search_latency()); printline("WARNING : search latency needs to be redesigned, it is currently disabled"); } m_last_try_frame = (Uint16) atoi(frame); // the last frame we tried to seek to becomes this current one // HERE IS WHERE THE SEARCH ACTUALLY TAKES PLACE int difference = frame_number - m_uCurrentFrame; // how many frames we'd have to skip // if the player supports skipping AND user has requested the we skip instead of searching when possible // AND if we can skip forward instead of seeking ... if (skipping_supported && skip_instead_of_search && ((difference <= max_skippable_frames) && (difference > 1))) { result = pre_skip_forward((Uint16) difference); } // otherwise do a regular search else { result = nonblocking_search(frame); m_dont_get_search_result = false; // it's now ok to get the search result // if search succeeded if (result) { // if we are to block until the search finishes, then wait here (this is bad, don't do this!) // This is only here for backward compatibility! if (block_until_search_finishes) { unsigned int cur_time = refresh_ms_time(); unsigned int uLastTime = cur_time; // used to compute m_uBlockedMsSincePlay int ldp_stat = -1; // we know we may be waiting for a while, so we pause the cpu timer to avoid getting a flood after the seek completes cpu_pause(); // wait for player to change its status or for us to timeout while (elapsed_ms_time(cur_time) < 7000) { ldp_stat = get_status(); // get_status does some stuff that needs to get done, so we don't just read m_status instead // if the search is finished if (ldp_stat != LDP_SEARCHING) { break; } // Since the cpu is paused, we should not use think_delay // Also, blocking seeking may be used for skipping in noldp mode for cpu games like super don, // so we cannot use think_delay here. MAKE_DELAY(1); // VLDP relies on our timers for its timing, so we need to keep the time moving forward during // this period where we're paused. (and we can't use think_delay or pre_think because it can // cause vblank events which can cause irqs while the cpu is supposed to be paused) unsigned int uCurTimeTmp = refresh_ms_time(); m_uBlockedMsSincePlay += (uCurTimeTmp - uLastTime); // since we're blocked, the blockmssinceplay must increase uLastTime = uCurTimeTmp; think(); } cpu_unpause(); // done with the delay, so we can unpause // if we didn't succeed, then return an error if (ldp_stat != LDP_PAUSED) { printline("LDP : blocking search didn't succeed"); result = false; } } // end if we were doing a blocking styled search } // if the initial search command was accepted // else if search failed immediately else { printline("LDP : search failed immediately"); m_status = LDP_ERROR; } } // end regular search (instead of skipping) return(result); }
/***************************************************************************** * UART ****************************************************************************/ static struct resource mv_uart_resources[] = { { .start = PORT0_BASE, .end = PORT0_BASE + 0xff, .flags = IORESOURCE_MEM, }, { .start = IRQ_UART0, .end = IRQ_UART0, .flags = IORESOURCE_IRQ, }, { .start = PORT1_BASE, .end = PORT1_BASE + 0xff, .flags = IORESOURCE_MEM, }, { .start = IRQ_UART1, .end = IRQ_UART1, .flags = IORESOURCE_IRQ, }, }; static struct plat_serial8250_port mv_uart_data[] = { { .mapbase = PORT0_BASE, .membase = (char *)PORT0_BASE, .irq = IRQ_UART0, .flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF, .iotype = UPIO_MEM, .regshift = 2, }, { .mapbase = PORT1_BASE, .membase = (char *)PORT1_BASE, .irq = IRQ_UART1, .flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF, .iotype = UPIO_MEM, .regshift = 2, }, { }, }; static struct platform_device mv_uart = { .name = "serial8250", .id = PLAT8250_DEV_PLATFORM, .dev = { .platform_data = mv_uart_data, }, .num_resources = ARRAY_SIZE(mv_uart_resources), .resource = mv_uart_resources, }; static void serial_initialize(void) { mv_uart_data[0].uartclk = mv_uart_data[1].uartclk = mvTclk; platform_device_register(&mv_uart); } static void __init mv_vfp_init(void) { #if defined CONFIG_VFP_FASTVFP printk("VFP initialized to Run Fast Mode.\n"); #endif } #if defined(MV_88F6183) #ifdef CONFIG_MV_INCLUDE_AUDIO typedef struct { unsigned int base; unsigned int size; } _audio_mem_info; typedef struct { u32 spdif_rec; u32 spdif_play; u32 i2s_rec; u32 i2s_play; _audio_mem_info mem_array[MV_DRAM_MAX_CS + 1]; } _audio_info; _audio_info audio_info = {1, 1, 1, 1}; static struct resource mv_snd_resources[] = { [0] = { .start = INTER_REGS_BASE + AUDIO_REG_BASE, .end = INTER_REGS_BASE + AUDIO_REG_BASE + SZ_16K -1, .flags = IORESOURCE_MEM, }, [1] = { .start = IRQ_AUDIO_INT, .end = IRQ_AUDIO_INT, .flags = IORESOURCE_IRQ, }, [2] = { .start = NR_IRQS, /* should obtained from board information*/ .end = NR_IRQS, /* should obtained from board information */ .flags = IORESOURCE_IRQ, } }; static u64 mv_snd_dmamask = 0xFFFFFFFFUL; static struct platform_device mv_snd_device = { .name = "mv88fx_snd", .id = -1, .dev = { .dma_mask = &mv_snd_dmamask, .coherent_dma_mask = 0xFFFFFFFF, .platform_data = &audio_info, }, .num_resources = ARRAY_SIZE(mv_snd_resources), .resource = mv_snd_resources, }; #endif /* #ifdef CONFIG_MV_INCLUDE_AUDIO */ #ifdef CONFIG_MV_INCLUDE_SDIO static struct resource mvsdmmc_resources[] = { [0] = { .start = INTER_REGS_BASE + 0x80000, .end = INTER_REGS_BASE + 0x80000 + SZ_1K -1, .flags = IORESOURCE_MEM, }, [1] = { .start = SDIO_IRQ_NUM, .end = SDIO_IRQ_NUM, .flags = IORESOURCE_IRQ, }, [2] = { .start = NR_IRQS, /* should obtained from board information*/ .end = NR_IRQS, /* should obtained from board information */ .flags = IORESOURCE_IRQ, } }; static u64 mvsdmmc_dmamask = 0xffffffffUL; static struct platform_device mvsdmmc_device = { .name = "mvsdmmc", .id = -1, .dev = { .dma_mask = &mvsdmmc_dmamask, .coherent_dma_mask = 0xffffffff, }, .num_resources = ARRAY_SIZE(mvsdmmc_resources), .resource = mvsdmmc_resources, }; #endif /* CONFIG_MV_INCLUDE_SDIO */ static struct platform_device *devices[] __initdata = { #ifdef CONFIG_MV_INCLUDE_AUDIO &mv_snd_device, #endif #ifdef CONFIG_MV_INCLUDE_SDIO &mvsdmmc_device, #endif NULL }; #endif /* #if defined(MV_88F6183) */ static void __init mv_init(void) { unsigned int temp; /* init the Board environment */ if (mvBoardIdGet() != RD_88F6082_MICRO_DAS_NAS) /* excluded for HDD power problem - to be fixed */ mvBoardEnvInit(); /* init the controller environment */ if( mvCtrlEnvInit() ) { printk( "Controller env initialization failed.\n" ); return; } if(mvBoardIdGet() == RD_88F5181_POS_NAS) { temp = MV_REG_READ(GPP_DATA_OUT_REG(0)); temp &= ~(1 << 0x5); /* for host mode should be set to 0 */ if(!mvIsUsbHost) { temp |= (1 << 0x5); } MV_REG_WRITE(GPP_DATA_OUT_REG(0), temp); } /* Init the CPU windows setting and the access protection windows. */ if( mvCpuIfInit(mv_sys_map()) ) { printk( "Cpu Interface initialization failed.\n" ); return; } /* Init Tclk & SysClk */ mvTclk = mvBoardTclkGet(); mvSysclk = mvBoardSysClkGet(); printk("Sys Clk = %d, Tclk = %d\n",mvSysclk ,mvTclk ); if ((mvCtrlModelGet() == MV_5281_DEV_ID) || (mvCtrlModelGet() == MV_1281_DEV_ID) || (mvCtrlModelGet() == MV_6183_DEV_ID)) mv_orion_ver = MV_ORION2; /* Orion II */ else mv_orion_ver = MV_ORION1; /* Orion I */ /* Implement workaround for FEr# CPU-C16: Wait for interrupt command */ /* is not processed properly, the workaround is not to use this command */ /* the erratum is relevant for 5281 devices with revision less than C0 */ if((mvCtrlModelGet() == MV_5281_DEV_ID) && (mvCtrlRevGet() < MV_5281_C0_REV)) { support_wait_for_interrupt = 0; } #ifdef CONFIG_JTAG_DEBUG support_wait_for_interrupt = 0; /* for Lauterbach */ #endif mv_vfp_init(); elf_hwcap &= ~HWCAP_JAVA; serial_initialize(); /* At this point, the CPU windows are configured according to default definitions in mvSysHwConfig.h */ /* and cpuAddrWinMap table in mvCpuIf.c. Now it's time to change defaults for each platform. */ mvCpuIfAddDecShow(); #if defined(CONFIG_MTD_PHYSMAP) mv_mtd_initialize(); #endif print_board_info(); #ifdef CONFIG_MV_INCLUDE_IDMA mvDmaInit(); #endif #if defined(MV_88F6183) #ifdef CONFIG_MV_INCLUDE_SDIO mvsdmmc_resources[2].end = mvBoardSDIOGpioPinGet() + IRQ_GPP_START; mvsdmmc_resources[2].start = mvBoardSDIOGpioPinGet() + IRQ_GPP_START; irq_int_type[mvBoardSDIOGpioPinGet()] = GPP_IRQ_TYPE_CHANGE_LEVEL; #endif /* CONFIG_MV_INCLUDE_SDIO */ #ifdef CONFIG_MV_INCLUDE_AUDIO for (temp=0 ; temp< MV_DRAM_MAX_CS; temp++) { MV_DRAM_DEC_WIN win; audio_info.mem_array[temp].base = 0; audio_info.mem_array[temp].size = 0; mvDramIfWinGet(SDRAM_CS0 + temp, &win); if (win.enable) { audio_info.mem_array[temp].base = win.addrWin.baseLow; audio_info.mem_array[temp].size = win.addrWin.size; } } #endif /* CONFIG_MV_INCLUDE_AUDIO */ if ((temp = ARRAY_SIZE(devices) - 1)) platform_add_devices(devices, temp); #endif /* MV_88F6183 */ return; }
// TODO: add player payments for chance/chest int main(int argc, char ** argv) { struct timeval t1, t2; MPI_Init(&argc, &argv); gettimeofday(&t1, NULL); int rank, size; MPI_Comm_rank(MPI_COMM_WORLD, &globalrank); MPI_Comm_size(MPI_COMM_WORLD, &size); globalsize = size; srand(time(NULL) + globalrank); struct location board[BSIZE]; struct player players[NUMPLAYERS]; int itr = 10000; long long bills[4]; // how much you owe each player at end of round init_players(players); init_board(board); char plocation; int pvalue; int numcomms = 1; MPI_Group world_group; MPI_Comm_group(MPI_COMM_WORLD, &world_group); playerdata d; d.money[0] = 0; d.money[1] = 0; d.money[2] = 0; d.money[3] = 0; output = (FILE **) malloc(size * sizeof(FILE *)); // if 1 process created just run sequentially if (size == 1) { int done[4] = {1, 1, 1, 1}; while (itr) { itr--; int i; for (i = 0; i < NUMPLAYERS; i++) { plocation = 0; pvalue = 0; if (players[i].money > 0) { move(players, board, i, &pvalue, &plocation); if (plocation) { board[plocation].owner = i; players[i].money -= pvalue; } } else { players[i].order = -1; if (done[i]) { remove_properties(board, i); done[i] = 0; } } } } gettimeofday(&t2, NULL); results(players, board); double exectime = (t2.tv_sec - t1.tv_sec) * 1000000 + ((t2.tv_usec - t1.tv_usec)); printf("Exec Time %lf\n", exectime); return 0; } // create a communicator for each monopoly game (for n > 4) MPI_Group * gamesel; MPI_Comm * games; int ranksel[4]; if (size > 4) { numcomms = size / 4; games = (MPI_Comm *) malloc(numcomms * sizeof(MPI_Comm)); gamesel = (MPI_Group *) malloc(numcomms * sizeof(MPI_Group)); int i; for (i = 0; i < numcomms; i++) { ranksel[0] = 4 * i; ranksel[1] = 4 * i + 1; ranksel[2] = 4 * i + 2; ranksel[3] = 4 * i + 3; MPI_Group_incl(world_group, 4, ranksel, &gamesel[i]); MPI_Comm_create(MPI_COMM_WORLD, gamesel[i], &games[i]); } } else { // n < 4 so use MPI_COMM_WORLD games = (MPI_Comm *) malloc(1 * sizeof(MPI_Comm)); games[0] = MPI_COMM_WORLD; numcomms = 1; } // create an MPI type so that we can use our player data struct in MPI communication calls const int nitems = 5; int blocklengths[5] = {4, 1, 1, 1, 1}; MPI_Datatype types[5] = {MPI_LONG_LONG, MPI_INT, MPI_CHAR, MPI_CHAR, MPI_CHAR}; MPI_Datatype MPI_MONO_DATA; MPI_Aint offsets[5]; offsets[0] = offsetof(playerdata, money); offsets[1] = offsetof(playerdata, pvalue); offsets[2] = offsetof(playerdata, plocation); offsets[3] = offsetof(playerdata, order); offsets[4] = offsetof(playerdata, trade); MPI_Type_create_struct(nitems, blocklengths, offsets, types, &MPI_MONO_DATA); MPI_Type_commit(&MPI_MONO_DATA); MPI_Comm_rank(games[globalrank / 4], &rank); #ifdef DEBUG char fname[10]; snprintf(fname, 10, "mon%d.dbg", globalrank); output[globalrank] = fopen(fname, "w"); fprintf(output[globalrank], "MAIN begin loop\n"); print_board_info(board); #endif // run the game for 40000 turns (10000 per player) while (itr > 0) { itr--; pvalue = 0; plocation = 0; d.trade = 0; d.order = rank; #ifdef DEBUG fprintf(output[globalrank], "MAIN tag 1 rank %d\n", rank); #endif move(players, board, rank, &pvalue, &plocation); d.pvalue = pvalue; d.plocation = plocation; #ifdef DEBUG fprintf(output[globalrank], "using comm %d\n", globalrank / 4); if (games[globalrank / 4] != MPI_COMM_WORLD) { fprintf(output[globalrank], "COMM ERROR\n"); } #endif send_info(&d, players, board, rank, games[globalrank / 4], MPI_MONO_DATA); #ifdef DEBUG fprintf(output[globalrank], "MAIN tag 3 rank %d\n", rank); print_board_info(board); #endif } #ifdef DEBUG fprintf(output[globalrank], "MAIN last tag rank %d\n", rank); #endif // get results from each process gather_results(players, board, games, numcomms, globalrank); gettimeofday(&t2, NULL); if (globalrank == 0) { results(players, board); } #ifdef DEBUG fclose(output[globalrank]); #endif double exectime = (t2.tv_sec - t1.tv_sec) * 1000000 + ((t2.tv_usec - t1.tv_usec)); if (globalrank == 0) { printf("Exec Time %lf\n", exectime); } MPI_Finalize(); return 0; }