Ada vs Java vs C#

Performance measurement sample

I prepare small and simple problem just for measuring real life performance of different run-time environments and corresponding languages. For now I implemented three versions: Ada, C# and Java.

The code use: object instance creation, parameter passing, returning a value from function, simple string manipulation and simple arithmetic operation. Sample was running for 50 million times in the loop. Each measurement represent one full execution of the main program. My environment was: Windows 10 64bit, Intel Core i7 2630QM processor and 8 GB RAM.

I am not sure how is that even possible, but Java was 3 times faster then C# and 10 times faster then Ada, it’s a clear winner here !

Looks like compiled language (Ada) lost this battle with highly optimized virtual machines, especially with Java HotSpot VM, which also compile some parts of java code to machine code too.

Measurements in seconds

(Lower is better)

Ada code

GPS 2016 (20160515) hosted on i686-pc-mingw32
GNAT GPL 2016 (20160515-49)
(c) 2001-2016 AdaCore

Compiled with full optimizations, without debugging:

gprbuild -d -PH:\Ada\SOURCE\Codesample1\codesample1.gpr
gcc -c -gnat12 -O3 -gnatp main.adb
gcc -c -gnat12 -O3 -gnatp calculators.adb
gprbind main.bexch
gnatbind main.ali
gcc -c b__main.adb
gcc main.o -o main.exe

with Ada; use Ada;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Ada.Calendar; use Ada.Calendar;
with Ada.Text_IO;

with Calculators;

procedure Main is
   Count  : Integer;
   Start_Time: Ada.Calendar.Time;
   Max : Integer;
