a simple bench on performance between C#/C++/Java

[blaise]

I just did some very simple comapre between these three langauge in some aspect.The result is only for reference.
I wish to do some further test on the database access functions of these three language, but I am not familar with JDBC. I wonder if anyone could help.
Here is what I did and what the result is:

*The statistic data*:
C++/STL C# JAVA
floatpoint 1202 8342 10225
interger/logic 1442 1452 1422
collection 631 2844 11576

*The conclusion*:
if you don't do a lot of floating points calculation, C#'s speed is almost acceptable. If you are not persueing the maxmum speed,swicth from c++ to C# is acceptable.

*The code*
//c++
#include "stdio.h"
#include "stdlib.h"
#include "assert.h"
#include "time.h"
#include "windows.h"
#include <stack>
#include <vector>
#include <queue>
using namespace std;
class cBenchTest
{
public:
virtual void Init(int heaviness1,int heaviness2)=0;
virtual void RunTest()=0;
virtual ~cBenchTest()=0{};
};

class cFPTest:public cBenchTest
{
public:
void Init(int heaviness1,int heaviness2);
void RunTest();
~cFPTest();
private:
enum eOperator
{
O_ADD,
O_SUB,
O_MUL,
O_DIV
};
int mHeaviness1;
int mHeaviness2;
float* mOperand1;
float* mOperand2;
float* mResult;
eOperator* mOperator;
};


void cFPTest::Init(int heaviness1,int heaviness2)
{
mHeaviness1=heaviness1;
mHeaviness2=heaviness2;
mOperand1= new float[mHeaviness1];
assert(mOperand1!=0);
mOperand2= new float[mHeaviness1];
assert(mOperand2!=0);
mResult= new float[mHeaviness1];
assert(mResult!=0);

mOperator= new eOperator[mHeaviness1];

srand((unsigned)time(NULL));
for(int i=0;i<mHeaviness1;i++)
{
mOperand1[i]=rand()*1.f/RAND_MAX*1000;
mOperand2[i]=rand()*1.f/RAND_MAX*1000;
mOperator[i]=(eOperator)(rand()*(O_DIV+1));
if(mOperator[i]==O_DIV&&mOperand2[i]==0.f)
mOperand2[i]=1.f;
}
};
void cFPTest::RunTest()
{
for(int i=0;i<mHeaviness2;i++)
{
for(int j=0;j<mHeaviness1;j++)
{
switch(mOperator[j])
{
case O_ADD:
mResult[j]=mOperand1[j]+mOperand2[j];
break;
case O_SUB:
mResult[j]=mOperand1[j]-mOperand2[j];
break;
case O_MUL:
mResult[j]=mOperand1[j]*mOperand2[j];
break;
case O_DIV:
mResult[j]=mOperand1[j]/mOperand2[j];
break;
}
}
}
}
cFPTest::~cFPTest()
{
delete []mOperand1;
delete []mOperand2;
delete []mResult;
delete []mOperator;
}



class cILTest:public cBenchTest
{
public:
void Init(int heaviness1,int heaviness2);
void RunTest();
~cILTest();
private:
void Func1(int i);
void Func2(int i);
void Func3(int i);
int mHeaviness1;
int mHeaviness2;
int* mData;
};

void cILTest::Func1(int i)
{
if(i<6)
return ;
int t=0;
while(t*t<i)
t++;
switch(i%3+1)
{
case 1:
Func1(t);
break;
case 2:
Func2(t);
break;
case 3:
Func3(t);
break;

}
}
void cILTest::Func2(int i)
{
if(i<6)
return ;
int t=0;
for(int k=1;k<i;k++)
{
if((i%k)==0)
t++;
}
t=i/t;
t--;
switch(i%3)
{
case 1:
Func1(t);
break;
case 2:
Func2(t);
break;
case 3:
Func3(t);
break;
}
}
void cILTest::Func3(int i)
{
if(i<6)
return ;

int t=i%2;
t--;
switch(i%3)
{
case 1:
Func1(t);
break;
case 2:
Func2(t);
break;
case 3:
Func3(t);
break;
}

}

