Bench Marking code of some type
Here's is some type of benchmark code by Zdeněk Šimek
[pbcode]
x=-1
h1$="L"
h2$="W"
h3$="K"
h=3724
repeat
x=x+1
p=p+1
if x>9999
x=0
a3=a3+1
if a3>25
a3=0
a2=a2+1
if a2>25
a2=0
a1=a1+1
endif
endif
endif
select a1
case 0
ps1$="A"
case 1
ps1$="B"
case 2
ps1$="C"
case 3
ps1$="D"
case 4
ps1$="E"
case 5
ps1$="F"
case 6
ps1$="G"
case 7
ps1$="H"
case 8
ps1$="I"
case 9
ps1$="J"
case 10
ps1$="K"
case 11
ps1$="L"
case 12
ps1$="M"
case 13
ps1$="N"
case 14
ps1$="O"
case 15
ps1$="P"
case 16
ps1$="Q"
case 17
ps1$="R"
case 18
ps1$="S"
case 19
ps1$="T"
case 20
ps1$="U"
case 21
ps1$="V"
case 22
ps1$="W"
case 23
ps1$="X"
case 24
ps1$="Y"
case 25
ps1$="Z"
endselect
select a2
case 0
ps2$="A"
case 1
ps2$="B"
case 2
ps2$="C"
case 3
ps2$="D"
case 4
ps2$="E"
case 5
ps2$="F"
case 6
ps2$="G"
case 7
ps2$="H"
case 8
ps2$="I"
case 9
ps2$="J"
case 10
ps2$="K"
case 11
ps2$="L"
case 12
ps2$="M"
case 13
ps2$="N"
case 14
ps2$="O"
case 15
ps2$="P"
case 16
ps2$="Q"
case 17
ps2$="R"
case 18
ps2$="S"
case 19
ps2$="T"
case 20
ps2$="U"
case 21
ps2$="V"
case 22
ps2$="W"
case 23
ps2$="X"
case 24
ps2$="Y"
case 25
ps2$="Z"
endselect
select a3
case 0
ps3$="A"
case 1
ps3$="B"
case 2
ps3$="C"
case 3
ps3$="D"
case 4
ps3$="E"
case 5
ps3$="F"
case 6
ps3$="G"
case 7
ps3$="H"
case 8
ps3$="I"
case 9
ps3$="J"
case 10
ps3$="K"
case 11
ps3$="L"
case 12
ps3$="M"
case 13
ps3$="N"
case 14
ps3$="O"
case 15
ps3$="P"
case 16
ps3$="Q"
case 17
ps3$="R"
case 18
ps3$="S"
case 19
ps3$="T"
case 20
ps3$="U"
case 21
ps3$="V"
case 22
ps3$="W"
case 23
ps3$="X"
case 24
ps3$="Y"
case 25
ps3$="Z"
endselect
until h1$=ps1$ and h2$=ps2$ and h3$=ps3$ and h=x
print p
sync
waitkey
end
[/pbcode]
I'm not to sure what this is testing, but here's a version that uses a On Variable goto JUMP TABLE implication as comparing Switch from C/C++ to Select/Case BASIC isn't the same structure.
On my laptop (which on has V1.64P4 on it) this about 66% faster than Select/Case version, which is about what I would expect, you can tweak the logic but that's for another day.
BenchMark Version 02 - Jump Tables
[pbcode]
; PROJECT : BenchMark Version 02 - Jump Tables
; AUTHOR : Kevin Picone
; CREATED : 20/06/2018
; EDITED : 20/06/2018
; ---------------------------------------------------------------------
; ---------------------------------------------------------------------
StartTime=Timer()
print "Benchmark started Jump Table Version"
sync
x=-1
h1$="L"
h2$="W"
h3$="K"
h=3724
repeat
x=x+1
p=p+1
if x>9999
x=0
a3=a3+1
if a3>25
a3=0
a2=a2+1
if a2>25
a2=0
a1=a1+1
endif
endif
endif
on A1 goto A1_0,A1_1,A1_2,A1_3,A1_4,A1_5,A1_6,A1_7,A1_8,A1_9,A1_10,A1_11,A1_12,A1_13,A1_14,A1_15,A1_16,A1_17,A1_18,A1_19,A1_20,A1_21,A1_22,A1_23,A1_24,A1_25
goto A1_Done
A1_0:
ps1$ = "A"
goto A1_Done
A1_1:
ps1$ = "B"
goto A1_Done
A1_2:
ps1$ = "C"
goto A1_Done
A1_3:
ps1$ = "D"
goto A1_Done
A1_4:
ps1$ = "E"
goto A1_Done
A1_5:
ps1$ = "F"
goto A1_Done
A1_6:
ps1$ = "G"
goto A1_Done
A1_7:
ps1$ = "H"
goto A1_Done
A1_8:
ps1$ = "I"
goto A1_Done
A1_9:
ps1$ = "J"
goto A1_Done
A1_10:
ps1$ = "K"
goto A1_Done
A1_11:
ps1$ = "L"
goto A1_Done
A1_12:
ps1$ = "M"
goto A1_Done
A1_13:
ps1$ = "N"
goto A1_Done
A1_14:
ps1$ = "O"
goto A1_Done
A1_15:
ps1$ = "P"
goto A1_Done
A1_16:
ps1$ = "Q"
goto A1_Done
A1_17:
ps1$ = "R"
goto A1_Done
A1_18:
ps1$ = "S"
goto A1_Done
A1_19:
ps1$ = "T"
goto A1_Done
A1_20:
ps1$ = "U"
goto A1_Done
A1_21:
ps1$ = "V"
goto A1_Done
A1_22:
ps1$ = "W"
goto A1_Done
A1_23:
ps1$ = "X"
goto A1_Done
A1_24:
ps1$ = "Y"
goto A1_Done
A1_25:
ps1$ = "Z"
A1_Done:
on A2 goto A2_0,A2_1,A2_2,A2_3,A2_4,A2_5,A2_6,A2_7,A2_8,A2_9,A2_10,A2_11,A2_12,A2_13,A2_14,A2_15,A2_16,A2_17,A2_18,A2_19,A2_20,A2_21,A2_22,A2_23,A2_24,A2_25
goto A2_Done
A2_0:
ps2$ = "A"
goto A2_Done
A2_1:
ps2$ = "B"
goto A2_Done
A2_2:
ps2$ = "C"
goto A2_Done
A2_3:
ps2$ = "D"
goto A2_Done
A2_4:
ps2$ = "E"
goto A2_Done
A2_5:
ps2$ = "F"
goto A2_Done
A2_6:
ps2$ = "G"
goto A2_Done
A2_7:
ps2$ = "H"
goto A2_Done
A2_8:
ps2$ = "I"
goto A2_Done
A2_9:
ps2$ = "J"
goto A2_Done
A2_10:
ps2$ = "K"
goto A2_Done
A2_11:
ps2$ = "L"
goto A2_Done
A2_12:
ps2$ = "M"
goto A2_Done
A2_13:
ps2$ = "N"
goto A2_Done
A2_14:
ps2$ = "O"
goto A2_Done
A2_15:
ps2$ = "P"
goto A2_Done
A2_16:
ps2$ = "Q"
goto A2_Done
A2_17:
ps2$ = "R"
goto A2_Done
A2_18:
ps2$ = "S"
goto A2_Done
A2_19:
ps2$ = "T"
goto A2_Done
A2_20:
ps2$ = "U"
goto A2_Done
A2_21:
ps2$ = "V"
goto A2_Done
A2_22:
ps2$ = "W"
goto A2_Done
A2_23:
ps2$ = "X"
goto A2_Done
A2_24:
ps2$ = "Y"
goto A2_Done
A2_25:
ps2$ = "Z"
A2_Done:
on A3 goto A3_0,A3_1,A3_2,A3_3,A3_4,A3_5,A3_6,A3_7,A3_8,A3_9,A3_10,A3_11,A3_12,A3_13,A3_14,A3_15,A3_16,A3_17,A3_18,A3_19,A3_20,A3_21,A3_22,A3_23,A3_24,A3_25
goto A3_Done
A3_0:
ps3$ = "A"
goto A3_Done
A3_1:
ps3$ = "B"
goto A3_Done
A3_2:
ps3$ = "C"
goto A3_Done
A3_3:
ps3$ = "D"
goto A3_Done
A3_4:
ps3$ = "E"
goto A3_Done
A3_5:
ps3$ = "F"
goto A3_Done
A3_6:
ps3$ = "G"
goto A3_Done
A3_7:
ps3$ = "H"
goto A3_Done
A3_8:
ps3$ = "I"
goto A3_Done
A3_9:
ps3$ = "J"
goto A3_Done
A3_10:
ps3$ = "K"
goto A3_Done
A3_11:
ps3$ = "L"
goto A3_Done
A3_12:
ps3$ = "M"
goto A3_Done
A3_13:
ps3$ = "N"
goto A3_Done
A3_14:
ps3$ = "O"
goto A3_Done
A3_15:
ps3$ = "P"
goto A3_Done
A3_16:
ps3$ = "Q"
goto A3_Done
A3_17:
ps3$ = "R"
goto A3_Done
A3_18:
ps3$ = "S"
goto A3_Done
A3_19:
ps3$ = "T"
goto A3_Done
A3_20:
ps3$ = "U"
goto A3_Done
A3_21:
ps3$ = "V"
goto A3_Done
A3_22:
ps3$ = "W"
goto A3_Done
A3_23:
ps3$ = "X"
goto A3_Done
A3_24:
ps3$ = "Y"
goto A3_Done
A3_25:
ps3$ = "Z"
A3_Done:
until h1$=ps1$ and h2$=ps2$ and h3$=ps3$ and h=x
print p
T=timer()-StartTime
print Str$(T / 1000)+" Seconds"
sync
waitkey
waitnokey
end
[/pbcode]
BenchMark Version 01 - Original Select /Case Version
[pbcode]
; PROJECT : BenchMark Version 01
; AUTHOR : Kevin Picone
; CREATED : 20/06/2018
; EDITED : 20/06/2018
; ---------------------------------------------------------------------
; ---------------------------------------------------------------------
StartTime=Timer()
print "Benchmark started Original Version"
sync
x=-1
h1$="L"
h2$="W"
h3$="K"
h=3724
repeat
x=x+1
p=p+1
if x>9999
x=0
a3=a3+1
if a3>25
a3=0
a2=a2+1
if a2>25
a2=0
a1=a1+1
endif
endif
endif
select a1
case 0
ps1$="A"
case 1
ps1$="B"
case 2
ps1$="C"
case 3
ps1$="D"
case 4
ps1$="E"
case 5
ps1$="F"
case 6
ps1$="G"
case 7
ps1$="H"
case 8
ps1$="I"
case 9
ps1$="J"
case 10
ps1$="K"
case 11
ps1$="L"
case 12
ps1$="M"
case 13
ps1$="N"
case 14
ps1$="O"
case 15
ps1$="P"
case 16
ps1$="Q"
case 17
ps1$="R"
case 18
ps1$="S"
case 19
ps1$="T"
case 20
ps1$="U"
case 21
ps1$="V"
case 22
ps1$="W"
case 23
ps1$="X"
case 24
ps1$="Y"
case 25
ps1$="Z"
endselect
select a2
case 0
ps2$="A"
case 1
ps2$="B"
case 2
ps2$="C"
case 3
ps2$="D"
case 4
ps2$="E"
case 5
ps2$="F"
case 6
ps2$="G"
case 7
ps2$="H"
case 8
ps2$="I"
case 9
ps2$="J"
case 10
ps2$="K"
case 11
ps2$="L"
case 12
ps2$="M"
case 13
ps2$="N"
case 14
ps2$="O"
case 15
ps2$="P"
case 16
ps2$="Q"
case 17
ps2$="R"
case 18
ps2$="S"
case 19
ps2$="T"
case 20
ps2$="U"
case 21
ps2$="V"
case 22
ps2$="W"
case 23
ps2$="X"
case 24
ps2$="Y"
case 25
ps2$="Z"
endselect
select a3
case 0
ps3$="A"
case 1
ps3$="B"
case 2
ps3$="C"
case 3
ps3$="D"
case 4
ps3$="E"
case 5
ps3$="F"
case 6
ps3$="G"
case 7
ps3$="H"
case 8
ps3$="I"
case 9
ps3$="J"
case 10
ps3$="K"
case 11
ps3$="L"
case 12
ps3$="M"
case 13
ps3$="N"
case 14
ps3$="O"
case 15
ps3$="P"
case 16
ps3$="Q"
case 17
ps3$="R"
case 18
ps3$="S"
case 19
ps3$="T"
case 20
ps3$="U"
case 21
ps3$="V"
case 22
ps3$="W"
case 23
ps3$="X"
case 24
ps3$="Y"
case 25
ps3$="Z"
endselect
until h1$=ps1$ and h2$=ps2$ and h3$=ps3$ and h=x
print p
T=timer()-StartTime
print Str$(T / 1000)+" Seconds"
sync
waitkey
waitnokey
end
[/pbcode]
Hi Kevin,
it's not even a complex "benchmarking," but it's one practical task that is solved by the same way (ie the same algorithm 1:1) in different languages on the same PC.
Your solution is much smarter and faster. In each language, this task can be optimized differently. But it was about using SELECT / CASE and strings. And keep the algorithm.
In other words. It's not a "competition": Write the best technique in a specific language for this example.
But use the same (though stupid) technique in different languages.
Result: You will learn what language is better for your technique. For your programming style. Not what language is the fastest ;)