L1VM vs. Java
I did some benchmarks on the primenum search using the well known sieve of Eratosthenes. I did use my L1VM bracket language and Java. The programs are searching for the prime numbers up to 10000000.
My primes-4 L1VM program uses the new if optimizer, which optimizes if calls. It just saves two operations. And uses only two opcodes for an if.
The Java program seems to be good for a comparison and is well optimized IMHO.
My L1VM is faster than Java in this case. It can run more instructions per cycle. Also the page faults counts are a lot less.
Or in other words: “Let’s put a dent in the universe!” - Steve Jobs
... snip ... 9999971 9999973 9999991 Performance counter stats for 'java SieveOfEratosthenes': 5.123,43 msec task-clock # 1,098 CPUs utilized 6.798 context-switches # 0,001 M/sec 82 cpu-migrations # 0,016 K/sec 4.611 page-faults # 0,900 K/sec 12.273.745.268 cycles # 2,396 GHz 8.646.049.734 instructions # 0,70 insn per cycle 1.814.826.502 branches # 354,221 M/sec 33.365.480 branch-misses # 1,84% of all branches 4,666948099 seconds time elapsed 2,580319000 seconds user 2,568318000 seconds sys
... snip ... 9999971 9999973 9999991 EXIT Performance counter stats for 'vm/l1vm-nojit prog/primes-4': 4.333,76 msec task-clock # 0,943 CPUs utilized 215 context-switches # 0,050 K/sec 22 cpu-migrations # 0,005 K/sec 957 page-faults # 0,221 K/sec 10.759.561.410 cycles # 2,483 GHz 14.633.831.959 instructions # 1,36 insn per cycle 2.252.911.335 branches # 519,852 M/sec 13.485.970 branch-misses # 0,60% of all branches 4,597503274 seconds time elapsed 2,853030000 seconds user 1,484863000 seconds sys
The primes-4 L1VM program is in my GitHub repository in prog/ directory. Here is the Java program I used to benchmark Java:
class SieveOfEratosthenes { void sieveOfEratosthenes(int n) { // Create a boolean array "prime[0..n]" and initialize // all entries it as true. A value in prime[i] will // finally be false if i is Not a prime, else true. boolean prime[] = new boolean[n+1]; for(int i=0;i<n;i++) prime[i] = true; for(int p = 2; p*p <=n; p++) { // If prime[p] is not changed, then it is a prime if(prime[p] == true) { // Update all multiples of p for(int i = p*p; i <= n; i += p) prime[i] = false; } } // Print all prime numbers for(int i = 2; i <= n; i++) { if(prime[i] == true) System.out.println(i); } } // Driver Program to test above function public static void main(String args[]) { int n = 10000000; System.out.print("Following are the prime numbers "); System.out.println("smaller than or equal to " + n); SieveOfEratosthenes g = new SieveOfEratosthenes(); g.sieveOfEratosthenes(n); } } // This code has been contributed by Amit Khandelwal.
More information about this Java program is here: Sieve of Eratosthenes
Update
If I compile the L1VM with -O2 instead of -Os (size optimization) then I get the following result:
9999971 9999973 9999991 EXIT Performance counter stats for 'vm/l1vm-nojit-O2 prog/primes-4': 3.991,23 msec task-clock # 0,948 CPUs utilized 90 context-switches # 0,023 K/sec 12 cpu-migrations # 0,003 K/sec 947 page-faults # 0,237 K/sec 9.938.794.245 cycles # 2,490 GHz 13.572.030.984 instructions # 1,37 insn per cycle 1.983.227.629 branches # 496,896 M/sec 12.118.955 branch-misses # 0,61% of all branches 4,211125771 seconds time elapsed 2,607546000 seconds user 1,385135000 seconds sys
That is a bit faster and makes it more clear that the L1VM is faster.