Return to syncer.cpp CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm

Annotation of nono/vm/syncer.cpp, revision 1.1

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2022 nono project
        !             4: // Licensed under nono-license.txt
        !             5: //
        !             6: 
        !             7: //
        !             8: // 実時間同期
        !             9: //
        !            10: 
        !            11: #include "syncer.h"
        !            12: #include "config.h"
        !            13: #include "mainapp.h"
        !            14: #include "mainbus.h"
        !            15: #include "mainram.h"
        !            16: #include "scheduler.h"
        !            17: 
        !            18: //#define DEBUG
        !            19: 
        !            20: #if defined(DEBUG)
        !            21: #define DPRINTF(fmt...)        printf(fmt);
        !            22: #else
        !            23: #define DPRINTF(fmt...) /**/
        !            24: #endif
        !            25: 
        !            26: // パフォーマンス測定を行う実時間間隔
        !            27: static constexpr uint64 PERF_INTERVAL = 1000_msec;
        !            28: 
        !            29: // コンストラクタ
        !            30: Syncer::Syncer()
        !            31:        : inherited(OBJ_SYNCER)
        !            32: {
        !            33:        for (int i = 0; i < perfq.Capacity(); i++) {
        !            34:                perfq.Enqueue(1000);
        !            35:        }
        !            36: 
        !            37:        sync_event.func = ToEventCallback(&Syncer::SyncCallback);
        !            38:        sync_event.time = 50_msec;
        !            39:        sync_event.Regist("Sync");
        !            40: }
        !            41: 
        !            42: // デストラクタ
        !            43: Syncer::~Syncer()
        !            44: {
        !            45: }
        !            46: 
        !            47: // 初期化
        !            48: bool
        !            49: Syncer::Init()
        !            50: {
        !            51:        if (inherited::Init() == false) {
        !            52:                return false;
        !            53:        }
        !            54: 
        !            55:        mainbus = GetMainbusDevice();
        !            56:        mainram = GetMainRAMDevice();
        !            57: 
        !            58:        mode = SCHED_POWEROFF;
        !            59:        overslept = 0;
        !            60: 
        !            61:        // 高速モード指定
        !            62:        bool fast_mode = gConfig->Find("fast-mode").AsInt();
        !            63:        RequestFullSpeed(fast_mode);
        !            64: 
        !            65:        scheduler->ConnectMessage(MessageID::SCHEDULER_SYNCMODE, this,
        !            66:                ToMessageCallback(&Syncer::ChangeModeCallback));
        !            67: 
        !            68:        return true;
        !            69: }
        !            70: 
        !            71: void
        !            72: Syncer::StartRealTime()
        !            73: {
        !            74:        realtime.Start();
        !            75: }
        !            76: 
        !            77: void
        !            78: Syncer::StopRealTime()
        !            79: {
        !            80:        realtime.Stop();
        !            81: }
        !            82: 
        !            83: // 時間の始まり
        !            84: void
        !            85: Syncer::StartTime()
        !            86: {
        !            87:        scheduler->StartEvent(sync_event);
        !            88: 
        !            89:        // 諸々の初期化が終わった頃にタイマーを開始。
        !            90:        // Stopwatch.Restart() は .Net 由来なので
        !            91:        // Restart() は経過時間をリセットしてからタイマーを開始の意。
        !            92:        realtime.Restart();
        !            93: 
        !            94:        rtime = realtime.Elapsed();
        !            95:        rtime_epoch = rtime;
        !            96:        vtime_epoch = scheduler->GetVirtTime();
        !            97: 
        !            98:        // パフォーマンス表示用。
        !            99:        // 最初の集計が行われる起動後1秒までは、この値が表示されるので
        !           100:        // インチキして 100% にしておく。
        !           101:        perf_counter = 100;
        !           102:        last_perf_rtime = rtime_epoch;
        !           103:        last_perf_vtime = vtime_epoch;
        !           104:        next_perf_rtime = PERF_INTERVAL;
        !           105: }
        !           106: 
        !           107: // CPU 状態変更(通常/STOP/HALT)を指示する。
        !           108: // CPU が呼ぶはずなので自スレッドからのみ呼ばれるはず。
        !           109: void
        !           110: Syncer::RequestCPUMode(uint32 cpumode)
        !           111: {
        !           112:        uint32 newmode;
        !           113: 
        !           114:        newmode = (mode & ~SCHED_CPU_MASK) | cpumode;
        !           115: 
        !           116:        ChangeMode(newmode);
        !           117: }
        !           118: 
        !           119: // 高速モード/同期モードの変更を指示する。
        !           120: // true なら高速モード、false なら同期モード。
        !           121: // 他スレッドから呼んでもよい。
        !           122: void
        !           123: Syncer::RequestFullSpeed(bool enable)
        !           124: {
        !           125:        scheduler->SendMessage(MessageID::SCHEDULER_SYNCMODE, enable);
        !           126: }
        !           127: 
        !           128: // ブートページモードの変更を指示する。
        !           129: // (VM::SwitchBootPage から呼ぶので個別には呼ばないこと)
        !           130: void
        !           131: Syncer::RequestBootPageMode(bool isrom)
        !           132: {
        !           133:        uint32 newmode;
        !           134: 
        !           135:        if (isrom) {
        !           136:                newmode = mode | SCHED_BOOT;
        !           137:        } else {
        !           138:                newmode = mode & ~SCHED_BOOT;
        !           139:        }
        !           140: 
        !           141:        ChangeMode(newmode);
        !           142: }
        !           143: 
        !           144: // キー入力状態の変更を指示する。
        !           145: void
        !           146: Syncer::RequestKeyPressed(bool pressed)
        !           147: {
        !           148:        uint32 newmode;
        !           149: 
        !           150:        if (pressed) {
        !           151:                newmode = mode | SCHED_KEY;
        !           152:        } else {
        !           153:                newmode = mode & ~SCHED_KEY;
        !           154:        }
        !           155: 
        !           156:        ChangeMode(newmode);
        !           157: }
        !           158: 
        !           159: // 電源状態の変更を指示する。
        !           160: void
        !           161: Syncer::RequestPowerOffMode(bool poweroff)
        !           162: {
        !           163:        uint32 newmode;
        !           164: 
        !           165:        if (poweroff) {
        !           166:                newmode = mode | SCHED_POWEROFF;
        !           167:        } else {
        !           168:                newmode = mode & ~SCHED_POWEROFF;
        !           169:        }
        !           170: 
        !           171:        ChangeMode(newmode);
        !           172: }
        !           173: 
        !           174: // 動作状態変更のメッセージコールバック
        !           175: void
        !           176: Syncer::ChangeModeCallback(MessageID msgid, uint32 arg)
        !           177: {
        !           178:        uint32 newmode;
        !           179: 
        !           180:        if (msgid == MessageID::SCHEDULER_SYNCMODE) {
        !           181:                if (arg) {
        !           182:                        newmode = mode & ~SCHED_SYNC;
        !           183:                } else {
        !           184:                        newmode = mode | SCHED_SYNC;
        !           185:                }
        !           186: 
        !           187:                ChangeMode(newmode);
        !           188:        }
        !           189: }
        !           190: 
        !           191: // メンバ変数 mode_request に従ってスケジューラの動作状態を変更。
        !           192: // 自スレッドから呼ぶこと。
        !           193: void
        !           194: Syncer::ChangeMode(uint32 newmode)
        !           195: {
        !           196:        // いずれかでも変化していれば..
        !           197:        if (mode != newmode) {
        !           198:                // 動作モード変更要因を全部調べた結果、変更が必要か。
        !           199:                // mode、newmode どちらもゼロ(高速モード)か非ゼロ(通常モード)か
        !           200:                // なので、等値比較ではなく二値にしてから比較。
        !           201:                if ((bool)mode != (bool)newmode) {
        !           202:                        // モードが変わるのでここで一旦同期をとる
        !           203:                        DoSync();
        !           204: 
        !           205:                        if (newmode == 0) {
        !           206:                                // 高速モードに
        !           207:                                putlog(2, "Fast mode");
        !           208: 
        !           209:                                // 高速モードでは RAM は直接アクセス
        !           210:                                mainbus->direct_ram_size = mainram->GetSize();
        !           211: 
        !           212:                        } else {
        !           213:                                // 同期モードに
        !           214:                                putlog(2, "Sync mode");
        !           215: 
        !           216:                                // 同期モードでは RAM アクセスはデバイス経由
        !           217:                                mainbus->direct_ram_size = 0;
        !           218: 
        !           219:                                // 同期用の基準点を設置。
        !           220:                                // ゲストが STOP 命令による定常状態にいる時は
        !           221:                                // 割り込みなど短期間だけ高速モードになるのを繰り返す。
        !           222:                                // スリープ粒度の粗い NetBSD ホストでは同期モードに
        !           223:                                // 切り替えるたびに基準点を移動していると、スリープ
        !           224:                                // しすぎてしまうので、実時間と仮想時間のズレが小さい場合は
        !           225:                                // 基準点を移動せず無視する。
        !           226:                                uint64 vtime = scheduler->GetVirtTime();
        !           227:                                uint64 rspan = rtime - rtime_epoch;
        !           228:                                uint64 vspan = vtime - vtime_epoch;
        !           229:                                if (vspan > rspan + overslept) {
        !           230:                                        rtime_epoch = rtime;
        !           231:                                        vtime_epoch = vtime;
        !           232:                                }
        !           233:                        }
        !           234:                }
        !           235: 
        !           236:                // ブール比較の後で、全ビットを維持したまま代入。
        !           237:                mode = newmode;
        !           238:        }
        !           239:        DPRINTF("ChangeMode end mode=$%x\n", mode);
        !           240: }
        !           241: 
        !           242: // 同期イベント
        !           243: void
        !           244: Syncer::SyncCallback(Event& ev)
        !           245: {
        !           246:        DPRINTF("SyncCallback\n");
        !           247:        DoSync();
        !           248: 
        !           249:        // 次回のイベントを再登録
        !           250:        scheduler->StartEvent(ev);
        !           251: }
        !           252: 
        !           253: // 同期処理
        !           254: // ここで仮想時間を実時間と同期させる。
        !           255: // スリープしすぎた実時間を返す。
        !           256: void
        !           257: Syncer::DoSync()
        !           258: {
        !           259:        // 実時間をここで更新
        !           260:        rtime = realtime.Elapsed();
        !           261:        DPRINTF("Sync begin rtime=%s\n", SecToStr(rtime).c_str());
        !           262: 
        !           263:        // 統計情報
        !           264:        sync_count++;
        !           265:        // XXX どこでやる?
        !           266:        if (__predict_false(rtime >= next_perf_rtime)) {
        !           267:                CalcPerf();
        !           268:        }
        !           269: 
        !           270:        // XXX 次回 Start する時のイベント間隔をここ(DoSync())で事前に決めている
        !           271:        sync_event.time = 50_msec;
        !           272: 
        !           273:        // 同期モードなら..
        !           274:        if (mode != 0) {
        !           275:                uint64 vtime = scheduler->GetVirtTime();
        !           276:                uint64 rspan = rtime - rtime_epoch;
        !           277:                uint64 vspan = vtime - vtime_epoch;
        !           278:                if (vspan > rspan) {
        !           279:                        // 仮想時間のほうが進んでいれば、スリープして待つ
        !           280:                        uint64 diff = vspan - rspan;
        !           281:                        uint64 prev = rtime;
        !           282: 
        !           283:                        DPRINTF("Sync wait_for=%s\n", SecToStr(diff).c_str());
        !           284:                        scheduler->Sleep(diff);
        !           285: 
        !           286:                        // スリープしすぎた時間を計測。
        !           287:                        // この時間にはスリープ時間を計算するための時間も含む。
        !           288:                        rtime = realtime.Elapsed();
        !           289:                        DPRINTF("Sync wakeup rtime=%s\n", SecToStr(rtime).c_str());
        !           290:                        uint64 realslept = rtime - prev;
        !           291:                        if (realslept > diff) {
        !           292:                                uint64 over = realslept - diff;
        !           293:                                if (over > 1_sec) {
        !           294:                                        // スリープ中にサスペンドされたと推定する
        !           295:                                        putlog(1, "時刻再同期(スリープ中の実時間跳躍)");
        !           296:                                        rtime_epoch = rtime;
        !           297:                                        vtime_epoch = vtime;
        !           298:                                } else if (over > overslept) {
        !           299:                                        overslept = over;
        !           300:                                }
        !           301:                        } else if (realslept < diff) {
        !           302:                                uint64 under = diff - realslept;
        !           303:                                if (under > overslept) {
        !           304:                                        sync_event.time = 0;
        !           305:                                }
        !           306:                        }
        !           307:                } else if (rspan > vspan + overslept) {
        !           308:                        // 実時間のほうが時間精度より進んでいれば、サスペンドとかから
        !           309:                        // 復帰してきた状態だと推定して、基準時刻を再同期する。
        !           310:                        putlog(1, "時刻再同期(実行中の実時間跳躍)");
        !           311:                        rtime_epoch = rtime;
        !           312:                        vtime_epoch = vtime;
        !           313:                } else {
        !           314:                        // 同期の範囲内にいるので何もしなくていい
        !           315:                }
        !           316:        }
        !           317: }
        !           318: 
        !           319: void
        !           320: Syncer::CalcPerf()
        !           321: {
        !           322:        uint64 vtime = scheduler->GetVirtTime();
        !           323:        uint64 rperf = rtime - last_perf_rtime;
        !           324:        uint64 vperf = vtime - last_perf_vtime;
        !           325: 
        !           326:        // 百分率で小数以下1桁分までとなるよう整数で計算する
        !           327:        perfq.EnqueueForce((uint32)(vperf * 1000 / rperf));
        !           328:        // 移動平均を求める (perfq は常に要素数分埋めてある)
        !           329:        int ma = 0;
        !           330:        int qlen = perfq.Length();
        !           331:        __assume(qlen > 0);
        !           332:        for (int i = 0; i < qlen; i++) {
        !           333:                auto v = perfq.Peek(i);
        !           334:                ma += v;
        !           335:        }
        !           336:        ma /= qlen;
        !           337:        // 最下位を四捨五入して捨てる (整数%になる)
        !           338:        ma = (ma + 5) / 10;
        !           339:        perf_counter = ma;
        !           340: 
        !           341:        // 直近1秒の Sync 回数
        !           342:        last_sync_count = sync_count;
        !           343:        sync_count = 0;
        !           344: 
        !           345:        last_perf_rtime = rtime;
        !           346:        last_perf_vtime = vtime;
        !           347:        next_perf_rtime = rtime + PERF_INTERVAL;
        !           348: }
        !           349: 
        !           350: // パフォーマンス測定用に実時間をログ出力
        !           351: void
        !           352: Syncer::PutlogRealtime()
        !           353: {
        !           354:        uint64 vtime = scheduler->GetVirtTime();
        !           355: 
        !           356:        // 電源オン時からここまでの時間を表示するだけでリセット等はしない。
        !           357:        putlog(0, "Elapsed time since power-on: %d.%03d sec, %6.2f%%",
        !           358:                (int)(rtime / (1000 * 1000 * 1000)),
        !           359:                (int)((rtime / (1000 * 1000)) % 1000),
        !           360:                (double)vtime / rtime * 100);
        !           361: 
        !           362: #if 0
        !           363:        // イベントキューの性能評価用
        !           364:        uint64 sum = 0;
        !           365:        for (const auto e : events) {
        !           366:                sum += e->count;
        !           367:        }
        !           368:        putlog(0, "%lu events done, %6.3fM/sec", sum, (double)sum / rtime * 1000);
        !           369: #endif
        !           370: }
        !           371: 
        !           372: // モニタ更新の下請け (Scheduler から呼ばれる)
        !           373: int
        !           374: Syncer::MonitorUpdateSub(TextScreen& screen, uint64 vtime)
        !           375: {
        !           376:        int y = 0;
        !           377: 
        !           378:        screen.Print(0, y, "Mode: 0x%04x (", mode);
        !           379:        switch (mode & SCHED_CPU_MASK) {
        !           380:         case SCHED_CPU_NORMAL:
        !           381:                screen.Puts(14, y, TA::Off, "Run");
        !           382:                break;
        !           383:         case SCHED_CPU_STOP:
        !           384:                screen.Puts(14, y, TA::On, "STOP");
        !           385:                break;
        !           386:         case SCHED_CPU_HALT:
        !           387:                screen.Puts(14, y, TA::On, "HALT");
        !           388:                break;
        !           389:        }
        !           390:        if ((mode & SCHED_SYNC)) {
        !           391:                screen.Puts(19, y, TA::On, "Sync");
        !           392:        } else {
        !           393:                screen.Puts(19, y, TA::Off, "Full");
        !           394:        }
        !           395:        screen.Puts(24, y, TA::OnOff((mode & SCHED_BOOT)), "Boot");
        !           396:        screen.Puts(29, y, TA::OnOff((mode & SCHED_KEY)), "Key");
        !           397:        screen.Puts(34, y, TA::OnOff((mode & SCHED_POWEROFF)), "POff");
        !           398:        screen.Puts(38, y, ")");
        !           399:        y++;
        !           400:        uint64 rt = rtime;
        !           401:        uint64 vt = vtime;
        !           402: 
        !           403:        auto s_rt = TimeToStr(rt);
        !           404:        auto s_vt = TimeToStr(vt);
        !           405:        std::string s_sync_rt {};
        !           406:        std::string s_sync_vt {};
        !           407:        if (mode != 0) {
        !           408:                uint64 sync_rt = rtime - rtime_epoch;
        !           409:                uint64 sync_vt = vtime - vtime_epoch;
        !           410:                s_sync_rt = TimeToStr(sync_rt);
        !           411:                s_sync_vt = TimeToStr(sync_vt);
        !           412:        }
        !           413:        // 日まで表示しようとするときは桁位置を動かす
        !           414:        int width = std::max(rt, vt) < 86400_sec ? 20 : 25;
        !           415: 
        !           416:        screen.Print(0, y++, "Total  Real Time: %*s", width, s_rt.c_str());
        !           417:        screen.Print(4, y++,     "Virtual Time: %*s", width, s_vt.c_str());
        !           418:        screen.Print(0, y++, "Sync   Real Time: %*s", width, s_sync_rt.c_str());
        !           419:        screen.Print(4, y++,     "Virtual Time: %*s", width, s_sync_vt.c_str());
        !           420: 
        !           421:        screen.Print(0, y++, "Performance     : %4d%%", perf_counter);
        !           422: 
        !           423:        int x = 52;
        !           424:        int y1 = 0;
        !           425:        screen.Print(x, y1++, "Max OverSlept: %13s", SecToStr(overslept).c_str());
        !           426:        screen.Print(x, y1++, "Sync per sec :          %4u", last_sync_count);
        !           427: 
        !           428:        return y;
        !           429: }

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