Bunny Mark Performance

Shin-NiL

This was already expected, since Lua is one of the fastest scripting languages we have out there. I agree there is room for improvement in GDScript. At least GDScript is on par with Python in this case :wink:

_807_

Other:

godot 3.0 fixnum win build 13/06/2017. Visual Script- 10x3200x3200 iterations test (editor preview- "for loop" approach): Results: 2 min 9 sec. VScript loses vs GDscript: 3.5 times slow in 10x3200x3200 test.

I don´t know c or c++, but it could be cool to do the test in GDNative and/or in module... to know exactly the basic loop computation up with both.

I can´t paste the code... there are rectangles :D

Shin-NiL

I opened an issue about our discussion.

_807_

More test about GDscript and access to API velocity. Done in editor preview. Sorry about code repetition but is performance test and function call (like test say) have a bit of overload.

The test:

extends Node2D

const numberofiterations = 1000000

var InitTimer
var EndTimer
const BasicNumber1 = 1
const BasicNumber2 = 2
var VarNumber1 = 1
var VarNumber2 = 2
var FloatNumber1 = 1.06542315654
var FloatNumber2 = 2.35684456213
const VectorNumber = Vector2(2,2)
enum {NUMBER1 = 1, NUMBER2 = 2}
var result = 0

func _ready():
	print ("___________________________________________________________")
	print ("GODOT 2.1.3. Velocity GDSCript and API function access test")
	print ("___________________________________________________________")
	print ("0- CONSTANTS INT " +str(numberofiterations)+" x2 SUM iteration")
	
	result = 0
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		result += BasicNumber1
		result += BasicNumber2
	EndPerformanceTest()
	
	print ("\n1-INT VAR " +str(numberofiterations)+" x2 SUM iteration")
	result = 0
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		result += VarNumber1
		result += VarNumber2
	EndPerformanceTest()
	
	print ("\n2-FLOAT VAR " +str(numberofiterations)+" x2 SUM iteration")
	result = 0
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		result += FloatNumber1
		result += FloatNumber2
	EndPerformanceTest()

	print ("\n3-ENUM CONST " +str(numberofiterations)+" x2 SUM iteration")
	result = 0
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		result += NUMBER1
		result += NUMBER2
	EndPerformanceTest()

	print ("\n4-VECTOR2 sum VEC2CONST " +str(numberofiterations)+" x1 SUM iteration")
	result = Vector2()
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		result += VectorNumber
	EndPerformanceTest()

	print ("\n5-VECTOR2 sum VEC2CONST to members " +str(numberofiterations)+" independent XY SUM iteration")
	result = Vector2()
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		result.x += VectorNumber.x
		result.y += VectorNumber.y
	EndPerformanceTest()

	print("\n6-FUNCTIONCALL SUM IN SCRIPT GLOBAL VAR " +str(numberofiterations)+" x2 ITERATIONS")
	result = 0
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		SUM2Numbers(VarNumber1,VarNumber2)
	EndPerformanceTest()

	print("\n7-SET_POS NO CHANGES OPERATION " +str(numberofiterations)+" ITERATIONS")
	result = 0
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		set_pos(Vector2(0,0))
	EndPerformanceTest()

	print("\n8-GET_POS NO CHANGES OPERATION " +str(numberofiterations)+" ITERATIONS")
	print("")
	result = 0
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		var pos = get_pos()
	EndPerformanceTest()

	print("\n9-SET_POS Node2D X+CONST Y+CONST " +str(numberofiterations)+" ITERATIONS")
	result = 0
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		set_pos(get_pos()+Vector2(BasicNumber1,BasicNumber2))
	EndPerformanceTest()

	print("\n10-SET_POS Node2D X+CONST Y+CONST Aproach1 " +str(numberofiterations)+" ITERATIONS")
	result = 0
	InitPerformanceTest()
	var TemporalX = 0
	var TemporalY = 0
	var Temporal = Vector2()
	for i in range (1,numberofiterations):
		TemporalX += BasicNumber1
		TemporalY += BasicNumber2
		Temporal = Vector2(TemporalX,TemporalY)
		set_pos(get_pos()+Temporal)
	EndPerformanceTest()

	print("\n11-SET_POS Node2D X+CONST Y+CONST Aproach2 " +str(numberofiterations)+" ITERATIONS")
	result = 0
	InitPerformanceTest()
	var TemporalX = 0
	var TemporalY = 0
	for i in range (1,numberofiterations):
		TemporalX += BasicNumber1
		TemporalY += BasicNumber2
		set_pos(Vector2(get_pos().x+TemporalX,get_pos().y+TemporalY))
	EndPerformanceTest()

	print("\n12- ARRAY APPEND " +str(numberofiterations)+" x2 ITERATIONS")
	result = Array()
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		result.append(BasicNumber1)
		result.append(BasicNumber1)
	EndPerformanceTest()

	print("\n13- ARRAY ACCESS " +str(numberofiterations*2)+" ITERATIONS")
	InitPerformanceTest()
	for i in result:
		var Temp = result[i]
	EndPerformanceTest()
	
	print("\n14- DICTIONARY APPEND " +str(numberofiterations)+" x2 ITERATIONS")
	result = {}
	InitPerformanceTest()
	for i in range (1,numberofiterations):
		result["key"+str(i)]=i
		result["key"+str(i+numberofiterations)]=i+numberofiterations
	EndPerformanceTest()

	print("\n15- DICTIONARY ACCESS " +str(numberofiterations*2)+" ITERATIONS")
	InitPerformanceTest()
	for i in result:
		var Temp = result[i]
	EndPerformanceTest()
	
func SUM2Numbers(Number1, Number2):
		result += Number1
		result += Number2