void cILTest::Init(int heaviness1,int heaviness2)
{
mHeaviness1=heaviness1;
mHeaviness2=heaviness2;
mData=new int[heaviness1];
assert(mData!=0);
srand((unsigned)time(NULL));
for(int i=0;i<mHeaviness1;i++)
{
mData[i]=(int)(rand()*1.f/RAND_MAX*10000);
}
}
void cILTest::RunTest()
{
for(int i=0;i<mHeaviness2;i++)
{
for(int j=0;j<mHeaviness1;j++)
{
switch(mData[j]%3+1)
{
case 1:
Func1(mData[j]);
break;
case 2:
Func2(mData[j]);
break;
case 3:
Func3(mData[j]);
break;
}
}
}
}
cILTest::~cILTest()
{
delete[] mData;
}
class cCollectionTest:public cBenchTest
{
public:
void Init(int heaviness1,int heaviness2);
void RunTest();
~cCollectionTest();
private:
int mHeaviness1;
int mHeaviness2;
vector<int>* mVector;
queue<int>* mQueue;
stack<int>* mStack;
};
void cCollectionTest::Init(int heaviness1,int heaviness2)
{
mHeaviness1=heaviness1;
mHeaviness2=heaviness2;
mVector=new vector<int>;
mQueue=new queue<int>;
mStack=new stack<int>;
for(int i=0;i<mHeaviness1;i++)
{
mVector->push_back(i);
}
}
void cCollectionTest::RunTest()
{
for(int i=0;i<mHeaviness2;i++)
{

vector<int>::iterator vi=mVector->begin();
while(vi!=mVector->end())
{
if((*vi%3)==0)
{
mQueue->push(*vi);
}
if((*vi%2)==0)
{
mStack->push(*vi);
}
++vi;
}
while(!mStack->empty())
{
mQueue->push(mStack->top());
mStack->pop();
}
}
}

cCollectionTest::~cCollectionTest()
{
delete mVector;
delete mStack;
delete mQueue;
}

void main()
{
cBenchTest* test=new cFPTest();
unsigned long start,end,timeellapsed;
printf("starting <%s> test\n","floating point");
test=new cFPTest();
test->Init(10000,10000);
start=GetTickCount();
test->RunTest();
end=GetTickCount();
if(end<start)
timeellapsed=end+~start;
else
timeellapsed=end-start;
printf("test take %dms\n",timeellapsed);
delete test;

printf("starting <%s> test\n","integer&logic&calling");
test=new cILTest();
test->Init(10000,1);
start=GetTickCount();
test->RunTest();
end=GetTickCount();
if(end<start)
timeellapsed=end+~start;
else
timeellapsed=end-start;
printf("test take %dms\n",timeellapsed);
delete test;

printf("starting <%s> test\n","collection");
test=new cCollectionTest();
test->Init(10000,300);
start=GetTickCount();
test->RunTest();
end=GetTickCount();
if(end<start)
timeellapsed=end+~start;
else
timeellapsed=end-start;
printf("test take %dms\n",timeellapsed);
delete test;

}


