Speed of code execution: IronPython vs C#?

Question

Am trying to provide a response from a Managers perspective to the question: What overall performance penalty will we incur if we write the application in IronPython instead of C#?

This question is directed at those who might have already undertaken some testing, benchmarking or have completed a migration from C# to IronPython, in order to quantify the penalty.

Answer 1

I created a C# console application (I'm not very good at C#), which basically encrypts an input file using a xor cipher.

Code below:

using System;
using System.IO;
using System.Text;
using System.Diagnostics;

namespace XorCryptor
{
    class Program
    {
        public static void Main(string[] args)
        {
            if(args.Length != 3)
            {
                Console.WriteLine("Usage: xorcryptor password file_in.txt file_out.txt");
                Console.Write("Press any key to continue...");
                Console.ReadKey(true);
                return;
            }
            Stopwatch sw = Stopwatch.StartNew();
            BinaryReader infileb;
            try{
                infileb = new BinaryReader(File.Open(args[1], FileMode.Open));
            }catch(IOException){
                Console.WriteLine("Error reading from input file (is it in use by another program?)");
                return;
            }
            byte[] encb = Crypt(infileb.ReadBytes((int)infileb.BaseStream.Length),args[0]);
            infileb.Close();
            BinaryWriter outfileb;
            try{
                outfileb = new BinaryWriter(File.Open(args[2], FileMode.Create));
            }catch(IOException){
                Console.WriteLine("Error writing to output file (is it in use by another program?)");
                return;
            }
            outfileb.Write(encb);
            outfileb.Close();
            sw.Stop();
            Console.WriteLine("Size: "+encb.Length.ToString());
            Console.WriteLine("Elapsed milliseconds: "+sw.ElapsedMilliseconds.ToString());
        }
        internal static byte[] Crypt(byte[] text, string password)
        {
            int i2 = 0;
            byte[] result = new byte[text.Length];
            foreach(byte b in text)
            {
                result[i2] = Convert.ToByte(b ^ password[i2 % password.Length]);
                i2++;
            }
            return result;
        }
    }
}

and then the equivalent Python version, (I used SharpDevelop 4.0 to build an executable):

import System
from System.IO import File, FileMode, BinaryReader, BinaryWriter
from System.Diagnostics import Stopwatch
import sys

def crypt(text, password):
    result = System.Array.CreateInstance(System.Byte, text.Length)
    for i, b in enumerate(text):
        result[i] = System.Convert.ToByte(b ^ ord(password[i % len(password)]))
    return result

argv = System.Environment.GetCommandLineArgs()

if len(argv) != 4:
    print "Usage: pyxorcryptor password file_in file_out"
    print "Press any key to exit...",
    System.Console.ReadKey(True)
    sys.exit(1)

sw = Stopwatch.StartNew()
try:
    infileb = BinaryReader(File.Open(argv[2], FileMode.Open))
    outfileb = BinaryWriter(File.Open(argv[3], FileMode.Create))
except IOException, e:
    print e.ToString()
    sys.exit(1)
encb = crypt(infileb.ReadBytes(int(infileb.BaseStream.Length)), argv[1])
infileb.Close()
outfileb.Write(encb)
outfileb.Close()
sw.Stop()

print "Size: {0}\nTime (ms): {1}".format(len(encb), sw.ElapsedMilliseconds)

Testing their speeds with the same plaintext 3,827 kb file, I get this:

---

C#:

• Size: 3928779
• Elapsed milliseconds: 73

---

IronPython 2.6 for .NET 4.0

• Size: 3928779
• Time (ms): 16825

---

So I think we can conclude that IronPython is significantly slower than C#, in this particular scenario.

I might have made a mistake somewhere in my code in those two files, so feel free to point them out. I'm still learning.

Answer 2

In the mono environment, using a limited number of benchmarks, IronPython 2.6.1 looks to be 7 to 120 times slower than C# according to the Computer Language Benchmarks Game Site.

Answer 3

Based on my understanding both languages will be compiled into MSIL so theoretically the performance of the application should be identical or very close, but there is a lot more to it, the human factor.

I can assure you that a program I write in C# could be a lot faster that the same program in iron-python not because C# is faster but because I'm more familiar with C# and I know what choices to make, so if your team is more familiar with C# your application has a better chance at performance if it is written in C# or the other way around.

This is just a personal theory so take it with a grain of salt.

Answer 4

IronPython performance will be always a little bit slower than C# because it is interpreted language. You can see it on jcao219 answer although it is not a good example.

But speed of development actually matters more that performance. Developing application in IronPython is faster than in C# for good IronPython developer. Of course, you should not consider developing application in IronPython when you (and your colleagues) are better in C#.

The overall performance heavily depends on what the code do. Encrypting in IronPython is not a good idea. Spreadsheet application is a good idea - see Resolver One. They thought about converting code from IronPython to C# but they have not done it yet because it is not necessary. When they needed to speed up the code, they have found a way in IronPython itself how to do it.