Annotation of nono/vm/pluto.cpp, revision 1.1.1.2

1.1       root        1: //
                      2: // nono
                      3: // Copyright (C) 2017 [email protected]
                      4: //
                      5: 
                      6: #include "pluto.h"
1.1.1.2 ! root        7: #include "mainapp.h"
1.1       root        8: #include "mpu.h"
                      9: 
                     10: PlutoDevice::PlutoDevice()
                     11: {
                     12:        logname = "pluto";
                     13:        devname = "Pluto";
                     14:        devaddr = 0xeac000;
                     15:        devlen  = 0x2000;
                     16: }
                     17: 
                     18: PlutoDevice::~PlutoDevice()
                     19: {
                     20: }
                     21: 
                     22: // ベンチマーク開始
                     23: void
                     24: PlutoDevice::benchmark_start(uint32 data)
                     25: {
                     26:        m_test_num = data;
                     27: 
                     28:        // テスト番号によってパラメータをセット
                     29:        // #2,#3 は NOP による実行サイクル測定。
                     30:        // #4,#5 は movem によるデータ空間アクセス測定。
                     31:        switch (m_test_num) {
                     32:         case 2:
                     33:         case 3:
                     34:                m_test_name = "NOP";
                     35:                m_inst_len = 2;
                     36:                m_inst_cycle = 2;
                     37:                break;
                     38:         case 4:
                     39:         case 5:
                     40:                m_test_name = "MOVEM";
                     41:                m_inst_len = 8;
                     42:                m_inst_cycle = 244;     // XXX 見直すこと
                     43:                break;
                     44:        }
                     45: 
                     46:        // 測定開始時だけ表示
                     47:        if (m_count == 0) {
                     48:                putlog(0, "ベンチマーク開始");
                     49: 
                     50:                // 命令開始アドレス。この時点で REG_PC は次をさしている
1.1.1.2 ! root       51:                m_start_addr = gMPU680x0->GetPPC();
1.1       root       52:        }
                     53: 
                     54:        // 測定開始
                     55:        gettimeofday(&m_start, NULL);
                     56: }
                     57: 
                     58: // ベンチマーク終了
                     59: void
                     60: PlutoDevice::benchmark_end()
                     61: {
                     62:        const int SECONDS = 5;  // 測定秒数 [sec]
                     63:        timeval end, result;
                     64:        int t;
                     65:        int num_of_inst;                // 1ループ中の命令セット数
                     66:        double speed;
                     67: 
                     68:        // 測定終了
                     69:        gettimeofday(&end, NULL);
                     70:        m_count++;
                     71: 
                     72:        // 今回1セット分の実行時間 [usec]
                     73:        timersub(&end, &m_start, &result);
                     74: 
                     75:        // 総実行時間
                     76:        timeradd(&result, &m_total, &m_total);
                     77: 
                     78:        // 規定秒数に満たなければ、もう1セット繰り返し。
                     79:        // 次が jmp 命令なのでこの命令を抜けるだけでいい。
                     80:        if (m_total.tv_sec < SECONDS) {
                     81:                return;
                     82:        }
                     83: 
                     84:        // 規定秒数に達していれば、測定終了
                     85:        t = m_total.tv_sec * 1000*1000 + m_total.tv_usec;
                     86:        putlog(0, "ベンチマーク#%d 終了 (%d 回, 計 %d.%03d msec)",
1.1.1.2 ! root       87:                gMainApp.benchmark_mode, m_count, t / 1000, t % 1000);
1.1       root       88: 
                     89:        // 1ループ中の命令セット数を算出。REG_PPC はこの命令の開始番地
1.1.1.2 ! root       90:        num_of_inst = (gMPU680x0->GetPPC() - m_start_addr) / m_inst_len;
1.1       root       91: 
                     92:        // 68030 のクロック数 [MHz] に換算
                     93:        speed = (double)(m_count * num_of_inst) * m_inst_cycle / t;
                     94: 
                     95:        // 表示用にベンチマーク ROM のリビジョンを取得
                     96:        int rev;
                     97: rev = 0;
                     98: #if 0
                     99:        IPLROM1 *iplrom1 = (IPLROM1 *)vm->SearchDevice(DEVICE_IPLROM1);
                    100:        ASSERT(iplrom1);
                    101:        if (!iplrom1->GetBenchmarkROM(m_test_num, NULL, &rev)) {
                    102:                rev = 0;
                    103:        }
                    104: #endif
                    105: 
                    106:        // XXX NetBSD ホストでは有効桁2桁と思われる
                    107:        putlog(0, "ベンチマーク#%d.%d (%s 実行速度) 68030/%3.0fMHz, %d MIPS",
                    108:                m_test_num, rev, m_test_name, speed, (m_count * num_of_inst) / t);
                    109: 
                    110:        // 電源オフ
                    111:        // XXX とりあえずね
                    112:        exit(1);
                    113: }
                    114: 
                    115: //
                    116: void
                    117: PlutoDevice::write_8_benchmark(uint32 addr, uint32 data)
                    118: {
                    119:        switch (data) {
                    120:         case 0:        // ベンチマーク終了
                    121:                benchmark_end();
                    122:                break;
                    123:         case 2:        // ベンチマーク開始
                    124:         case 3:
                    125:         case 4:
                    126:         case 5:
                    127:                benchmark_start(data);
                    128:                break;
                    129:         default:
                    130:                PANIC("not impl");
                    131:        }
                    132: }
                    133: 
                    134: uint64
                    135: PlutoDevice::Read8(uint32 addr)
                    136: {
                    137:        PANIC("not impl");
                    138: }
                    139: 
                    140: uint64
                    141: PlutoDevice::Read16(uint32 addr)
                    142: {
                    143:        PANIC("not impl");
                    144: }
                    145: 
                    146: uint64
                    147: PlutoDevice::Write8(uint32 addr, uint32 data)
                    148: {
                    149:        switch (addr) {
                    150:         case 0xeac403:
                    151:                write_8_benchmark(addr, data);
                    152:                break;
                    153:         default:
                    154:                PANIC("not yet");
                    155:        }
                    156:        return 0;
                    157: }
                    158: 
                    159: uint64
                    160: PlutoDevice::Write16(uint32 addr, uint32 data)
                    161: {
                    162:        PANIC("not impl");
                    163:        return 0;
                    164: }
                    165: 
                    166: uint64
                    167: PlutoDevice::Peek8(uint32 addr)
                    168: {
                    169:        PANIC("not yet");
                    170:        return 0;
                    171: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.