In this directory, I'm developing some test cases to study 
some different options for Bochs performance improvements.

ideas:

write a loop or nested loop that takes some serious computing, that takes 
  maybe 15 seconds to run
benchmark on several machines
compile with optimization and understand the assembly
reimplement with switch stmt,function pointers, etc
benchmark again to measure the overhead of switch & function calls
test on several machines
reimplement with goto *label (gcc extension) style
benchmark again to measure the overhead of switch & function calls
test on several machines

or, by working more directly with the bochs source, we can test the
performance benefit of the "cut-and-paste native code" method on 
a small scale.

---------------------------------------------------
Performance measurements

blur.c 1.2
-----------
estimated 1.43 million instructions per iteration (-O2)
  (see blur-1.2-performance.gnumeric spreadsheet for details)
on Athlon 750 with no optimization, 4.0622 ms per iteration
on Athlon 750 with -O2, 1.795138 ms per iteration
on P2 350 with no optimization, 6.162224 ms per iteration
on P2 350 with -O2, 2.5258 ms per iteration
on Bochs with -O2 on Athlon 750, 478 ms per iteration

Conclusion
Bochs is about 270x slower than native code.

Try replacing the innermost loop of blur() with a function call
that does the same thing.  Continue to compile with -O2.

if innermost loop is "sum += array[x2][y2]", 1.796 ms per iter.
if innermost loop is "blur_func (&sum, &array[x2][y2])", 3.526978 ms per iter.
function with three arguments: 3.784
function with four arguments: 4.390
function with five arguments: 4.879

what is the overhead in terms of instructions?
func_overhead(N, ARGS) for N instructions in the function, ARGS arguments
F(N, ARGS) = ?
  1.5*ARGS to push them onto the stack
  1 for the call
  1 to set %esp back to normal
  1.5*ARGS to load it into a register and maybe save the old register value
  2 for leave & ret
  
  = 4 + 3*ARGS   instructions

This is ignoring the fact that some CISC instructions are much more expensive
than others.

However when you measure the time cost of the function call, it is
much larger.

Compare blur with no function call to blur with a call to a function with
2 arguments.  1.796 ms per iter versus 3.526978 ms per iter.  The function
was called 142884 times, so the overhead of each function call is
12.1 ns.  (In 12.1 ns this machine can execute between 9-10 instructions.)

I briefly tested the overhead of function calls of 2,3,4,5 arguments.
This should measure the difference between NO function call (inline function)
and a function call with N arguments.

2 args: 12.1 ns more than no function call
3 args: 13.91 ns more than no function call
4 args: 18.15 ns more than no function call
5 args: 21.58 ns more than no function call

Based on measurements, maybe the func_overhead should be
func_overhead(ARGS) = 4 + 2.5*ARGS instructions


Measure the cost of a switch statement.
With no switch statement, around 1.84 ms per iteration.
With 2 case switch+default, 2.3867 ms.
With 3 case switch+default, 3.739635 ms.
With 4 case switch, 3.341807 ms.   (successive compares)
With 8 case switch, 2.241196 ms.   (jump table)
With 16 case switch, 3.122807 ms.  (jump table)
With 32 case switch, 3.080882 ms.  (jump table)

Once you have enough cases that gcc creates a jump table, the
cost of a switch statement is about 7 instructions.

Try with a bunch of function calls in a switch stmt.


blur-O2                 1.798693 ms
blur-O2-func            3.309882 ms
blur-O2-switch          3.101132 ms
blur-O2-switch-call     2.667050 ms
blur-O2-fnptr-switch    8.669802 ms
blur-O2-fnptr-table     6.010503 ms



;;;;;;;;;;;blur.c revision 1.2, compiled with -O2 -S;;;;;;;;;;;;
;; with some annotations by Bryce to figure out what is what.

	.file	"blur.c"
	.version	"01.01"
gcc2_compiled.:
.text
	.align 4
.globl blur
	.type	 blur,@function
blur:
	pushl %ebp
	movl %esp,%ebp
	subl $36,%esp
	pushl %edi
	pushl %esi
	pushl %ebx
	movl $1,%eax
	.p2align 4,,7
.L20:
	movl $1,%edi
	leal -1(%eax),%ebx
	movl %ebx,-28(%ebp)
	leal 1(%eax),%ebx
	movl %ebx,-16(%ebp)
	sall $9,%eax
	movl %eax,-24(%ebp)
	movl %ebx,-8(%ebp)
	movl -28(%ebp),%ebx
	movl %ebx,-32(%ebp)
	sall $9,-32(%ebp)
	.p2align 4,,7
.L24:
	xorl %esi,%esi                 ; let %esi = sum
	movl -28(%ebp),%ecx
	leal 1(%edi),%ebx
	movl %ebx,-20(%ebp)
	cmpl -8(%ebp),%ecx
	jg .L26


	movl %ebx,-12(%ebp)
	movl -16(%ebp),%ebx
	movl %ebx,-4(%ebp)
	movl -32(%ebp),%ebx
	movl %ebx,-36(%ebp)
	.p2align 4,,7
.L28:
	leal -1(%edi),%edx            ; let %edx = y2
	cmpl -12(%ebp),%edx           ; test if y2 
	jg .L27


	;; build pointer in %eax to array[x2][y2]
	movl -36(%ebp),%eax
	addl $array,%eax
	leal (%eax,%edx,4),%eax
	.p2align 4,,7

.L32:
	;; innermost loop. it has precomputed the endpoint in -20(%ebp)
	addl (%eax),%esi               ;; sum += (%eax)
	addl $4,%eax                   ;; point %eax to next value
	incl %edx                      ;; y2++
	cmpl -20(%ebp),%edx            ;; if y2<=max
	jle .L32

.L27:
	addl $512,-36(%ebp)
	incl %ecx
	cmpl -4(%ebp),%ecx
	jle .L28

.L26:
	movl -24(%ebp),%ebx
	leal (%ebx,%edi,4),%eax
	movl %esi,array2(%eax)
	movl -20(%ebp),%edi
	cmpl $126,%edi
	jle .L24

	movl -16(%ebp),%eax
	cmpl $126,%eax
	jle .L20

	leal -48(%ebp),%esp
	popl %ebx
	popl %esi
	popl %edi
	leave
	ret
.Lfe1:
	.size	 blur,.Lfe1-blur
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
----------------------------------


blur-opcode.c

In a past email, I described a way to use gcc and gas to produce
native code, so that Bochs would not need its own code generator for
every supported platform.  I will attempt a proof of concept here.

I will try to create a system in which snippets of C++ code can be compiled
by gcc, then extracted to form a chunk of native binary code.  The chunks
will be designed so that they can be pasted together efficiently.

I haven't tried anything like this before....