Read this...

http://dosbox.sourceforge.net/wiki/index.php? … =BuildingDOSBox

You need to replace the appropriate files with the ones for Fast DOSBox and compile it. It's fairly straightforward.

What is that? A Real Time Clock patched version?

no some code optimalisations

Some make sense.
but some don't (no offense)

The coder changed a lot of multiplies into bitshifts (good thing)
but also precalculated certain values. (like 8*1024)
That isn't needed. I tested the following:

1#include <iostream>
2
3int main(int argc,char* arv[]) {
4   std::cout << 144 << std::endl;
5   return 0;
6}

Which gave exactly the same results as:

1#include <iostream>
2
3int main(int argc,char* arv[]) {
4   std::cout << 12*12 << std::endl;
5   return 0;
6}

the resulting execatables were the same. Maybe this isn't true when used in calculations.
The author frequently changed:

1if (y&1) off+=8*1024;

to

1if (y&1) off+=8192;

I doubt that makes any difference

However most of the bitshifts might work.

Futher the author implemented a jumptable FPU core.
Might be good. but it was based on 0.63 source and the current source is lot different

He might have done more things. but these were the things I noticed. while quickly browsing the source.
Those bitshits in in the main cpu loop might be a good thing to do.

Creating a seperate project seems somewhat unnecessary since the effort could be spent on improving official code. Also, current compilers make such code changes unnecessary as well - a simple line a = a * 1024 will compile into SAL 10 so compiler will optimize multiplications into bitshifts when possible (unless of course the compiler cannot see when to optimize but a good programmer can).

> Futher the author implemented a jumptable FPU core. Might be good.

...but it won't be any faster as the fpu operations are very
heavy themselves.

Still, every bit of optimization helps as long as it doesn't adversely affect the maintainability, stability, or portability of the code.

None of those optimizations can't be done by the compiler
(msvc already uses jump tables for the fpu, i assume gcc
does that as well), except for the optimized idle looping 😉
And replacing constant calculations by precalculated values
DOES affect readability.