//C#
namespace cs
{
using System;
using System.Runtime.InteropServices;
using System.Collections;
/// <summary>
/// Summary description for Class1.
/// </summary>
interface IBenchTest
{
void Init(int heaviness1,int heaviness2);
void RunTest();
};
enum eOperator
{
O_ADD,
O_SUB,
O_MUL,
O_DIV
};
class cFPTest :IBenchTest
{

void IBenchTest.Init(int heaviness1,int heaviness2)
{
mHeaviness1=heaviness1;
mHeaviness2=heaviness2;
mOperand1= new float[mHeaviness1];
mOperand2= new float[mHeaviness1];
mResult= new float[mHeaviness1];
mOperator= new eOperator[mHeaviness1];

Random r=new Random();
for(int i=0;i<mHeaviness1;i++)
{
mOperand1[i]=r.Next(1000)*1.0f;
mOperand2[i]=r.Next(1000)*1.0f;
mOperator[i]=(eOperator)r.Next((int)(eOperator.O_DIV+1));
if(mOperator[i]==eOperator.O_DIV&&mOperand2[i]==0)
mOperand2[i]=1.0f;
}


}
void IBenchTest.RunTest()
{
for(int i=0;i<mHeaviness2;i++)
{
for(int j=0;j<mHeaviness1;j++)
{
switch(mOperator[j])
{
case eOperator.O_ADD:
mResult[j]=mOperand1[j]+mOperand2[j];
break;
case eOperator.O_SUB:
mResult[j]=mOperand1[j]-mOperand2[j];
break;
case eOperator.O_MUL:
mResult[j]=mOperand1[j]*mOperand2[j];
break;
case eOperator.O_DIV:
mResult[j]=mOperand1[j]/mOperand2[j];
break;
}
}
}
}

private int mHeaviness1;
private int mHeaviness2;
private float[] mOperand1;
private float[] mOperand2;
private float[] mResult;
private eOperator[] mOperator;
}

class cILTest: IBenchTest
{
void IBenchTest.Init(int heaviness1,int heaviness2)
{
mHeaviness1=heaviness1;
mHeaviness2=heaviness2;
mData=new int[heaviness1];
Random r=new Random();
for(int i=0;i<mHeaviness1;i++)
{
mData[i]=r.Next(10000);
}
}
void IBenchTest.RunTest()
{
for(int i=0;i<mHeaviness2;i++)
{
for(int j=0;j<mHeaviness1;j++)
{
switch(mData[j]%3+1)
{
case 1:
Func1(mData[j]);
break;
case 2:
Func2(mData[j]);
break;
case 3:
Func3(mData[j]);
break;
}
}
}
}

private void Func1(int i)
{
if(i<6)
return ;
int t=0;
while(t*t<i)
t++;
switch(i%3+1)
{
case 1:
Func1(t);
break;
case 2:
Func2(t);
break;
case 3:
Func3(t);
break;

}
}
private void Func2(int i)
{
if(i<6)
return ;
int t=0;
for(int k=1;k<i;k++)
{
if((i%k)==0)
t++;
}
t=i/t;
t--;
switch(i%3)
{
case 1:
Func1(t);
break;
case 2:
Func2(t);
break;
case 3:
Func3(t);
break;
}
}
private void Func3(int i)
{
if(i<6)
return ;

int t=i%2;
t--;
switch(i%3)
{
case 1:
Func1(t);
break;
case 2:
Func2(t);
break;
case 3:
Func3(t);
break;
}

}
private int mHeaviness1;
private int mHeaviness2;
private int[] mData;
}


class cCollectionTest:IBenchTest
{
void IBenchTest.Init(int heaviness1,int heaviness2)
{
mHeaviness1=heaviness1;
mHeaviness2=heaviness2;
mVector=new ArrayList();
mQueue=new Queue();
mStack=new Stack();
for(int i=0;i<mHeaviness1;i++)
{
mVector.Add(i);
}
}
void IBenchTest.RunTest()
{
for(int i=0;i<mHeaviness2;i++)
{
IEnumerator vi=mVector.GetEnumerator();

while(vi.MoveNext())
{
if(((int)vi.Current%3)==0)
{
mQueue.Enqueue(vi.Current);
}
if(((int)vi.Current%2)==0)
{
mStack.Push(vi.Current);
}
}
while(mStack.Count>0)
{
mQueue.Enqueue(mStack.Pop());
}
}
}
private int mHeaviness1;
private int mHeaviness2;
private ArrayList mVector;
private Queue mQueue;
private Stack mStack;
};
public class Class1
{


public Class1()
{
//
// TODO: Add Constructor Logic here
//
}

[DllImport("kernel32.dll")]
public static extern uint GetTickCount();
public static int Main(string[] args)
{
//
// TODO: Add code to start application here
//
uint start,end,timeellapsed;
IBenchTest test;
Console.WriteLine("start <{0}> test","floating point");
test=new cFPTest();
test.Init(10000,10000);
start=GetTickCount();
test.RunTest();
end=GetTickCount();
if(end<start)
timeellapsed=end+~start;
else
timeellapsed=end-start;
Console.WriteLine("test take {0}ms",timeellapsed);

Console.WriteLine("start <{0}> test","integer&logic&calling");
test=new cILTest();
test.Init(10000,1);
start=GetTickCount();
test.RunTest();
end=GetTickCount();
if(end<start)
timeellapsed=end+~start;
else
timeellapsed=end-start;
Console.WriteLine("test take {0}ms",timeellapsed);

Console.WriteLine("start <{0}> test","collection test");
test=new cCollectionTest();
test.Init(10000,300);
start=GetTickCount();
test.RunTest();
end=GetTickCount();
if(end<start)
timeellapsed=end+~start;
else
timeellapsed=end-start;
Console.WriteLine("test take {0}ms",timeellapsed);

return 0;
}
}
}



//java
import java.util.*;

