ASM Community

I've created a "mult" macro that replaces (in some cases)
the slower "imul" instruction. (max 5 times faster than imul)

Currently, it supports all numbers between 0 and 50, and some others.

You can get it from www.beotel.net/~astancic (click on "Multiply.inc")

I disagree.

Writing a 'separate' macro for every number needed is, AFAIK,
simply the fastest method to MUL reg with a number.

I've created a list with all the numbers between 0-50, just
to see how it works, that doesn't mean that I need all of them.

In the future, I'll just add the numbers that I need.

For example, now I need to mul with 4000:
lea reg,
lea reg,
lea reg,
shl reg,5 ;(5*5*5*32)
can you make it faster than that? (its 44% faster than IMUL)

I have always been interested in the fractions and the percentages that people give. 44%? Where did you get the numerator and the denominator that have made that percentage?

Now about the actual code, the code that you gave:

  LEA     EAX , 
  LEA     EAX , 
  LEA     EAX , 
  SHL     EAX , 5

Takes 3 clock cycles to execute on my PIII 800MHZ with the code segment aligned on a DWORD boundary. The equivalent of this code using IMUL:

   IMUL     EAX , EAX , 4000

Takes 1 clock cycle on the same machine to execute. Now if the value that has to be multiplied is in a variable, your code will take 13 clock cycles to execute:

  MOV     EAX , DWORD PTR 
  LEA     EAX , 
  LEA     EAX , 
  LEA     EAX , 
  SHL     EAX , 5
  MOV     DWORD PTR  , EAX

this is while the equivalent of this code using IMUL will take 12 clock cycles on the same machine with the same conditions:

  IMUL    EAX , DWORD PTR  , 4000
  MOV     DWORD PTR  , EAX

I just don't believe, yet, that any CPU can MUL in just one clock with a number such as 4000.
DECODE in one clock is OK, but the actual MUL...

Parallel execution (probably, I'm not sure with the IMUL instruction)
lets you do other stuff while IMUL is executing, but in my current app there's simply no other stuff to do.

Actually, I've made a mistake, it is 30%.
The numerator and denominator were given by the test prog below (MASM),
namely 150mS for the IMUL and 105mS for the macro.

;___________________________________________________________________________________________________________________________
number equ 4000

Start proc public
local text[128]:char
local count:UINT, count1:UINT, count2:UINT
local rez1:dword, rez2:dword

;---------------------------------------------------------------------------------------------------------------------------
status , GetTickCount ;invoke GetTickCount: mov , eax

mov eax,3
mov ecx,2500000
@@: imul eax,number
djnz ecx, @B ;DEC, JNZ

mov , eax

invoke GetTickCount
sub eax,
mov ,eax

;---------------------------------------------------------------------------------------------------------------------------
status , GetTickCount

mov eax,3
mov ecx,2500000
@@: mult eax,number
djnz ecx, @B

mov , eax

invoke GetTickCount
sub eax,
mov ,eax

;---------------------------------------------------------------------------------------------------------------------------
% invoke wsprintf, a text, qt2(<'number=%u', cr,lf,cr,lf, 'imul = %u, mult = %u', cr,lf,cr,lf, 'rez1=%u', cr,lf, 'rez2=%u'>), number, , , ,
invoke MessageBox, null, a text, qt2('Test'), null
ret
Start endp
;___________________________________________________________________________________________________________________________
end Start

You forgot to set Realtime priority first and the number of iterations are very few to get a conclution. Besides, the loops are not aligned so perhaps one of them is enjoying a better alignment than the other.

The flat assembler program below gives me this


The flat assembler program below gives me this

include 'win32axp.inc'

number equ 4000

proc Start
local text[128]:BYTE,\
      count:DWORD, count1:DWORD, count2:DWORD,\
      rez1:DWORD, rez2:DWORD,\
      ProcessAffinityMask:DWORD, SystemAffinityMask:DWORD

      push     ebx esi

      invoke   GetCurrentProcess
      mov      ebx, eax
      invoke   SetPriorityClass, eax, REALTIME_PRIORITY_CLASS
      invoke   GetCurrentThread
      invoke   SetThreadPriority, eax, THREAD_PRIORITY_TIME_CRITICAL

;;;; On multi-{core|CPU} systems is required to set affinity as well but I don't have one :D
;;;; f0dder insisted in adding it anyway so here it is :P

      invoke   GetProcessAffinityMask, ebx, addr ProcessAffinityMask, addr SystemAffinityMask
      test     eax, eax
      jz       .letThePartyBegin

; Lets choose only one of the processors allowed for this process
      mov      esi, 1
      bsf      ecx, 
      shl      esi, cl

; Now, since Win9x/Me is smart enough to have GetProcessAffinityMask but not its counterpart we must check its existence first

      invoke   LoadLibrary, 'KERNEL32.DLL'
      test     eax, eax
      jz       .letThePartyBegin

      invoke   GetProcAddress, eax, 'SetProcessAffinityMask'
      test     eax, eax
      jz       .letThePartyBegin

      stdcall  eax, ebx, esi

.letThePartyBegin:
      invoke Sleep, 20 ; Lets get a fresh slice
;---------------------------------------------------------------------------------------------------------------------------
      invoke GetTickCount
      mov    , eax

      mov   eax,3
      mov   ecx, $10000000

align 16
@@:
      imul   eax,number
      dec    ecx
      jnz    @B

      mov   , eax

      invoke   GetTickCount
      sub      eax,
      mov      ,eax

      invoke Sleep, 20 ; Lets get a fresh slice
;---------------------------------------------------------------------------------------------------------------------------
      invoke GetTickCount
      mov    , eax

      mov   eax,3
      mov   ecx, $10000000

@@:
reg equ eax
      lea   reg,
      lea   reg,
      lea   reg,
      shl   reg,5         ;(5*5*5*32)
restore reg

      dec    ecx
      jnz    @B

      mov   , eax

      invoke   GetTickCount
      sub   eax,
      mov   ,eax

;---------------------------------------------------------------------------------------------------------------------------
      invoke   wsprintf, addr text, fmt, number, , , , 
      invoke   MessageBox, NULL, addr text, 'Test', NULL

      pop      esi ebx
      ret
endp

fmt db 'number=%u', 13, 10, 13, 10, 'imul = %u, mult = %u', 13, 10, 13, 10, 'rez1=%u', 13, 10, 'rez2=%u',0
;___________________________________________________________________________________________________________________________
.end Start

I got the red warning before posting telling me that Ultrano already posted something but I couldn't resist myself to post my version :P

Since f0dder disliked my laziness now it also takes care about affinity ;)

Fixed a big mess I did (apparently I did :?) with tags

Yes, I remember your advice from the other forum but seems that my disclaimer was not enough to avoid the suggestion ;)

I added it, but I can't assure if it is right because I don't remember how you did it.

I agree with codename. Imho aleksaZR's macro just needs polishing:
1) we should see the speed results of all supported numbers in mult, compared to imul. Like the ones I posted. Though, in my case I simply spent several minutes recompiling and running the app for each number ^^. The needed data to obtain this way is - with which numbers mult is faster than imul on all/most cpus.
2) change the mult macro to support only the faster-than-imul versions
3) also make a mult2 macro, which accepts 3 parameters (dest,temp,imm) - where "temp" will remove the need for stack-usage. This optimization won't be noticed as an improvement in the synthetic benchmarks, but can give an extra cycle or two (we save the write-back to memory, after all).

hello Aleksandre,
i also wrote a mul replacement recursive macro.
might be useful.
http://www.asmcommunity.net/board/index.php?topic=20441.0