My past experiences with Mono
left me unimpressed because of it's speed
issues, in some cases the .NET Framework runing six times faster. But
because a lot of people claim that Mono gets faster with every build,
today I decided to run a small series of tests to see if there have been
any improvements. The results have been very surprising as you will see below.
First of all, this is the C# code used for my tests. Sorry
if it's a little messy :-)
using System;
using System.Collections;
namespace TestNamespace
{
public class
TestClass
{
static long ticks = 0;
public static void
InitTicks()
{
TestClass.ticks = DateTime.Now.Ticks;
}
public static void ShowTime(string str)
{
long newTicks =
DateTime.Now.Ticks;
//milliseconds, not Microsoft :)
double ms = (newTicks
- TestClass.ticks) / TimeSpan.TicksPerMillisecond;
Console.WriteLine("{0}{1} ms",
str.PadRight(35, '.'), ms);
TestClass.ticks = DateTime.Now.Ticks;
}
public static void Test1()
{
ArrayList a = new ArrayList();
for(int i=0;i<1000000;i++)
{
string str =
i.ToString();
a.Add(str);
}
ShowTime("ArrayList strings test");
System.Text.StringBuilder strBuilder = new System.Text.StringBuilder();
Random rnd = new Random();
foreach(object strObj in a)
{
strBuilder.Append(strObj as
string);
strBuilder.Append(rnd.Next().ToString());
}
string s =
strBuilder.ToString();
if(s ==
"Dsadasdasdsa")
{
throw(new Exception("no way..."));
}
ShowTime("StringBuilder test");
}
public static void Test2()
{
int i = 0;
double d = 0.0;
for(i=0;
i<1000000000; i++)
{
d += i;
}
double d2 = d/2;
ShowTime("Integer & Floating ADD");
}
public static void Test3()
{
int i = 0;
int sum = 0;
for(i=0;i<100000;i++)
{
try
{
if(i is int)
{
throw(new Exception("the i integer is an integer.. oh no..."));
}
}
catch(Exception ex)
{
if(ex is NotImplementedException)
{
Console.Write("who's responsable for this
?");
}
}
}
int res = sum/2;
if(res == -321)
throw(new Exception("this is odd"));
ShowTime("Exception test");
}
public static void
Recursive(string str)
{
string name =
System.Reflection.MethodBase.GetCurrentMethod().Name;
if(str.Substring(0,
name.Length) == name)
{
int i =
Convert.ToInt32(str.Substring(name.Length));
if(i < 1000)
{
//
Console.Write(i.ToString()+"\n");
Recursive(name + (i+1).ToString());
}
}
}
public static void Test4()
{
for(int i=0;i<1000;i++)
{
Recursive("Recursive0");
}
ShowTime("Reflection and recursion");
}
public static void Main()
{
InitTicks();
Test1();
Test2();
Test3();
Test4();
}
}
}
This code
contains 5 tests:
|
Test
name
|
Function
name
|
Details
|
|
ArrayList
test
|
Test1,
1st part
|
1
million strings are inserted into an ArrayList.
|
|
StringBuilder
test
|
Test1,
2nd part
|
The
strings from the ArrayList are appended to a StringBuilder.
|
|
Integer
& Floating ADD test
|
Test2
|
An
integer is added to a double 1 billion times.
|
|
Exception
test
|
Test3
|
100.000
exceptions are thrown.
|
|
Recursion
and reflection test
|
Test4
|
A
recursive function that calls GetCurrentMethod() is called for 1000 times. (see
more details in code)
|
I almost forgot to specify my configuration: Athlon
XP 2600+, 1 GB RAM PC2700, 80 GB 7200 2MB HDD,
WindowsXP SP2. Now, to the really interesting part.
There are the results when compiling with the
optimizations off. As you can see, it's unbelievable how similar the timings
are.
-----------------------------------------------------------------------------
Running Mono binary:
ArrayList strings test.............890 ms
StringBuilder test.................1046 ms
Integer & Floating ADD.............2000 ms
Exception test.....................890 ms
Reflection and recursion...........3859 ms
-----------------------------------------------------------------------------
Running Framework binary:
ArrayList strings test.............921 ms
StringBuilder test.................1062 ms
Integer & Floating ADD.............1968 ms
Exception test.....................859 ms
Reflection and recursion...........3859 ms
-----------------------------------------------------------------------------
When I turned the optimizations on in both CSC and MCS
(the Mono C# compiler) the Integer & Floating ADD Test ran two times
faster with the .NET Framework. However, because this is a very simple test,
the optimizations used may not be appliable in any real-life applications.
Other than that there are no noticeable differences between the timings
obtained with or without the optimize+
flag. That's right, the same flags are used in Mono, but they are
passed with a '-' charater instread of a '/'. Here are he results:
-----------------------------------------------------------------------------
Running Mono binary:
ArrayList strings test.............890 ms
StringBuilder test.................1046 ms
Integer & Floating ADD.............2015 ms
Exception test.....................859 ms
Reflection and recursion...........3890 ms
-----------------------------------------------------------------------------
Running Framework binary:
ArrayList strings test.............921 ms
StringBuilder test.................1078 ms
Integer & Floating ADD.............984 ms
Exception test.....................812 ms
Reflection and recursion...........3875 ms
-----------------------------------------------------------------------------
With speed no longer an issue, the only important thing
that is now missing from Mono is Windows.Forms, but this is under heavy development
and I'm sure we are going to see it in future releases.
After doing these tests and viewing the results, I only
have two gthings to say:
1. Thank you Microsoft for .NET and
C#.
2. Thank you Mono for true
cross-platform development (almost there).