func InitPerformanceTest():
	InitTimer = OS.get_ticks_msec()
	
func EndPerformanceTest():
	EndTimer = OS.get_ticks_msec()
	print ("Operation performance: "+str(EndTimer-InitTimer)+" msec")

_807_

My result:

GODOT 2.1.3. Velocity GDSCript and API function access test

0- CONSTANTS INT 1000000 x2 SUM iteration Operation performance: 286 msec

1-INT VAR 1000000 x2 SUM iteration Operation performance: 295 msec

2-FLOAT VAR 1000000 x2 SUM iteration Operation performance: 292 msec

3-ENUM CONST 1000000 x2 SUM iteration Operation performance: 299 msec

4-VECTOR2 sum VEC2CONST1000000 x1 SUM iteration Operation performance: 192 msec

5-VECTOR2 sum VEC2CONST to members 1000000 independent XY SUM iteration Operation performance: 1361 msec

6-FUNCTIONCALL SUM IN SCRIPT GLOBAL VAR 1000000 x2 ITERATIONS Operation performance: 549 msec

7-SET_POS NO CHANGES OPERATION 1000000 ITERATIONS Operation performance: 412 msec

8-GET_POS NO CHANGES OPERATION 1000000 ITERATIONS Operation performance: 334 msec

9-SET_POS Node2D X+CONST Y+CONST 1000000 ITERATIONS Operation performance: 786 msec

10-SET_POS Node2D X+CONST Y+CONST Aproach1 1000000 ITERATIONS Operation performance: 1017 msec

11-SET_POS Node2D X+CONST Y+CONST Aproach2 1000000 ITERATIONS Operation performance: 1693 msec

12- ARRAY APPEND 1000000 x2 ITERATIONS Operation performance: 536 msec

13- ARRAY ACCESS 2000000 ITERATIONS Operation performance: 328 msec

14- DICTIONARY APPEND 1000000 x2 ITERATIONS Operation performance: 3762 msec

15- DICTIONARY ACCESS 2000000 ITERATIONS Operation performance: 747 msec

_807_

I made a export build and have several opinion notes:

·Vector2 x and y operations have optimizations that give x2 performance. Even so... direct operation in x and y members of vector 2 is 3 times slow that direct operation with float values.

·Vector2 us Vector2 direct operations have same performance that float us float direct operations. That point is good, but realy I have no idea how to take advantage of this without access sometimes vector members, to dificult to me think always in vector math and puntualy access members can lower performance more that the increment gains with direct vector manipulation.

·int us int, int us float, etc... etc... have same performance, does not matters type, "const" types gives very very very tiny "up" in performance. "enums" type too, but tiniest. Last 2 point probably are some wrong in my test, or other thing...

·Array are faster that Dictionary (probably by dictionary index). In editor array access is x2 faster, in release x3. The test is 1 million of iterators with numbers, I don´t test bigger data or other types. Array is generic array, it is assumed to be faster that typed arrays with few entries, i read this in some doc.

·What surprises me the most is the penalty of pass parameters to a function. Is not the code of functions supposed to be copied to the necessary sites when exporting? (doing the test with ten millions of simple add number iterations with and without function calling is 5 us 3 seconds, with "code replacement" in compiled script´s performance should be the same? Is not that? I'm wrong with this?)

Shin-NiL

Very interesting. So Zylann was right about Vector math operations.

_807_

Good news in Godot simple iteration test:

GODOT 3.0 Calinou 16/07/2017 alpha custom buid - Velocity GDSCript and API function access test in preview

0- CONSTANTS INT 1000000 x2 SUM iteration Operation performance: 257 msec

1-INT VAR 1000000 x2 SUM iteration Operation performance: 256 msec

2-FLOAT VAR 1000000 x2 SUM iteration Operation performance: 260 msec

3-ENUM CONST 1000000 x2 SUM iteration Operation performance: 258 msec

4-VECTOR2 sum VEC2CONST 1000000 x1 SUM iteration Operation performance: 153 msec

5-VECTOR2 sum VEC2CONST to members 1000000 independent XY SUM iteration Operation performance: 1113 msec

6-FUNCTIONCALL SUM IN SCRIPT GLOBAL VAR 1000000 x2 ITERATIONS Operation performance: 488 msec

6.1-FUNCTIONCALL funcref SUM IN SCRIPT GLOBAL VAR 1000000 x2 ITERATIONS Operation performance: 630 msec

7-SET_POS NO CHANGES OPERATION 1000000 ITERATIONS Operation performance: 322 msec

8-GET_POS NO CHANGES OPERATION 1000000 ITERATIONS Operation performance: 284 msec

9-SET_POS Node2D X+CONST Y+CONST 1000000 ITERATIONS Operation performance: 673 msec

10-SET_POS Node2D X+CONST Y+CONST Aproach1 1000000 ITERATIONS Operation performance: 930 msec

11-SET_POS Node2D X+CONST Y+CONST Aproach2 1000000 ITERATIONS Operation performance: 1496 msec

12- ARRAY APPEND 1000000 x2 ITERATIONS Operation performance: 463 msec

13- ARRAY ACCESS 2000000 ITERATIONS Operation performance: 313 msec

14- DICTIONARY APPEND 1000000 x2 ITERATIONS Operation performance: 2787 msec

15- DICTIONARY ACCESS 2000000 ITERATIONS Operation performance: 745 msec

_807_

I think that performance are very dependent from the system/version of compiler... But for now, Godot 3.0 in preview is faster that godot 2.1.3 in preview (I can´t test exports because there is no templates to this version)

user_id

Hi, I can't find anything relevant about gpu array operations (something ala arrayfire). Is it possible with gdscript ?

« Previous Page