Not sure, but the following program runs in just over 3 seconds on my
laptop, as does the equivalent in Java.

using System;

public class Test
{
   int a=0;
   
   static void Main()
   {
       Test t = new Test();
       DateTime start = DateTime.Now;
       for (int x = 0; x < 1000000000; x++) t.SomeMethod();
       DateTime end = DateTime.Now;
       Console.WriteLine (end-start);
   }
   
   void SomeMethod()
   {
       a=a+a;
   }
}

Then again, I got rather different results in the JIT compiled machine
code, where the main part is:

[0033] xor         edx,edx
[0035] mov         eax,dword ptr [esi+4]
[0038] add         dword ptr [esi+4],eax
[003b] inc         edx
[003c] cmp         edx,3B9ACA00h
[0042] jl          FFFFFFF3

I got my disassembly using cordbg, with mode JitOptimizations=1, after
building the code without debug information. How did you get yours?

The JIT compiler doesn't optimize while the application is
beeing debugged.

Insert the statement System.Diagnostics.Debugger.Break()
somewhere after the calculation, start the app (but not
from within the the IDE!!) and wait for the debugger to pop up.

You'll get a better performance then from the Delphi
compiler.

bye
Rob

Here is the code, simply paste it and run in Release mode. Couldn't get any register optimization on it.
Dissassembled by pressing Brake All button in VS.NET IDE. (Yes, I run it in IDE, but without IDE it takes the same time to complete anyway).

Can you reproduce it too? I have .NET framework 1.1.

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
using System.Runtime.InteropServices;

namespace WindowsApplication1
{
/// <summary>
/// Summary description for Form1.
/// </summary>
///
public class Form1 : System.Windows.Forms.Form
{
private System.Windows.Forms.Button button1;
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.Container components = null;
public Form1()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
}
[DllImport("kernel32.dll")]
public static extern int GetTickCount();
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose( bool disposing )
{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.button1 = new System.Windows.Forms.Button();
this.SuspendLayout();
//
// button1
//
this.button1.Location = new System.Drawing.Point(104, 112);
this.button1.Name = "button1";
this.button1.TabIndex = 0;
this.button1.Text = "Run Test";
this.button1.Click += new System.EventHandler(this.button1_Click);
//
// Form1
//
this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
this.ClientSize = new System.Drawing.Size(292, 272);
this.Controls.Add(this.button1);
this.Name = "Form1";
this.Text = "Here come the time";
this.ResumeLayout(false);
}
#endregion
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.Run(new Form1());
}
private int a = 0;
private void someMethod()
{
a=a+a;
}
private void button1_Click(object sender, System.EventArgs e)
{
int a = GetTickCount();
for (int x = 0; x < 1000000000; x++) someMethod();
a = GetTickCount() - a;
Text = a.ToString();
}
}
}

Hi,

I just tested John's sample and have acountered the following
problem: MarshalByRefObjects members are not beeing optimized by
the JIT like other objects. In the following sample "someMethod()"
will not be inlined when the class is a MarshalByRefObject.

Is this a documented "feature"??

bye
Rob

//
// compile csc /o+ /debug- bench.cs
//
using System;
using System.Diagnostics;

// use this to get the optimized version: class App {
class App : MarshalByRefObject {
    int a = 0;

    private void someMethod()
    {
        a = a + a;
    }

    static void Main()
    {
        App app = new App();
        DateTime t = DateTime.Now;
        for (int x = 0; x < 1000000000; x++) app.someMethod();
        Console.WriteLine(DateTime.Now - t);
    }
}

So, based on that, use a nested class

[DllImport("kernel32.dll")]
public static extern int GetTickCount();

private class myClass
{
static int a = 0;

public static void someMethod()
{
 a = a + a;
}
}

private void button1_Click(object sender, System.EventArgs e)
{
int a = GetTickCount();
for (int x = 0; x < 1000000000; x++)  myClass.someMethod();
a = GetTickCount() - a;
Text = a.ToString();
}

Runs in 1.9 seconds on my machine - previously 15.5 seconds..

Cheers,

Stu
 Just installed .NET Framework 1.1 and VS.NET 2003. Wrote a simple program:

 [DllImport("kernel32.dll")]
 public static extern int GetTickCount();

 int a = 0;

 private void someMethod()
 {
     a = a + a;
 }

 private void button1_Click(object sender, System.EventArgs e)
 {
     int a = GetTickCount();
     for (int x = 0; x < 1000000000; x++) someMethod();
     a = GetTickCount() - a;
     Text = a.ToString();
 }

 I have AMD Athlon XP 2600+ (1.9GHz). This program compiled in Release more works 19 seconds. The same code in Delphi 5 works 3 seconds, 2 seconds in Java 1.4. What's wrong with .NET?

 After analyzing the machine code produced by JIT compiler everything becomes clear.
 .NET has no register optimization!!!
 The loop variable x - is used via stack reference and not assigned to register variable!
 Here are the opcodes produced for loop:

 0000002f mov ecx,esi
 00000031 call dword ptr ds:[00975A00h]      ; Calling someMethod
 00000037 inc dword ptr [ebp-10h]            ; x++          
 0000003a cmp dword ptr [ebp-10h],3B9ACA00h  ; if x < 1kkk
 00000041 jl 0000002F                        ; jump

 Method someMethod opcodes:

 00000000 push ebp
 00000001 mov ebp,esp
 00000003 push eax
 00000004 push esi
 00000005 mov esi,ecx
 00000007 mov eax,dword ptr [esi+000000E4h]
 0000000d add dword ptr [esi+000000E4h],eax
 00000013 nop
 00000014 pop esi
 00000015 mov esp,ebp
 00000017 pop ebp
 00000018 ret

 I dont know why, but there is simply NO ANY KIND of OPTIMIZATION available in this code.
 Maybe I need to switch it on somehow? If so, why it is not on by default?

 Does anybody know?