Benchmark different implementations in different languages

2. The 73js

3. Let’s implement the 73 calculator
f(x) = {
3, x=7
7, x=3
¯_(ツ)_/¯, otherwise
}

5. Let’s implement the 73 calculator
f(x) = {
3, x=7
7, x=3
¯_(ツ)_/¯, otherwise
}

6. Use an if
static useif(n) {
if (n == 3) return 7;
return 3;
}

7. Use an if (the strict equality version)
static useifeq(n) {
if (n === 3) return 7;
return 3;
}

8. Use a Xor
static useXor(n) {
return (n ^= 4);
}

9. Use an array
static useArray(n) {
const mem = [-1,-1,-1,7,-1,-1,-1,3];
return mem[n];
}

10. The switch statement
static useSwitch(n) {
switch (n) {
case 7:
return 3;
case 3:
return 7;
default:
throw new exception("err");
}
}

11. useSubstraction
static useSubstraction(n) {
return 10 - n;
}

12. Division
static useDivision(n) {
return 21 / n;
}

13. String replace (I asked for a number)
static stringReplaceNumber(n) {
return Number("37".replace(n, ""));
}

14. String replace (I’ll parse you a number)
static stringReplaceParseInt(n) {
return parseInt("37".replace(n, ""));
}

15. Using modulo
static useModulo(n) {
return ((n + 4) % 8);
}

16. Using object map
static useObjectMap(n) {
const objmapper = {
3: 7,
7: 3
};
return objmapper[n];
}

17. Using indexer dictionary
static useIndexerDictionary(n) {
const dict = {};
dict[3] = 7;
dict[7] = 3;
return dict[n];
}

18. Using a Polynom
static usePolynom(n) {
return ((79 - (n * n)) / 10);
}

19. Let’s try another base
static useOctalCast(n) {
let numberAsOctal = (n + 4).toString(8)
return parseInt(numberAsOctal) % 10;
}

20. I bet there are a couple more
ways…
Using relational
databases, AI, routing,
statistics, fourier
transforms, various
functional bases, and the
sky is the limit…

21. There’s more than one way to skin
a cat

22. Now what?

23. Let’s find out which is best!

24. Using benchmark.js

25. var Benchmark = require('benchmark');
var suite = new Benchmark.Suite;
const The73Calculator = require("./The73Calculator.js");
suite.add(The73Calculator.useif.name, () => {
expectBehavior(The73Calculator.useif);
})
.add(The73Calculator.useifeq.name, () => {
expectBehavior(The73Calculator.useifeq);
})
.add(The73Calculator.useXor.name, () => {
expectBehavior(The73Calculator.useXor);
})
.add(The73Calculator.useArray.name, () => {
expectBehavior(The73Calculator.useArray);
})
.add(The73Calculator.usingSwitch.name, () => {
expectBehavior(The73Calculator.usingSwitch);
})
.add(The73Calculator.useSubstraction.name, () => {
expectBehavior(The73Calculator.useSubstraction);
})
.add(The73Calculator.useDivision.name, () => {
expectBehavior(The73Calculator.useDivision);
})
.add(The73Calculator.useStringReplaceParseInt.name, () => {
expectBehavior(The73Calculator.useStringReplaceParseInt);

26. // add listeners
.on('cycle', function(event) {
console.log(String(event.target));
})
.on('complete', function() {
report.sort((a, b) => (b.hz - a.hz));
report.forEach(r => console.log(r.name + " - " + r.hz));
console.log('Fastest is ' + this.filter('fastest').map('name'));
console.log('Slowest is ' + this.filter('slowest').map('name'));
})
// run async
.run({ 'async': true });
function expectBehavior(f) {
for (var i = 0; i < 100000; i++) {
f(3);
f(7);
}
}

27. If
Ifeq
Substraction
Division
Xor
Polynom
Modulo
Switch
Array
Octal
IndexerDictionary
StringReplaceNumber
StringReplaceParseInt
ObjectMap

28. And the winner is…
If
Ifeq
Substraction
Division
Xor
Polynom
Modulo
Switch
Array
Octal
IndexerDictionary
StringReplaceNumber
StringReplaceParseInt
ObjectMap

29. And the loser is…
If
Ifeq
Substraction
Division
Xor
Polynom
Modulo
Switch
Array
Octal
IndexerDictionary
StringReplaceNumber
StringReplaceParseInt
ObjectMap

30. To the results…

31. To the results……

32. javascript
Method runtime (us)
useif 24.52
useXor 827
useSubstraction 951
useifeq 956
usingSwitch 1012
useArray 1228
usingPolynom 1349
usingModulo 1547
division 1848
usingObjectMap 4950
octal 12938
usingIndexerDictionary 40371
stringReplaceNumber 48875
stringReplaceParseInt 64267

33. javascript c#
Method runtime (us) runtime (ns)
useif 24.52 485
useXor 827 437
useSubstraction 951 428
useifeq 956 498
usingSwitch 1012 501
useArray 1228 437
usingPolynom 1349 486
usingModulo 1547 432
division 1848 554
usingObjectMap 4950 4255
octal 12938 n/a
usingIndexerDictionary 40371 1335
stringReplaceNumber 48875 n/a
stringReplaceParseInt 64267 8474

34. You have to measure to know

35. If you haven’t measured, you don’t
know

36. If you think you know, and you
haven’t measured, you still don’t
know

37. Now what? (2 of n)

38. javascript c#
Method runtime (us) runtime (ns)
useif 24.52 485
useXor 827 437
useSubstraction 951 428
useifeq 956 498
usingSwitch 1012 501
useArray 1228 437
usingPolynom 1349 486
usingModulo 1547 432
division 1848 554
usingObjectMap 4950 4255
octal 12938 n/a
usingIndexerDictionary 40371 1335
stringReplaceNumber 48875 n/a
stringReplaceParseInt 64267 8474

39. javascript c#
Method runtime (us) runtime (ns)
useif 24.52 485
useXor 827 437
useSubstraction 951 428
useifeq 956 498
usingSwitch 1012 501
useArray 1228 437
usingPolynom 1349 486
usingModulo 1547 432
division 1848 554
usingObjectMap 4950 4255
octal 12938 n/a
usingIndexerDictionary 40371 1335
stringReplaceNumber 48875 n/a
stringReplaceParseInt 64267 8474
By that much?
This is
interesting #1
This is
interesting #2

40. You are a victim of branch
prediction fail.

42. Summary
There’s more than one way to skin
a cat
You have to measure to know
Benchmark.js is great
Energy awareness is a thing

43. @hanokhaloni
Hanokhaloni
hanokhaloni
https://github.com/hanokhaloni/73js