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