Re: Skybuck presents alternative division method, to be benchmarked ;)

Ok,

This one slightly faster.

However the leading zero count assembler function can't be inlined so this

means calling overhead is added.

To bad ;)

Still it's slightly faster than the previous general function.

I am just too lazy to write a pascal version which searches for the first 
bit set.

I am gonna try that next... lol me so lazy :)

// not sure if this assembler version will always work if compiler changes
// but so far it seems to work ok ;) :)
// to bad it can't be inlined... maybe try that later.
function LeadingZeroCount( const Value : longword ) : longword;
asm
 push ebx
 bsr ebx,eax
 mov eax,32
 jz @[EMAIL PROTECTED]
  sub eax,ebx
  dec eax
 @[EMAIL PROTECTED]
 pop ebx
end;

// general version just out of curiosity...
function SimulatedDivGeneralV2( Content : longword; Divisor : longword ) :

longword; inline;
var
 vLeadingZeroCount : byte;
 v****fter : byte;
 vDivisions : longword;
 vBiggerDivisor : longword;
 vAnder : longword;
 vDivisorDifference : longword;
begin
 result := 0;  // latency 1

 // replacement
 vLeadingZeroCount := LeadingZeroCount( Divisor );
 v****fter := 32 - vLeadingZeroCount;
 vBiggerDivisor := 1 shl v****fter;
 vAnder := $FFFFFFFF shr vLeadingZeroCount;

 vDivisorDifference := vBiggerDivisor - Divisor;

 // main algorithm
 while Content > vBiggerDivisor do // latency 1 + latency 1 = latency 2
 begin
  vDivisions := (Content shr v****fter); // latency 1 + latency 1 = latency
2
  Content := (Content and vAnder) + vDivisions * vDivisorDifference; // 
latency 1 + latency 1 = latency 2
  result := result + vDivisions; // latency 1
 end;

 // single loop latency: 2 + 2 + 2 + 1 = 7
 if Content >= Divisor then // latency 1 + latency 1 = latency 2
 begin
  result := result + 1; // latency 1
 end;

 // best case latency: 1 + 7 + 3 = 11
 // worst case latency (max loops 11 for 32 bit longwords): 1 + 7 * 11 + 3
= 
81

 // very close to div 7, though this routine is probably directpath mostly

and not vector path
 // so maybe it's faster... but then again still some calling overhead.. 
let's see what happens
 // when it's inlined ;)
 // yup inlining works real nice.

 // time for a benchmark :)

 // tested on amd x2 3800+
 // for content values ranging from say 1000 to even a million this
routine 
appears
 // to be faster than the div... kinda nice.

 // general routine is slower... didn't bother to optimize it or so ;)
end;

Bye,
  Skybuck.