ImageTransform vs Concatenate execution time
Thu, 06/29/2023 - 02:48 am
Hi all,
I was testing what is the fastest way to stack 2d waves. I did a comparison between "ImageTrasnform stackImages" and "Concatenate".
I used the following code.
variable i
for(i = 0;i < nn; i++)
Make/O/N=(4096,4096) $("wname_" + num2str(i))
endfor
return 0
End
Function MakeTheWaveRefs(variable nn)
variable i
Make/O/N=(nn)/WAVE mxpwaveRef
for(i = 0;i < nn; i++)
mxpwaveRef[i] = $("wname_" + num2str(i))
endfor
return 0
End
Function [variable tN0, variable tP0, variable tN1, variable tP1] timerFunction(variable nn)
MakeTheWaves(nn)
MakeTheWaveRefs(nn)
WAVE/T mxpwaveRef
variable tm00=stopmstimer(-2)
ImageTransform/NP=(nn) stackImages $"wname_0"
variable tm01=stopmstimer(-2)
variable tm10=stopmstimer(-2)
Concatenate/O/NP=2 {mxpwaveRef}, M_Concatenate
variable tm11=stopmstimer(-2)
tN0 = (tm01-tm00)/1e6
tN1 = (tm11-tm10)/1e6
// Now all stacks are pre-allocated, redo the operations
tm00=stopmstimer(-2)
ImageTransform/NP=(nn) stackImages $"wname_0"
tm01=stopmstimer(-2)
tm10=stopmstimer(-2)
Concatenate/O/NP=2 {mxpwaveRef}, M_Concatenate
tm11=stopmstimer(-2)
tP0 = (tm01-tm00)/1e6
tP1 = (tm11-tm10)/1e6
KillWaves/A/Z
return [tN0, tP0, tN1, tP1] // 0 = ImageTransform, 1 = Concatenate
End
Function RunTheTest(int startN, int stopN, int stepN) // Entry point
variable nn, i, tN0, tP0, tN1, tP1
string dataFolderName = "TestResults_" + num2str(startN) + "_" + num2str(stopN) + "_" + num2str(stepN)
NewDataFolder/O $dataFolderName
DFREF dfr = $dataFolderName
int sizeN = (stopN - startN)/stepN + 1
Make/N=(sizeN) dfr:results_CN /WAVE=wcn
Make/N=(sizeN) dfr:results_IT /WAVE=wit
Make/N=(sizeN) dfr:results_CN_Pre /WAVE=wcnP
Make/N=(sizeN) dfr:results_IT_Pre /WAVE=witP
SetScale/P x, startN, stepN, "Nr. Images", wcn, wcnP, wit, witP
for(nn = startN; nn < stopN + 1; nn += stepN)
[tN0, tP0, tN1, tP1] = timerFunction(nn)
wcn[i] = tN1
wit[i] = tN0
wcnP[i] = tP1
witP[i] = tP0
i++
endfor
End
You can see the comparison between ImageTransform and Concatenation in the graphs (green and black line, respectively). I found most interesting the comparison between times depending whether the destination wave is already present.
Concatenation seems to perform the same (or worse!) when the destination wave is already there (haven't test the effect of the absence of flag /O).
On the other hand, ImageTransform stackImages has considerable gain for images of size (512 x 512) and is faster most of the times for (4096 x 4096) images. Strangely enough I see a reversal of this trend when I try to stack 50-80 images.
Are these results expected or I miss something here?
Cheers,
My system
MacBookPro 2020 - 2,3 GHz Quad-Core Intel Core i7, 16 GB 3733 MHz LPDDR4X.
IGORVERS:9.03
BUILD:40067
IGORKIND:pro64
FREEMEM:1130721280
PHYSMEM:17179869184
USEDPHYSMEM:488624128
NSCREENS:2
SCREEN1:DEPTH=32,RECT=0,0,2560,1440
SCREEN2:DEPTH=32,RECT=2560,70,4000,970
OS:macOS
OSVERSION:13.4.1
LOCALE:US
IGORFILEVERSION:9.03B01
The fact that your Concatenate "pre-allocated" case is slower than your "Created" case is due to you assuming that Concatenate/O works differently than it does.
I think you are assuming that if the output wave already exists and is the correct size, memory doesn't need to be reallocated and therefore the operation should complete faster. That's not a crazy assumption, but it's wrong. Surprisingly, the actual behavior is even documented in the Details section of the Concatenate topic:
Perhaps "destWave is created..." should be changed to "destWave is [re]created..." to make it slightly more clear what is happening.
ImageTransform stackImages works differently in the case when the output wave already exists. It calls an internal command to make the output wave of the correct size and type, but if the output wave already exists and is already the correct size and type this is almost a no-op.
Your findings with the ~100 layer large images are also explainable. A 4096x4096x100 image of single precision floating point type is about 6.7 GB. That's just for the output, and you have the same number of bytes in your input waves. So that's over 13 GB of memory needed. According to your system info you have 16 GB RAM, so you're likely getting into the need for virtual memory somewhere around 75 layers.
On my machine (Windows 11, Intel 12900KS processor, 64GB RAM), I'm getting times that are close to 10x faster than yours. But I'm also seeing that the "Clean" case of ImageTransform is slower than the "clean" Concatenate case (tested only with 20 and 100 layers). I think your last graph shows the "clean" case of both operations, and if so you don't see quite the same thing. Looking at the code that executes it makes sense that ImageTransform would be slower in the "clean" case, but the explanation is getting into the weeds and some of the difference might be due to how memory allocation works on macOS vs. Windows.
June 29, 2023 at 09:19 am - Permalink