Making UniPCemu's hardware run independently of emulated CPU speed without breaking cycle accuracy with hardware? \ VOGONS

Making UniPCemu's hardware run independently of emulated CPU speed without breaking cycle accuracy with hardware?

Topic actions

Post a reply

First post, by superfury

Posted on 2016-09-01, 08:59

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5478
Joined: 2014-03-08, 11:25
Location: Netherlands

I'm currently using the following code with my cycle-accurate CPU/hardware emulation:

1extern uint_32 CPU_InterruptReturn, CPU_exec_EIP; //Interrupt return address!
2
3extern byte allcleared;
4
5double currenttiming = 0.0; //Current timing spent to emulate!
6
7extern byte Settings_request; //Settings requested to be executed?
8
9OPTINLINE byte coreHandler()
10{
11	uint_32 MHZ14passed; //14 MHZ clock passed?
12	byte BIOSMenuAllowed = 1; //Are we allowed to open the BIOS menu?
13	//CPU execution, needs to be before the debugger!
14	currenttiming += getnspassed(&CPU_timing); //Check for any time that has passed to emulate!
15	uint_64 currentCPUtime = (uint_64)currenttiming; //Current CPU time to update to!
16	uint_64 timeoutCPUtime = currentCPUtime+TIMEOUT_TIME; //We're timed out this far in the future (1ms)!
17
18	double instructiontime,timeexecuted=0.0f; //How much time did the instruction last?
19	byte timeout = TIMEOUT_INTERVAL; //Check every 10 instructions for timeout!
20	for (;last_timing<currentCPUtime;) //CPU cycle loop for as many cycles as needed to get up-to-date!
21	{
22		if (debugger_thread)
23		{
24			if (threadRunning(debugger_thread)) //Are we running the debugger?
25			{
26				updateAudio(getnspassed(&CPU_timing)); //Discard the time passed!
27				return 1; //OK, but skipped!
28			}
29		}
30		if (BIOSMenuThread)
31		{
32			if (threadRunning(BIOSMenuThread)) //Are we running the BIOS menu and not permanently halted? Block our execution!
33			{
34				if ((CPU[activeCPU].halt&2)==0) //Are we allowed to be halted entirely?
35				{
36						updateAudio(getnspassed(&CPU_timing)); //Discard the time passed!
37						return 1; //OK, but skipped!
38				}
39				BIOSMenuAllowed = 0; //We're running the BIOS menu! Don't open it again!
40			}
41		}
42		if ((CPU[activeCPU].halt&2)==0) //Are we running normally(not partly ran without CPU from the BIOS menu)?
43		{
44			BIOSMenuThread = NULL; //We don't run the BIOS menu anymore!
45		}
46
47		if (allcleared) return 0; //Abort: invalid buffer!
48
49		interruptsaved = 0; //Reset PIC interrupt to not used!
50		if (!CPU[activeCPU].registers) //We need registers at this point, but have none to use?
51		{
52			return 0; //Invalid registers: abort, since we're invalid!
53		}
54		if (CPU[activeCPU].halt) //Halted?
55		{
56			if (romsize) //Debug HLT?
57			{
58				MMU_dumpmemory("bootrom.dmp"); //Dump the memory to file!
59				return 0; //Stop execution!
60			}

…Show last 163 lines

61
62			if (CPU[activeCPU].halt & 0xC) //CGA wait state is active?
63			{
64				if ((CPU[activeCPU].halt&0xC) == 8) //Are we to resume execution now?
65				{
66					CPU[activeCPU].halt &= ~0xC; //We're resuming execution!
67					goto resumeFromHLT; //We're resuming from HLT state!
68				}
69				goto skipHaltRestart; //Count cycles normally!
70			}
71			else if (CPU[activeCPU].registers->SFLAGS.IF && PICInterrupt() && ((CPU[activeCPU].halt&2)==0)) //We have an interrupt? Clear Halt State when allowed to!
72			{
73				CPU[activeCPU].halt = 0; //Interrupt->Resume from HLT
74				goto resumeFromHLT; //We're resuming from HLT state!
75			}
76			else
77			{
78				skipHaltRestart:
79				if (DosboxClock) //Execute using Dosbox clocks?
80				{
81					CPU[activeCPU].cycles = 1; //HLT takes 1 cycle for now!
82				}
83				else //Execute using actual CPU clocks!
84				{
85					CPU[activeCPU].cycles = 1; //HLT takes 1 cycle for now, since it's unknown!
86				}
87			}
88			if (CPU[activeCPU].halt==1) //Normal halt?
89			{
90				//Increase the instruction counter every instruction/HLT time!
91				cpudebugger = needdebugger(); //Debugging information required? Refresh in case of external activation!
92				if (cpudebugger) //Debugging?
93				{
94					debugger_beforeCPU(); //Make sure the debugger is prepared when needed!
95					debugger_setcommand("<HLT>"); //We're a HLT state, so give the HLT command!
96				}
97				debugger_step(); //Step debugger if needed, even during HLT state!
98			}
99		}
100		else //We're not halted? Execute the CPU routines!
101		{
102			resumeFromHLT:
103			if (CPU[activeCPU].registers && doEMUsinglestep) //Single step enabled?
104			{
105				if (getcpumode() == (doEMUsinglestep - 1)) //Are we the selected CPU mode?
106				{
107					switch (getcpumode()) //What CPU mode are we to debug?
108					{
109					case CPU_MODE_REAL: //Real mode?
110						singlestep |= ((CPU[activeCPU].registers->CS == (singlestepaddress >> 16)) && (CPU[activeCPU].registers->IP == (singlestepaddress & 0xFFFF))); //Single step enabled?
111						break;
112					case CPU_MODE_PROTECTED: //Protected mode?
113					case CPU_MODE_8086: //Virtual 8086 mode?
114						singlestep |= ((CPU[activeCPU].registers->CS == singlestepaddress >> 32) && (CPU[activeCPU].registers->EIP == (singlestepaddress & 0xFFFFFFFF))); //Single step enabled?
115						break;
116					default: //Invalid mode?
117						break;
118					}
119				}
120			}
121
122			HWINT_saved = 0; //No HW interrupt by default!
123			CPU_beforeexec(); //Everything before the execution!
124			if (!CPU[activeCPU].trapped && CPU[activeCPU].registers) //Only check for hardware interrupts when not trapped!
125			{
126				if (CPU[activeCPU].registers->SFLAGS.IF) //Interrupts available?
127				{
128					if (PICInterrupt()) //We have a hardware interrupt ready?
129					{
130						HWINT_nr = nextintr(); //Get the HW interrupt nr!
131						HWINT_saved = 2; //We're executing a HW(PIC) interrupt!
132						if (!((EMULATED_CPU <= CPU_80286) && REPPending)) //Not 80386+, REP pending and segment override?
133						{
134							CPU_8086REPPending(); //Process pending REPs normally as documented!
135						}
136						else //Execute the CPU bug!
137						{
138							CPU_8086REPPending(); //Process pending REPs normally as documented!
139							CPU[activeCPU].registers->EIP = CPU_InterruptReturn; //Use the special interrupt return address to return to the last prefix instead of the start!
140						}
141						call_hard_inthandler(HWINT_nr); //get next interrupt from the i8259, if any!
142					}
143				}
144			}
145			cpudebugger = needdebugger(); //Debugging information required? Refresh in case of external activation!
146			MMU_logging = debugger_logging(); //Are we logging?
147			CPU_exec(); //Run CPU!
148
149			//Increase the instruction counter every instruction/HLT time!
150			debugger_step(); //Step debugger if needed!
151
152			CB_handleCallbacks(); //Handle callbacks after CPU/debugger usage!
153		}
154
155		//Update current timing with calculated cycles we've executed!
156		instructiontime = CPU[activeCPU].cycles*CPU_speed_cycle; //Increase timing with the instruction time!
157		last_timing += instructiontime; //Increase CPU time executed!
158		timeexecuted += instructiontime; //Increase CPU executed time executed this block!
159
160		//Tick 14MHz master clock, for basic hardware using it!
161		MHZ14_ticktiming += instructiontime; //Add time to the 14MHz master clock!
162		if (MHZ14_ticktiming>=MHZ14tick) //To tick some 14MHz clocks?
163		{
164			MHZ14passed = (uint_32)(MHZ14_ticktiming/MHZ14tick); //Tick as many as possible!
165			MHZ14_ticktiming -= MHZ14tick*(float)MHZ14passed; //Rest the time passed!
166		}
167		else
168		{
169			MHZ14passed = 0; //No time has passed on the 14MHz Master clock!
170		}
171
172		tickPIT(instructiontime,MHZ14passed); //Tick the PIT as much as we need to keep us in sync!
173		updateDMA(MHZ14passed); //Update the DMA timer!
174		updateMouse(instructiontime); //Tick the mouse timer if needed!
175		stepDROPlayer(instructiontime); //DRO player playback, if any!
176		if (useAdlib) updateAdlib(MHZ14passed); //Tick the adlib timer if needed!
177		if (useGameBlaster) updateGameBlaster(MHZ14passed); //Tick the Game Blaster timer if needed!
178		if (useSoundBlaster) updateSoundBlaster(instructiontime,MHZ14passed); //Tick the Sound Blaster timer if needed!
179		//updateATA(instructiontime); //Update the ATA timer! This is currently not used, so ignore it!
180		tickParallel(instructiontime); //Update the Parallel timer!
181		if (useLPTDAC) tickssourcecovox(instructiontime); //Update the Sound Source / Covox Speech Thing if needed!
182		updateVGA(instructiontime); //Update the VGA timer!
183		updateJoystick(instructiontime); //Update the Joystick!
184		updateAudio(instructiontime); //Update the general audio processing!
185		if (--timeout==0) //Timed out?
186		{
187			timeout = TIMEOUT_INTERVAL; //Reset the timeout to check the next time!
188			currenttiming += getnspassed(&CPU_timing); //Check for passed time!
189			if (currenttiming >= timeoutCPUtime) break; //Timeout? We're not fast enough to run at full speed!
190		}
191	} //CPU cycle loop!
192
193	//Slowdown to requested speed if needed!
194	currenttiming += getnspassed(&CPU_timing); //Add real time!
195	for (;currenttiming < last_timing;) //Not enough time spent on instructions?
196	{
197		currenttiming += getnspassed(&CPU_timing); //Add to the time to wait!
198		delay(0); //Update to current time every instruction according to cycles passed!
199	}
200
201	float temp;
202	temp = (float)MAX(last_timing,currenttiming); //Save for substraction(time executed in real time)!
203	last_timing -= temp; //Keep the CPU timing within limits!
204	currenttiming -= temp; //Keep the current timing within limits!
205
206	timeemulated += timeexecuted; //Add timing for the CPU percentage to update!
207
208	updateKeyboard(timeexecuted); //Tick the keyboard timer if needed!
209
210	//Check for BIOS menu!
211	if (psp_keypressed(BUTTON_SELECT) || Settings_request) //Run in-emulator BIOS menu requested?
212	{
213		if ((!is_gamingmode() && !Direct_Input && BIOSMenuAllowed) || Settings_request) //Not gaming/direct input mode and allowed to open it(not already started)?
214		{
215			lock(LOCK_INPUT);
216			Settings_request = 0; //We're handling the request!
217			unlock(LOCK_INPUT);
218			BIOSMenuThread = startThread(&BIOSMenuExecution,"BIOSMenu",NULL); //Start the BIOS menu thread!
219			delay(0); //Wait a bit for the thread to start up!
220		}
221	}
222	return 1; //OK!
223}

It runs without problems when the CPU and hardware are running with the CPU speed above 44 Dosbox-style cycles(in the case of 44.1kHz signals being generated, not to mention hardware running at higher frequencies). But when the user sets the cycle amount too low(so that the CPU runs more slowly than the hardware), the hardware won't be executed until the CPU actually does something, idling in the meantime, and generating that time in one big block when the CPU stops idling. In the case of audio output, this causes the audio to be generated too late for the audio output to give audio, while generating a huge amount of samples(the entire time the CPU spends idling is rendered all at once) causing dropouts in audio output.

Is there a good way to keep this synchronized at both slow and fast(independant of CPU speed) CPU speed settings, while keeping accuracy with the CPU/hardware cycle counting? I've currently fixed this by changing audio sampling to be able to store one full second of audio data(1 Dosbox-cycle set in the Setting menu, so 1000 instructions/second, which is the minimum speed) to always have enough buffered for playback, even at those slow speeds(1kIPS, tested with 9kIPs w/ Sound Blaster 2.0 emulation).

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Go to top of page Go to top of page

Back to PC Emulation

Main menu

Common searches