interface IBenchTest
{
void Init(int heaviness1,int heaviness2);
void RunTest();
}
class cFPTest implements IBenchTest
{

public void Init(int heaviness1,int heaviness2)
{
mHeaviness1=heaviness1;
mHeaviness2=heaviness2;
mOperand1= new float[mHeaviness1];
mOperand2= new float[mHeaviness1];
mResult= new float[mHeaviness1];
mOperator= new int[mHeaviness1];

Random r=new Random();
for(int i=0;i<mHeaviness1;i++)
{
mOperand1[i]=r.nextInt(1000)*1.0f;
mOperand2[i]=r.nextInt(1000)*1.0f;
mOperator[i]=r.nextInt(4);
if(mOperator[i]==3&&mOperand2[i]==0)
mOperand2[i]=1.0f;
}
}
public void RunTest()
{
for(int i=0;i<mHeaviness2;i++)
{
for(int j=0;j<mHeaviness1;j++)
{
switch(mOperator[j])
{
case 0:
mResult[j]=mOperand1[j]+mOperand2[j];
break;
case 1:
mResult[j]=mOperand1[j]-mOperand2[j];
break;
case 2:
mResult[j]=mOperand1[j]*mOperand2[j];
break;
case 3:
mResult[j]=mOperand1[j]/mOperand2[j];
break;
}
}
}
}

private int mHeaviness1;
private int mHeaviness2;
private float[] mOperand1;
private float[] mOperand2;
private float[] mResult;
private int[] mOperator;
}

class cILTest implements IBenchTest
{
public void Init(int heaviness1,int heaviness2)
{
mHeaviness1=heaviness1;
mHeaviness2=heaviness2;
mData=new int[heaviness1];
Random r=new Random();
for(int i=0;i<mHeaviness1;i++)
{
mData[i]=r.nextInt(10000);
}
}
public void RunTest()
{
for(int i=0;i<mHeaviness2;i++)
{
for(int j=0;j<mHeaviness1;j++)
{
switch(mData[j]%3+1)
{
case 1:
Func1(mData[j]);
break;
case 2:
Func2(mData[j]);
break;
case 3:
Func3(mData[j]);
break;
}
}
}
}

private void Func1(int i)
{
if(i<6)
return ;
int t=0;
while(t*t<i)
t++;
switch(i%3+1)
{
case 1:
Func1(t);
break;
case 2:
Func2(t);
break;
case 3:
Func3(t);
break;

}
}
private void Func2(int i)
{
if(i<6)
return ;
int t=0;
for(int k=1;k<i;k++)
{
if((i%k)==0)
t++;
}
t=i/t;
t--;
switch(i%3)
{
case 1:
Func1(t);
break;
case 2:
Func2(t);
break;
case 3:
Func3(t);
break;
}
}
private void Func3(int i)
{
if(i<6)
return ;

int t=i%2;
t--;
switch(i%3)
{
case 1:
Func1(t);
break;
case 2:
Func2(t);
break;
case 3:
Func3(t);
break;
}

}
private int mHeaviness1;
private int mHeaviness2;
private int[] mData;
}
class cCollectionTest implements IBenchTest
{
public void Init(int heaviness1,int heaviness2)
{
mHeaviness1=heaviness1;
mHeaviness2=heaviness2;
mVector=new Vector();
mList=new ArrayList();
mStack=new Stack();
for(int i=0;i<mHeaviness1;i++)
{
mVector.add(new Integer(i));
//System.out.println("init add "+i);
}
}
public void RunTest()
{
for(int i=0;i<mHeaviness2;i++)
{

for (Enumeration e = mVector.elements() ; e.hasMoreElements() ;)
{
int t=((Integer)(e.nextElement())).intValue();
if((t%3)==0)
{
mList.add(new Integer(t));
//System.out.println("list add "+t);
}
if((t%2)==0)
{
mStack.push(new Integer(t));
//System.out.println("stack push "+t);
}
}

while(!mStack.empty())
{
Integer ii=(Integer)mStack.pop();
mList.add(ii);
//System.out.println("stack pop/List add "+ii.intValue());
}
}
}
private int mHeaviness1;
private int mHeaviness2;
private Vector mVector;
private ArrayList mList;
private Stack mStack;
};

class Class2
{

public static void main(String s[])
{
long start,end,timeellapsed;
IBenchTest test;

System.out.println("start <floating point> test");
test=new cFPTest();
test.Init(10000,10000);
start=(new Date()).getTime();
test.RunTest();
end=(new Date()).getTime();
if(end<start)
timeellapsed=end+~start;
else
timeellapsed=end-start;
System.out.println("test take "+timeellapsed+"ms");


System.out.println("integer&logic&calling");
test=new cILTest();
test.Init(10000,1);
start=(new Date()).getTime();
test.RunTest();
end=(new Date()).getTime();
if(end<start)
timeellapsed=end+~start;
else
timeellapsed=end-start;
System.out.println("test take "+timeellapsed+"ms");

System.out.println("collection test");
test=new cCollectionTest();
test.Init(10000,300);
start=(new Date()).getTime();
test.RunTest();
end=(new Date()).getTime();
if(end<start)
timeellapsed=end+~start;
else
timeellapsed=end-start;
System.out.println("test take "+timeellapsed+"ms");

}
}