D vs Java - some benchmarks comparing D and Java in allocating dynamically sized arrays

bench.d

/**
bench.d -
Allocation/Garbage collection benchmark for D
*/

import std.stdio;
import std.datetime;
import std.conv;

ulong[] ascendingAlloc(int n, int max_size, bool warmup)
{
    // setup timer
    StopWatch sw;
    TickDuration[] times;
    times.length = n;
    TickDuration last = TickDuration.from!"seconds"(0);
    sw.start();

    // microbenchmark code
    ulong[] lens;
    for (auto i = 0; i < n; i++)
    {
       double[][] x;
       auto ii = 0;
       while (ii++ < max_size)
       {
           double[] y;
           y.length = ii;
           x ~= y;
       }

       lens ~= x.length;

       ii = max_size;
       while (ii-- > 1)
       {
           x.length = ii;
       }
       x.length = 0;
    }

    // stop timer
    sw.stop();
    auto t = sw.peek() - last;

    // output results
    if (warmup == false)
        writeln("ascendingAllocD,", t.msecs);

    return lens;
}

ulong[] descendingAlloc(int n, int max_size, bool warmup)
{
    // setup timer
    StopWatch sw;
    TickDuration[] times;
    times.length = n;
    TickDuration last = TickDuration.from!"seconds"(0);
    sw.start();

     // microbenchmark code
    ulong[] lens;
    for (auto i = 0; i < n; i++)
    {
       double[][] x;
       auto ii = max_size;
       while (ii-- > 1)
       {
           double[] y;
           y.length = ii;
           x ~= y;
       }

       lens ~= x.length;

       ii = max_size;
       while (ii-- > 1)
       {
           x.length = ii;
       }

       x.length = 0;
    }

    // stop timer
    sw.stop();
    auto t = sw.peek() - last;

    // output results
    if (warmup == false)
        writeln("descendingAllocD,", t.msecs);
    return lens;
}

ulong[] alternatingAlloc(int n, int max_size, bool warmup)
{
    // setup timer
    StopWatch sw;
    TickDuration[] times;
    times.length = n;
    TickDuration last = TickDuration.from!"seconds"(0);
    sw.start();

    // microbenchmark code
    ulong[] lens;

    for (auto i = 0; i < n; i++)
    {
       double[][] x;
       auto ii = 0;
       int l1 = max_size / 2;
       int l2 = 0;
       int limit = l1;
       while (ii++ < limit)
       {
           double[] y;
           double[] y2;
           y.length = ++l1;
           y2.length = ++l2;
           x ~= y;
           x ~= y2;
       }

       lens ~= x.length;

       ii = limit;
       while (ii-- > 1)
       {
           x.length = ii;
       }
       x.length = 0;
    }

    // stop timer
    sw.stop();
    auto t = sw.peek() - last;

    // output results
    if (warmup == false)
        writeln("alternatingAllocD,", t.msecs);

    return lens;
}


void main(string[] args)
{
    auto bench_iters = to!int(args[1]);
    auto times = to!int(args[2]);
    auto max_size = to!int(args[3]);


    //warmup
    auto warmup = ascendingAlloc(times, max_size, true);
    warmup = ascendingAlloc(times, max_size, true);
    warmup = alternatingAlloc(times, max_size, true);
    warmup = ascendingAlloc(times, max_size, true);
    warmup = ascendingAlloc(times, max_size, true);
    warmup = alternatingAlloc(times, max_size, true);

    // run benchmarks
    while (bench_iters-- > 0)
     {
         auto result = ascendingAlloc(times, max_size, false);
         auto result2 = descendingAlloc(times, max_size, false);
         auto result3 = alternatingAlloc(times, max_size, false);
         auto result4 = alternatingAlloc(times, max_size, false);
         auto result5 = descendingAlloc(times, max_size, false);
         auto result6 = ascendingAlloc(times, max_size, false);
         auto result7 = ascendingAlloc(times, max_size, false);
         auto result8 = descendingAlloc(times, max_size, false);
         auto result9 = alternatingAlloc(times, max_size, false);
         max_size += 1000;
     }
}

Bench.java

/**
   Bench.java -
   Allocation/Garbage collection benchmark for Java
*/
import java.util.ArrayList;
import java.util.Collections;

/**
 *
 * @author tommy
 */
public class Bench {