begin
   Start_Time := Ada.Calendar.Clock;
   Count  := 0;
   Max := 50_000_000;
   for I in Integer range 1..Max loop
      Count := Calculators.Calculate(Count => Count, Max => Max);
   end loop;
    
   Ada.Text_IO.Put_Line("Time: " & Duration'Image(Ada.Calendar.Clock - Start_Time) & " s");
end Main;

with Ada; use Ada;

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

with Ada.Calendar; use Ada.Calendar;

with Ada.Text_IO;

with Calculators;

procedure Main is

Count : Integer;

Start_Time: Ada.Calendar.Time;

Max : Integer;

begin

Start_Time := Ada.Calendar.Clock;

Count := 0;

Max := 50_000_000;

for I in Integer range 1..Max loop

Count := Calculators.Calculate(Count => Count, Max => Max);

end loop;

Ada.Text_IO.Put_Line("Time: " & Duration'Image(Ada.Calendar.Clock - Start_Time) & " s");

end Main;

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

package Calculators is

   type Calculator is tagged
      record
         Result: Integer;
         Name: Unbounded_String;
      end record;

   function Calculate(This: in out Calculator; Count: Integer; Max: Integer) return Integer;

   function Calculate(Count: Integer; Max: Integer) return Integer;

end Calculators;

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

package Calculators is

type Calculator is tagged

record

Result: Integer;

Name: Unbounded_String;

end record;

function Calculate(This: in out Calculator; Count: Integer; Max: Integer) return Integer;

function Calculate(Count: Integer; Max: Integer) return Integer;

end Calculators;

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Ada.Text_IO;

package body Calculators is

   function Calculate(This: in out Calculator;  Count: in Integer; Max: Integer) return Integer is
   begin
      This.Result := Count + 1;
      This.Name := To_Unbounded_String("Name:") & This.Result'Image;
      if This.Result = Max then
        Ada.Text_IO.Put_Line(To_String(This.Name));
      end if;
      return This.Result;
   end Calculate;
   
   
   -- create new instance for each call without pointers (Calculator'Access, new and Unchecked_Deallocation)  
   function Calculate(Count: in Integer; Max: Integer) return Integer is
      Calc: Calculator;
      Result : Integer;
   begin
      Result := Calc.Calculate(Count, Max);
      Return Result;
   end Calculate;

end Calculators;

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

with Ada.Text_IO;

package body Calculators is

function Calculate(This: in out Calculator; Count: in Integer; Max: Integer) return Integer is

begin

This.Result := Count + 1;

This.Name := To_Unbounded_String("Name:") & This.Result'Image;

if This.Result = Max then

Ada.Text_IO.Put_Line(To_String(This.Name));

end if;

return This.Result;

end Calculate;

-- create new instance for each call without pointers (Calculator'Access, new and Unchecked_Deallocation)

function Calculate(Count: in Integer; Max: Integer) return Integer is

Calc: Calculator;

Result : Integer;

begin

Result := Calc.Calculate(Count, Max);

Return Result;

end Calculate;

end Calculators;

C# code

Microsoft Visual C# 2015
Microsoft .Net Framework version 4.6.01038

Running »Release build«

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;


namespace SimpleMeasureTestCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            int max = 50000000;
            int count = 0;
            Console.WriteLine("Start");
            for (int i = 1; i <= max; i++)
            {
                Calculator c = new Calculator();
                count = c.calculate(count, max);
            }
            long elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
            float seconds = (float) elapsedMilliseconds / 1000;
            Console.WriteLine("Time: " + seconds.ToString() + " s");
            Console.ReadKey();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Diagnostics;

namespace SimpleMeasureTestCSharp

{

class Program

{

static void Main(string[] args)

{

Stopwatch stopwatch = new Stopwatch();

stopwatch.Start();

int max = 50000000;

int count = 0;

Console.WriteLine("Start");

for (int i = 1; i <= max; i++)

{

Calculator c = new Calculator();

count = c.calculate(count, max);

}

long elapsedMilliseconds = stopwatch.ElapsedMilliseconds;

float seconds = (float) elapsedMilliseconds / 1000;

Console.WriteLine("Time: " + seconds.ToString() + " s");

Console.ReadKey();

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SimpleMeasureTestCSharp
{
    class Calculator
    {
        private int Result;
        private String Name;

        public int calculate(int count, int max)
        {
            Result = count + 1;
            Name = "Result: " + Result.ToString();
            if (Result == max)
            {
                Console.WriteLine(Name);
            }
            return Result;
        }
    }

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace SimpleMeasureTestCSharp

{

class Calculator

{

private int Result;

private String Name;

public int calculate(int count, int max)

{

Result = count + 1;

Name = "Result: " + Result.ToString();

if (Result == max)

{

Console.WriteLine(Name);

}

return Result;

}

Java code

Java runtime:
java version “1.8.0_60”
Java(TM) SE Runtime Environment (build 1.8.0_60-b27)
Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)

package com.company;
public class Main {
    public static void main(String[] args) {
        long start_time = System.currentTimeMillis();
        int count = 0;
        int max = 50000000;
        for (int i = 1; i <= max; i++) {
            Calculator c = new Calculator();
            count = c.calculate(count, max);
        }
        long end_time = System.currentTimeMillis();
        long diff_time = end_time - start_time;
        float seconds = (float)diff_time/1000;
        System.out.println("Time: "  + seconds + " s");
    }
}

package com.company;

public class Main {

public static void main(String[] args) {

long start_time = System.currentTimeMillis();

int count = 0;

int max = 50000000;

for (int i = 1; i <= max; i++) {

Calculator c = new Calculator();

count = c.calculate(count, max);

}

long end_time = System.currentTimeMillis();

long diff_time = end_time - start_time;

float seconds = (float)diff_time/1000;

System.out.println("Time: " + seconds + " s");

}

package com.company;
/**
 * Created by igorb on 14.8.2016.
 */
public class Calculator {
    private int Result;
    private String Name;
    public int calculate(int count, int max)
    {
        Result = count + 1;
        Name = "Result: " + Result;
        if(Result == max) {
            System.out.println(Name);
        }
       return Result;
    }
}

package com.company;

/**

* Created by igorb on 14.8.2016.

public class Calculator {

private int Result;

private String Name;

public int calculate(int count, int max)

{

Result = count + 1;

Name = "Result: " + Result;

if(Result == max) {

System.out.println(Name);

}

return Result;

}

TypeScript/JavaScript

Out of pure curiosity I wrote the same test with typescript. The results from running under node (on the same machine) are:

igorb@PAVILION MINGW64 /c/Bisaga/Workspaces/learning/calcspeed
$ node ./dist/index.js
Start.
Result: 50000000
Time: 7.456 sec

igorb@PAVILION MINGW64 /c/Bisaga/Workspaces/learning/calcspeed
$ node ./dist/index.js
Start.
Result: 50000000
Time: 7.709 sec

igorb@PAVILION MINGW64 /c/Bisaga/Workspaces/learning/calcspeed
$ node ./dist/index.js
Start.
Result: 50000000
Time: 7.529 sec

igorb@PAVILION MINGW64 /c/Bisaga/Workspaces/learning/calcspeed
$ node ./dist/index.js
Start.
Result: 50000000
Time: 7.358 sec

igorb@PAVILION MINGW64 /c/Bisaga/Workspaces/learning/calcspeed
$ node ./dist/index.js
Start.
Result: 50000000
Time: 7.387 sec

igorb@PAVILION MINGW64 /c/Bisaga/Workspaces/learning/calcspeed
$ node ./dist/index.js
Start.
Result: 50000000
Time: 7.496 sec