Speed test: Faster Plots, Lines, and Rects

BlitzMax Forums/OpenGL Module/Speed test: Faster Plots, Lines, and Rects

EOF	(Posted 2010) [#1]

*EDIT: Code demo now with additional standard IO printout and Fast Rand (From Zeke)

GL coders

Can you run the code below and let me know if you see much of a speed difference between regular BlitzMax Plot, DrawLine, DrawRect vs the batch-processed versions in the demo?
What I mean by batch-processed is, drawing is done within a BEGIN2D .. END2D block to cut out a little overhead

In my testing I typically see the Line routine to be somewhere like twice as fast but the Plotting and quads, although faster, aren't significantly so

BTW I don't know much about OpenGL so feel free to comment about the commands used. Especially if you know even quicker methods

' GL 2D drawing speed test
' Plot, DrawLine, DrawRect vs Fast alternatives

SuperStrict
Framework BRL.GLMax2D
Import BRL.Random
Import BRL.StandardIO

Extern "C"
	Function FSeedRnd:Int(val:Int) = "srand"
	Function _crand:Int () = "rand"
End Extern

FSeedRnd MilliSecs()

Const width%=640 , height%=480
Const numPlots%=250000 , numLines%=150000 , numRects%=80000
' timer-related variables
Global t%,nPlot%,fPlot%,nLine%,fLine%,nRect%,fRect%

Graphics width,height,0

' batch vs standard tests
SetColor 100,50,50
SpeedTest "PLOT" , 0 ; fPlot=MilliSecs()-t
SpeedTest "PLOT" , 1 ; nPlot=MilliSecs()-t
SetColor 50,100,50
SpeedTest "LINE" , 0 ; fLine=MilliSecs()-t
SpeedTest "LINE" , 1 ; nLine=MilliSecs()-t
SetColor 50,50,100
SpeedTest "RECT" , 0 ; fRect=MilliSecs()-t
SpeedTest "RECT" , 1 ; nRect=MilliSecs()-t
Delay 500
SetColor 200,200,200

Function SpeedTest(tst$,mode%)
	Cls
	t=MilliSecs()
	Local n%
	'
	If mode=0 ' ----------- FAST  -------------
		Select tst
			Case "PLOT"
				Begin2D(GL_POINTS)
				For n=1 To numPlots
					rndc
					FastPlot Rand(width),Rand(height)
				Next
				End2D
			Case "LINE"
				Begin2D(GL_LINES)
				For n=1 To numLines
					rndc
					FastLine Rand(width),Rand(height),Rand(width),Rand(height)
				Next
				End2D
			Case "RECT"
				Begin2D(GL_QUADS)
				For n=1 To numRects
					rndc
					FastRect Rand(width),Rand(height),Rand(100),Rand(100)
				Next
				End2D
		End Select
	Else ' ----------- STANDARD -----------------
		Select tst
			Case "PLOT"
				For n=1 To numPlots
					rndc
					Plot Rand(width),Rand(height)
				Next
			Case "LINE"
				For n=1 To numLines
					rndc
					DrawLine Rand(width),Rand(height),Rand(width),Rand(height)
				Next
			Case "RECT"
				For n=1 To numRects
					rndc
					DrawRect Rand(width),Rand(height),Rand(100),Rand(100)
				Next
		End Select
	EndIf
	'
	Flip
End Function


' _________________________________________________

Cls
txt "Number of dots = "+String(numPlots)
txt "  Fast plot (m/secs)= "+String(fPlot)
txt "Normal plot (m/secs)= "+String(nPlot)
txt "---"
txt "Number of lines = "+String(numLines)
txt "  Fast line (m/secs)= "+String(fLine)
txt "Normal line (m/secs)= "+String(nLine)
txt "---"
txt "Number of rects = "+String(numRects)
txt "  Fast rect (m/secs)= "+String(fRect)
txt "Normal rect (m/secs)= "+String(nRect)
Flip
WaitKey
End

Function txt(m$)
	Global y%=5
	DrawText m,4,y ; y:+22
	Print m
End Function


' _________________________________________________

Function FastPlot(x%,y%)
	glVertex2f x,y
End Function

Function FastLine(x1%,y1%,x2%,y2%)
	glVertex2f x1,y1 ; glVertex2f x2,y2
End Function

Function FastRect(x%,y%,w%,h%)
	glVertex2f x,y ; glVertex2f x+w,y
	glVertex2f x+w,y+h ; glVertex2f x,y+h
End Function


Function Begin2D(mode%)
	glDisable GL_TEXTURE_2D ; glBegin mode
End Function

Function End2D()
	glEnd ; glEnable GL_TEXTURE_2D	
End Function

Function rndc()
	SetColor FRand(0,255),FRand(0,255),FRand(0,255)
End Function

'Faster Rand() function, range 0-32768
Function FRand:Int (s:Int,e:Int)
	Return _crand() Mod (e-s+1)+s
End Function

_Skully

(Posted 2010) [#2]

Number of dots = 250000

Fast plot (m/secs)= 532

Normal plot (m/secs)= 640

---

Number of lines = 150000

Fast line (m/secs)= 403

Normal line (m/secs)= 534

---

Number of rects = 80000

Fast rect (m/secs)= 287

Normal rect (m/secs)= 252

SLotman

(Posted 2010) [#3]

DebugLog:Number of dots = 250000
DebugLog: Fast plot (m/secs)= 440
DebugLog:Normal plot (m/secs)= 596
DebugLog:---
DebugLog:Number of lines = 150000
DebugLog: Fast line (m/secs)= 395
DebugLog:Normal line (m/secs)= 535
DebugLog:---
DebugLog:Number of rects = 80000
DebugLog: Fast rect (m/secs)= 262
DebugLog:Normal rect (m/secs)= 247

(I changed the code to output on debug window, easier to copy results here)

Here rects are marginally slower with your code, dots a little bit faster and lines faster.

degac

(Posted 2010) [#4]

Debug on
Number of dots = 250000
Fast plot (m/secs)= 482
Normal plot (m/secs)= 654
---
Number of lines = 150000
Fast line (m/secs)= 357
Normal line (m/secs)= 646
---
Number of rects = 80000
Fast rect (m/secs)= 386
Normal rect (m/secs)= 203

Debug OFF
Number of dots = 250000
Fast plot (m/secs)= 156
Normal plot (m/secs)= 268
---
Number of lines = 150000
Fast line (m/secs)= 155
Normal line (m/secs)= 293
---
Number of rects = 80000
Fast rect (m/secs)= 79
Normal rect (m/secs)= 109

Hardware specs in sig

Zeke	(Posted 2010) [#5]

Blitz rand:
fast Plot = 164
normal Plot = 360

fast line = 145
normal line = 353

fast rect = 84
normal rect = 147

FastRand:
fast Plot = 84
normal Plot = 306

fast line = 69
normal line = 305

fast rect = 47
normal rect = 107

FastRand version:

' GL 2D drawing speed test
' Plot, DrawLine, DrawRect vs Fast alternatives

SuperStrict
Framework BRL.GLMax2D
Import BRL.Random

Extern "C"
	Function crndseed:Int(val:Int) = "srand"
	Function _crand:Int () = "rand"
End Extern

Function FastRand:Int (start:Int, ende:Int) 'Faster Rand() function, range 0-32768
	Return _crand() Mod (ende-start+1) + start
EndFunction

crndseed(MilliSecs())

Const width%=640 , height%=480
Const numPlots%=250000 , numLines%=150000 , numRects%=80000
' timer-related variables
Global t%,nPlot%,fPlot%,nLine%,fLine%,nRect%,fRect%

Graphics width,height,0

' batch vs standard tests
SetColor 100,50,50
SpeedTest "PLOT" , 0 ; fPlot=MilliSecs()-t
SpeedTest "PLOT" , 1 ; nPlot=MilliSecs()-t
SetColor 50,100,50
SpeedTest "LINE" , 0 ; fLine=MilliSecs()-t
SpeedTest "LINE" , 1 ; nLine=MilliSecs()-t
SetColor 50,50,100
SpeedTest "RECT" , 0 ; fRect=MilliSecs()-t
SpeedTest "RECT" , 1 ; nRect=MilliSecs()-t
Delay 500
SetColor 200,200,200

Function SpeedTest(tst$,mode%)
	Cls
	t=MilliSecs()
	Local n%
	'
	If mode=0 ' ----------- FAST  -------------
		Select tst
			Case "PLOT"
				Begin2D(GL_POINTS)
				For n=1 To numPlots
					rndc
					FastPlot FastRand(0,width),FastRand(0,height)
				Next
				End2D
			Case "LINE"
				Begin2D(GL_LINES)
				For n=1 To numLines
					rndc
					FastLine FastRand(0,width),FastRand(0,height),FastRand(0,width),FastRand(0,height)
				Next
				End2D
			Case "RECT"
				Begin2D(GL_QUADS)
				For n=1 To numRects
					rndc
					FastRect FastRand(0,width),FastRand(0,height),FastRand(0,100),FastRand(0,100)
				Next
				End2D
		End Select
	Else ' ----------- STANDARD -----------------
		Select tst
			Case "PLOT"
				For n=1 To numPlots
					rndc
					Plot FastRand(0,width),FastRand(0,height)
				Next
			Case "LINE"
				For n=1 To numLines
					rndc
					DrawLine FastRand(0,width),FastRand(0,height),FastRand(0,width),FastRand(0,height)
				Next
			Case "RECT"
				For n=1 To numRects
					rndc
					DrawRect FastRand(0,width),FastRand(0,height),FastRand(0,100),FastRand(0,100)
				Next
		End Select
	EndIf
	'
	Flip
End Function


' _________________________________________________

Cls
txt "Number of dots = "+String(numPlots)
txt "  Fast plot (m/secs)= "+String(fPlot)
txt "Normal plot (m/secs)= "+String(nPlot)
txt "---"
txt "Number of lines = "+String(numLines)
txt "  Fast line (m/secs)= "+String(fLine)
txt "Normal line (m/secs)= "+String(nLine)
txt "---"
txt "Number of rects = "+String(numRects)
txt "  Fast rect (m/secs)= "+String(fRect)
txt "Normal rect (m/secs)= "+String(nRect)
Flip
WaitKey
End

Function txt(m$)
	Global y%=5
	DrawText m$,4,y ; y:+22
End Function


' _________________________________________________

Function FastPlot(x%,y%)
	glVertex2f x,y
End Function

Function FastLine(x1%,y1%,x2%,y2%)
	glVertex2f x1,y1 ; glVertex2f x2,y2
End Function

Function FastRect(x%,y%,w%,h%)
	glVertex2f x,y ; glVertex2f x+w,y
	glVertex2f x+w,y+h ; glVertex2f x,y+h
End Function


Function Begin2D(mode%)
	glDisable GL_TEXTURE_2D ; glBegin mode
End Function

Function End2D()
	glEnd ; glEnable GL_TEXTURE_2D	
End Function

Function rndc()
	SetColor FastRand(0,255),FastRand(0,255),FastRand(0,255)
End Function

degac

(Posted 2010) [#6]

@Zeke: the RAND built-in function in BlitzMax is so slow?!? 40ms? Interesting

EOF	(Posted 2010) [#7]

(I changed the code to output on debug window, easier to copy results here)

Here rects are marginally slower with your code, dots a little bit faster and lines faster

Updated code with additional Print() output
Yes, I find the standard Rect sometimes reports a faster time but upon re-running the code several times the FastRect wins out (marginally)

It's interesting how the Line drawing seems to be the big winner here

Noobody

(Posted 2010) [#8]

@Zeke: the RAND built-in function in BlitzMax is so slow?!? 40ms? Interesting

Rand in BMax uses RndDouble(), maps the result to the interval (min, max) and casts it to Int.

This means that a call to Rand() involves a call to a normal random generator, a double division, a double multiplication and a cast from double to int. This is of course much slower than rand in C/++, which will most probably only use integers.

However, there's a problem with both functions. RndDouble() divides by 2^29 at the end (to map the integer value in range 0.0!-1.0!). This implies that the random number generated is only in range 0-2^29. If I were to call Rand( 2^31 ), only a fourth of the numbers in range can be actually generated. This is pretty bad.

On the other hand, the quality of rand in the cstdlib greatly depends on the implementation, but in a lot of cases the quality is poor. It will also only generate numbers in range of 0-RANGE_MAX. The value of RANGE_MAX depends on the implementation, but it is granted to be at least 32767 (and you shouldn't bet on more than that). 32767 is only 2^15, not enough for a lot of cases.

That's why I propose reimplementing BRL.Random with something faster and more exact (=covering all 32 bits). It doesn't have to be a fancy Mersenne Twister; a simple Multiply-with-carry would suffice, which is really easy to implement.