Logo Home

This document defines DAP2 Benchmark's test set.

DAP2 benchmark consists of 7 tests. The idea is to perform the same computation using different abstraction features of a programming language in different combinations.

  • Test 0 - calculate a sum of array filled with 'double' precision floating point numbers. This must be the fastest way to get the sum. You are free to code this in any way. In C++ it would be a simple 'fortran' style loop. In Java it's a little trickier, e.g. HotSpot optimization won't work with that loop. Anyway, the point is to produce the fastest possible code, because all other tests are measured against this one.
  • Test 1 - calculate the sum of array of 'double' objects. This must be an immutable object, not a primitive type. It has to implement the interface IDouble, with an accessor returning a primitive type.
  • Test 2 - calculate the sum of elements of a List, containg the same objects as in Test 1. This List must be from the language's standard collections library, it should provide with a sequential iterator. C# has Collections namespace, Java has Collections framework. I chose ArrayLists for both languages, since they are the fastest Lists.
  • Test 3 - the same as Test 2, but the custom List is used. Moreover, importantly this custom List must be based on the standard abstract/base implementation. Both Java and C# provide us with these base classes, and developers are supposed to use them to build their own custom collections. That's why they are in the benchmark. Also, these custom Lists should be constructed from the Lists instances in Test2.

    Tests 1,2 and 3 accumulate the sum into a primitive variable. However, in the real world, many Java and C# programs (and OOP languages in general) operate with object instances and generate them in large numbers. Particularly, this is applicable for server-side apps. Therefore there are three more tests. They do the same task but they accumulate the sum into a non-primitive variable. So, every time when two instances of double object added to each other using "plus" operator, it produces the new instance of the double object. "Plus" operator is implemented differently in Java and C#. For Java it's an instance of object with "plus" method, for C# it's a delegate. In C++ it would be an overloaded operator.

  • Test 4 - the same as Test1 but with "plus".
  • Test 5 - the same as Test2 but with "plus".
  • Test 6 - the same as Test3 but with "plus".