    public static ArrayList<Integer> ascendingAlloc(int n, int max_size, boolean warmup) {
        ArrayList<Integer> lens = new ArrayList<Integer>();
        // setup timer
        long startTime = System.currentTimeMillis();

        // microbenchmark code
        for (int i = 0; i < n; i++)
        {
            ArrayList<ArrayList<Double>> x = new ArrayList<ArrayList<Double>>();
            int ii = 0;
            while (ii++ < max_size)
            {
                ArrayList<Double> y = new ArrayList<Double>(ii);
                x.add(y);
            }

            lens.add(x.size());

            ii = max_size;
            while (ii-- > 1)
            {
                x.remove(ii - 1);
            }

            x.clear();
        }

        // stop timer
        long estimatedTime = System.currentTimeMillis() - startTime;

        // output results
        if (warmup == false)
        {
            System.out.print("ascendingAllocJava,");
            System.out.print(estimatedTime);
            System.out.print('\n');
        }
        return lens;
    }

    public static ArrayList<Integer> descendingAlloc(int n, int max_size, boolean warmup) {
        ArrayList<Integer> lens = new ArrayList<Integer>();

        // setup timer
        long startTime = System.currentTimeMillis();

        // microbenchmark code
        for (int i = 0; i < n; i++)
        {
            ArrayList<ArrayList<Double>> x = new ArrayList<ArrayList<Double>>();
            int ii = max_size;
            while (ii-- > 1)
            {
                ArrayList<Double> y = new ArrayList<Double>(ii);
                x.add(y);
            }

            lens.add(x.size());

            ii = max_size;
            while (ii-- > 1)
            {
                x.remove(ii - 1);
            }

            x.clear();
        }

        // stop timer
        long estimatedTime = System.currentTimeMillis() - startTime;

        // output results
        if (warmup == false)
        {
            System.out.print("descendingAllocJava,");
            System.out.print(estimatedTime);
            System.out.print('\n');
        }
        return lens;
    }

    public static ArrayList<Integer> alternatingAlloc(int n, int max_size, boolean warmup) {
        ArrayList<Integer> lens = new ArrayList<Integer>();
        // setup timer
        long startTime = System.currentTimeMillis();

        // microbenchmark code
        for (int i = 0; i < n; i++)
        {
            ArrayList<ArrayList<Double>> x = new ArrayList<ArrayList<Double>>();
            int ii = 0;
            int l1 = max_size / 2;
            int l2 = 0;
            int limit = l1;
            while (ii++ < limit)
            {
                ArrayList<Double> y = new ArrayList<Double>(++l1);
                ArrayList<Double> y2 = new ArrayList<Double>(++l2);
                x.add(y);
                x.add(y2);
            }

            lens.add(x.size());

            ii = limit;
            while (ii-- > 1)
            {
                x.remove(ii - 1);
            }

            x.clear();
        }

        // stop timer
        long estimatedTime = System.currentTimeMillis() - startTime;

        // output results
        if (warmup == false)
        {
            System.out.print("alternatingAllocJava,");
            System.out.print(estimatedTime);
            System.out.print('\n');
        }
        return lens;
    }


    /**
     * @param args bench_iters times max_size
     */
    public static void main(String[] args) {
        int bench_iters = Integer.parseInt(args[0]);
        int times = Integer.parseInt(args[1]);
        int max_size = Integer.parseInt(args[2]);

        // warmup
        ArrayList<Integer>  warmup = ascendingAlloc(times, max_size, true);
        warmup = ascendingAlloc(times, max_size, true);
        warmup = descendingAlloc(times, max_size, true);
        warmup = descendingAlloc(times, max_size, true);
        warmup = alternatingAlloc(times, max_size, true);
        warmup = alternatingAlloc(times, max_size, true);

        // run benchmarks
        while (bench_iters-- > 0)
        {
            ArrayList<Integer> result = ascendingAlloc(times, max_size, false);
            ArrayList<Integer> result2 = descendingAlloc(times, max_size, false);
            ArrayList<Integer> result3 = alternatingAlloc(times, max_size, false);
            ArrayList<Integer> result4 = descendingAlloc(times, max_size, false);
            ArrayList<Integer> result5 = ascendingAlloc(times, max_size, false);
            ArrayList<Integer> result6 = alternatingAlloc(times, max_size, false);
            ArrayList<Integer> result7 = alternatingAlloc(times, max_size, false);
            ArrayList<Integer> result8 = ascendingAlloc(times, max_size, false);
            ArrayList<Integer> result9 = descendingAlloc(times, max_size, false);
            max_size += 1000;
        }
    }
}

dresults.csv

javaresults.csv

run.sh

#!/bin/bash

## run the d benchmarks and java benchmarks
## results included run with ./run.sh 5 6000 1000 

if [ $# -lt 3 ]
then
    echo "usage: ./run.sh (bench_iters) (times) (maxsize start)"
    exit 1;
fi

rm -f ./dresults.csv;
dmd -m64 -O -inline -noboundscheck -ofbench bench.d
./bench $* > dresults.csv;
rm -f *.o;
rm -f bench;
rm -f ./javaresults.csv;
javac Bench.java;
java -server Bench $*  > javaresults.csv;
rm *.class