An idea how to speed up computer programs and avoid waiting. ("event driven memory system")

No,

The program only tests the CPU L1 cache, at least that's what I think it's
doing.

So it's name: "memory test" is a bit mis leading.

It can be used to test memory though, but it would require different
settings.

I also tested memory a little bit the transactions per second would drop
back to 20 million per second or so if I remember correctly, while the gpu
could do 200 million per second which is remarkable.

For a real memory test your reasoning becomes valid and it's interesting to
note that the gpu would be faster, this does assume parallel execution of
problems/algorithms though

Also the L1 caches are usually quite small, so no where near the 8MB you
mentioned, though these are probably L2 and L3 caches and such.

Indeed those caches could be tested as well.

So it needs quite a large data set before the effects of the data caches can
be neglected

Bye,
Skybuck.

In article e.nl,
says...

I just gave Delphi XE2 a try in 64 bit mode.

I have done something like this under TP, so the code would have to be
modified for 64 bit processors. Loading a constant this way ran about 3
times faster than the equivalent FOR-loop. I still have fairly complete
units for vector- and matrix-algebra like that, if anybody is
interested.


type VektorStruc = record
Spalten : word;
Daten : array [1..MaxVektor] of float;
end;
VektorTyp = ^VektorStruc;

procedure InitVektor (var Vek : VektorTyp; Laenge : word);

{$IFDEF Deutsch} const Text = ' nicht genï¿?gend (zusammenhï¿?ngender)
Speicher'; {$ENDIF}
{$IFDEF Englisch} const Text = ' not enough (continous) memory';
{$ENDIF}

begin
if (Laenge MaxVektor) or (Laenge*SizeOf(Float)+4 MaxAvail)
then
begin
ch := FehlerMeldung(Text);
VektorError := true;
exit;
end;
GetMem(Vek, Laenge*SizeOf(Float)+4);
Vek^.Spalten := Laenge;
end;

procedure LadeKonstante (Vek : VektorTyp; C : float);

var i : word;

begin
if (Vek^.Spalten = 0) then exit;
i := SizeOf(Float);
asm
mov ax,i { AX enthï¿?lt SizeOf(float) }
les bx,[Vektor]
mov cx,word ptr es:[bx] { CX enthï¿?lt Lï¿?nge des Vektors }
add bx,2 { ES:[BX] = A.Daten[1] }
fld qword ptr C { C nach ST(0) bringen }
@ConstLoop:
fst qword ptr ES:[BX] { C nach A[j] bringen }
add bx,ax { ES:[BX] zeigt auf nï¿?chstes
Element }
loop @ConstLoop
fstp st(0) { Coprozessor-Stack aufrï¿?umen }
end;
end;

In article ,
wolfgang kern wrote:
Muscipula wrote:

IOW it makes absolutely no difference unless of course you are one of
those undesirable characters who like to reverse engineer and claim
the code as yours. I don't know, but it seems a little suspicious why
you would be frowning on such a petty issue.

my rule #1: never use foreign code!

So you don't believe in reversing Polish? :-)


Regards,
Nick Maclaren.