I am back from the holidays for sometime now, but I got swamped instantly by the work in my daytime job. I had very little energy on the project in the nights, which was spent on two things:
chasing that #@!% bug which is killing me and
implementing the data-flow optimization.
Needless to say that I
failed to track down the bug again, just like every time I spent hours on looking at couple megabytes of log dumps. Next time I will try a new approach, suggested by Stephen Fellner:
reducing the code complexity while the bug can be reproduced.
We will see how it goes. The processor cache emulation is certainly complicates things, that can be eliminated at least.
While I acknowledged the failure again, I gathered all my previous thoughts and implemented the data-flow based optimization which does a really nice job.
The
update is small, but highly important again:
- Implementation of code optimization.
- New configuration was introduced: comp_optimize to turn it on/off.
- Bugs in the register input/output flag specifications are fixed.
- Fixed too small string buffer in the 68k disassembler, previously the debugger crashed every time when memory was disassembled to the screen.
- Implementation of MOVEM.x regs,-(Ay)
What, how and why?
As I tried to explain earlier
in this post some of the compiled code is completely useless. The emulated instruction consists of the following parts usually:
- Initialization of certain temporary registers;
- Executing the actual operation;
- Alter the arithmetic flags according to the result;
- Save the result somewhere (into memory)
Some of these operations are not common or can be done for a series of instructions ahead, like loading the previous data for the emulated registers into temporary registers, but there are parts that cannot be avoided if we examine the emulated instruction out of its context.
For example the arithmetic flags are overwritten quite often by the following instructions, what means: if the next instruction(s) are not depending directly on the flag results then we can remove the code that generates these.
Typically, if we (as mighty humans) look at the instructions in a
block we can easily identify the context, we can tell mostly which
instructions produce usable results and what is not important. Like in most of the cases simple for a human, but it is a really complex job for the code compiler.
As I previously described: the emulated code is broken up into macroblocks by the precompiling. These blocks represent an "atomic" operation, like load data into temporary register, compare two registers or calculate certain arithmetic flags from the previous result.
When I started working on this concept I figured out that if I would be able to identify
exactly for each macroblocks the previous result(s) that it is depending on and the result(s) that it produces then I can evaluate the dependencies between the subsequent macroblocks.
Going with the flow
For Petunia I already implemented a similar concept, but that was limited to the flag usage and it is not able to split up the emulation of the arithmetic flags into individual flag registers: it is either emulated completely or removed completely. (Which means that even if we needed only the C register later the rarely used X register will be calculated too, usually after the C register was already done.
If you don't understand the reason behind this: don't worry - you need to know more about 68k assembly.)
For E-UAE the implementation is radically different. For any macroblock there is the possibility of specifying each and every emulated register, flag or temporary register as dependecy (input) and/or as result (output).
In the recent changes I implemented the rather simple solution for calculating the data-flow for each registers after all macroblocks are collected for a block of instructions.
It is capable of finding out for each macroblock whether the produced results are relevant for the following instructions in the block or not. If not then that macroblock can be eliminated from the compiled code because no instruction is depending on its results.
How to use it
Although, the optimization is completely safe (it won't remove any code that is essential) while the emulation is not stable enough there might be some bugs. So, I introduced a new configuration for turning it on/off, called:
comp_optimize.
It replaces the
comp_nf configuration from the x86 JIT implementation, because it is not just about the flags (
nf = no flags).
If it was set to true then the data-flow calculation is done and some macroblocks will be removed. By setting it to false the emulation compiles all the instructions fully into the buffer.
The results
And finally some speed tests... Compared to
the previously published Mandelbrot test results the actual numbers are:
Interpretive: 108 seconds;
JIT compiled without optimization: 52 seconds;
JIT compiled with optimization: 32 seconds.
That is roughly
40% speed increase in the case of this (heavily arithmetic) test.
The test system was: Micro AmigaOne (G3/800 MHz) - let's compare it to WinUAE that is running on my laptop (Intel Core i3 M350/2.27 GHz):
JIT compiled with all the possible optimizations turned on: 9 seconds.
It would be a tough job to compare these two computers, but I am pretty sure that my laptop is more than 3.5x faster than that poor old G3 machine.
I am really content with these results for now.
