Benchmark test - VB6/VC6/Delphi6/Java

I have posted inaccurate benchmarks in the past. This here is a valid one.VC++6, VB6, and Delphi6 are running all program with equivalent algorithms to populate a 1000 element array with random elements 1000 times. (Byte and char types are equivalent in terms of size).

Here is the code I used for the Visual C++ 6 Benchmark:

Code:

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <ctime>
#include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
    char data[1000];
    DWORD dwStart = GetTickCount();
    for(int i = 0; i < 1000; i++)
    {
        for(int j = 0; j < 1000; j++)
        {
            data[j] = (char)rand()%100;
        }
    } 
    DWORD dwEnd = GetTickCount();
    cout << "Took " << (dwEnd)-(dwStart) << " milliseconds to complete." << endl;
    return 0;
}

Here is the code I used for the Visual Basic 6 Benchmark:

Code:

Private Declare Function GetTickCount Lib "kernel32" () As Long

Private Sub Command1_Click()
Dim Start As Long
Start = GetTickCount()
Dim arr1(1000) As Byte
Dim i As Integer
Dim j As Integer
For i = 1 To 1000
    For j = 1 To 1000
        arr1(j) = Rnd Mod 100
    Next j
Next i
Dim EndTime As Long
EndTime = GetTickCount()
MsgBox "That took " & Str(EndTime - Start) & " milliseconds to complete."
End Sub

And the Borland Delphi 6 equivalent:

Code:

program Project2;

{$APPTYPE CONSOLE}

uses
  SysUtils, Windows;
var
i,j,start,endtime:Longint;
data: array[1..1000] of Byte;
begin
  { TODO -oUser -cConsole Main : Insert code here }
  start := GetTickCount();
  for i := 1 to 1000 do
  begin
        for j := 1 to 1000 do
        begin
                data[j] := Random(32767) mod 100;
                // 32767 is the same as RAND_MAX in VC++
        end;
  end;
  endtime := GetTickCount();
  WriteLn('That took ' + IntToStr(endtime-start) + ' milliseconds to finish.');
end.

Java source (thanks Cheese Police):

Code:

public class Benchmark
{
    public static void main(String[] args)
    {
        byte[] data = new byte[1000];
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++)
        {
            for (int j = 0; j < 1000; j++)
            {
                data[j] = (byte) (Math.random() * 256);
            }    
        }
        long end = System.currentTimeMillis();
        System.out.println((end - start) + " ms");
    }

}

Output:

VB6:
157 milliseconds
156 milliseconds
141 milliseconds
141 milliseconds
140 milliseconds

VC6:
31 milliseconds
16 milliseconds
31 milliseconds
15 milliseconds
31 milliseconds

BD6:
16 milliseconds
31 milliseconds
31 milliseconds
31 milliseconds
31 milliseconds

Java:
125 ms
94 ms
94 ms
94 ms
94 ms

Averages: VB6 - takes 147 milliseconds to fill a 1000 element array 1000 times
VC6 - takes 24.8 milliseconds to fill a 1000 element array 1000 times
BD6 - takes 28 milliseconds to fill a 1000 element array 1000 times
Java - takes 100.2 milliseconds to fill a 1000 element array 1000 times

C++ and Delphi are pretty evenly matched, Java is only slow because of it being bytecode, although, it's obvious here who the clear loser is in terms of speed. The algorithm is exactly the same, yet VB takes significantly longer to run it.

 

For VB, did you compile the program and run the .exe or simply run it through the IDE? Compiling the program makes it run "faster".

I don't use any of these, I use code::blocks and C/C++, maybe MSVC# if I need something fast.

 

I actually compiled the VB project before running it. I know what I'm doing lol >_>

 

Code:

program Project2;

uses
 Windows;

function IntToStr(i: Integer): String;
begin
 Str(i, Result);
end;

var
 I, J, Start, EndTime: LongInt;
 Data: array[1..1000] of Byte;
begin
 Start := GetTickCount();
 for I := 1 to 1000 do for J := 1 to 1000 do data[J] := Random(32767) mod 100;
 EndTime := GetTickCount();
 MessageBox(0, PChar('That took ' + IntToStr(EndTime-Start) + ' milliseconds to finish.'), nil, 0);
end.

For me this does:
15 milliseconds
15 milliseconds
16 milliseconds
31 milliseconds
15 milliseconds

Depends on luck... C++ & Delphi are the same speed for this thing xD.
Note: This is on Delphi 2007.

 

Here is a C# 3.0 benchmark code:

Code:

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

namespace Benchmark
{
    class Program
    {
        [System.Runtime.InteropServices.DllImport("kernel32")]
        static extern Int32 GetTickCount();
        static Random rnd = new Random();

        static void Main(string[] args)
        {
            do
            {
                Console.WriteLine(Bench());
                Console.ReadKey();
            } while (true);
        }

        static Int32 Bench()
        {
            var data = new byte[1000];
            var start = GetTickCount();
            for (var i = 0; i < 1000; i++)
                for (var j = 0; j < 1000; j++)
                    data[j] = (byte)(rnd.Next() % 100);
            var end = GetTickCount();
            return (end - start);
        }
    }
}

My results were:
47
31
46
31
31

The loop is just so I dont have to restart the application each time.

 

Yes, I did notice that the speed between Delphi/VC++ is usually quite close.

Nice, I would've actually expected .NET results to be close to Java's as .NET is also bytecode - but your computer is probably better than my P.O.S.

 

Here's vb.NET 2005

Code:

Public Class Form1

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        Dim Start As Long
        Start = System.Environment.TickCount
        Dim arr1(1000) As Byte
        Dim i As Integer
        Dim j As Integer
        For i = 1 To 1000
            For j = 1 To 1000
                arr1(j) = Rnd() Mod 100
            Next j
        Next i
        Dim EndTime As Long
        EndTime = System.Environment.TickCount
        MsgBox("That took " & Str(EndTime - Start) & " milliseconds to complete.")
    End Sub
End Class

Results:
265
265
234
250
266

 

I compiled your C++ source with Dev-CPP and came up with an average of 47 milliseconds, considerably worse.

 

Surely these aren't reliable? I mean, after all it depends on the CPU speed too so someone with a not-so-good computer would have even worse results.

 

All the tests that I did were run on the same computer.

 

What speed is your CPU?

 

Can you post your CPU speed too, I wouldn't think that VC++ should be that much faster than Dev-CPP.

I used an Intel Cored Duo T7200 @ 2.00GHz.

 

I have an emachines running a Pentium IV @ 1.99 GHz (not overclocked, not dual core) with 384 MB RAM. Given that, my computer should be a lot slower than yours.

 

omg i tried this in SCAR:

Code:

program New;
var
  i, time, finishtime, k : Integer;
  Data : array[0..1000] of byte;
begin
  time := GetSystemTime;
  for i:=0 to High(Data) do
  begin
    for k:= 0 to High(Data) do
    begin
      Data[k] := random(32767) mod 100;
    end;
  end;
  finishtime := GetSystemTime;
  writeln('That took '+inttostr(finishtime-time)+' milliseconds to finish.');
end.

That took 24687 milliseconds to finish.

im not lucky.

 

No, use the GetTickCount API - enable API calls then declare it from kernel32.dll.

 

kernel32.dll? btw in SCAR there isnt any plugin called kernel.

 

No, learn how to call Windows APIs through SCAR -.- Try dlltest.scar in the Test folder.

 

k, and whats the difference between GetSystemTime and GetTicketCount?

 

I have an Intel Celeron CPU 2.80 GHz with 1.46 GB of RAM.

Why do you ask?

 

Because test results will differ on CPU's with varying speed.