C#

byte[] data = new byte[size];
[...].unsafe{
  fixed (byte* ptr = data) {
    [...]
    for (int i = 0; i < size; i++)
      ptr[i] = 128;
    [...]
  }
}

byte[] data = new byte[size];
[...].for (int i = 0; i < size; i++)
   data[i] = 128;

byte* ptr = data;
byte* ptrEnd = data;
ptrEnd += (size - (size % 10));
while (ptr != ptrEnd)
{
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
    *ptr = 128; ptr++;
}
ptrEnd += (size % 10);
while(ptr != ptrEnd)
{
    *ptr = 128; ptr++;
}

*(++ptr) = 128;   // Maybe this?
*(ptr++) = 128;   // Or was it this?

Array.Copy(data, 0, length, data, length, length);

Kevin13 wrote:

The C# returns between 30 and 45 ms and the C/C++ a stable 4.2 ms.

 

Is there anything I can do with my C# code to speed it up?

Bastard Programmer from Hell

Eddy Vluggen wrote:

You're comparing native code to an interpreted language

AspDotNetDev wrote:

It's compiled on the machine it is run on, making it possibly faster than pre-compiled code for a more generic architecture.

AspDotNetDev wrote:

My guess is that the C++ compiler is using some special optimization (e.g., MMX instructions, or loop unwinding) that the C# compiler didn't happen to implement for this scenario.

Bastard Programmer from Hell

Eddy Vluggen wrote:

Compiles to bytecode AFAIK, and runs in a VM.

Eddy Vluggen wrote:

No garbage-collector thread in the background, no framework at all.

AspDotNetDev wrote:

The DLL contains bytecode, but when (just before, actually) the DLL is run it gets compiled to native code.

AspDotNetDev wrote:

The garbage collector works in stages. It wouldn't slow down performance in general.

Bastard Programmer from Hell

class Program
{
    static List<String> numbersList = new List<string>();
    static void Main(string[] args)
    {
        int start = Environment.TickCount;
        while (Environment.TickCount - start < 5000)
        {
            numbersList.Add("Tick " + Environment.TickCount);
        }
        Console.WriteLine(numbersList.Count);
        Console.ReadKey();
    }
}

procedure Test1();
var start: dword;
    numbersList: TStringList;
begin
  numbersList := TStringList.Create();
  start := GetTickCount();
  while GetTickCount() - start < 5000 do
  begin
    numbersList.Add('Tick ' + IntToStr(GetTickCount()));
  end;
  WriteLn(numbersList.Count);
  numbersList.Clear;
  numbersList.Free;
end;

begin
  Test1();
  ReadLn();
end.  

procedure Test2();
const testSize = 10000000;
var start: dword;
    data : array[0..testSize] of byte;
    i    : integer;
begin
  start := GetTickCount();
  for i := 0 to testSize do
  begin
     data[i] := 128;
  end;
  WriteLn('Safe time ' +  IntToStr(GetTickCount() - start) + ' ms');
end;

procedure Test2();
const testSize = 10000000;
var start: dword;
    data : array[0..testSize] of byte;
begin
  start := GetTickCount();
  FillChar(data, SizeOf(data), 128);
  WriteLn('Safe time ' +  IntToStr(GetTickCount() - start) + ' ms');
end;

Bastard Programmer from Hell

interface IUndoableCommand {
 void Undo();
 void Redo();
}

class ItemRenameCommand : IUndoableCommand {
 string oldname, newname;
 INamedModel Model { get; set; }
 
 ItemRenameCommand(INamedModel model, string oldname, string newname) {
  this.oldname = oldname; this.newname = newname;
  Model = model;
 }

 void Undo() { Model.Name = oldname; }
 void Redo() { Model.Name = newname; }
}

class MainForm : Form {
 ...
 void TreeNodeRenamed(object sender, NodeRenameEventArgs e){
  IUndoableCommand renameCommand = new ItemRenameCommand(treeViewModel, e.OldName, e.NewName);
  undoStack.Push(renameCommand);
 }

 Stack<IUndoableCommand> undoStack, redoStack;
}

public partial class ConsoleControllerForm : Form {
  [DllImport("user32.dll")]
  [return: MarshalAs(UnmanagedType.Bool)]
  private static extern bool ShowWindow(IntPtr hWnd, Int32 nCmdShow);

  [DllImport("user32.dll")]
  private static extern IntPtr FindWindowW(
    [In] [MarshalAs(UnmanagedType.LPWStr)] String lpClassName,
    [In] [MarshalAs(UnmanagedType.LPWStr)] String WindowName);


  private const String KnownConsoleTitle = "TestApp";
  private IntPtr handle;

  public ConsoleControllerForm() {
    InitializeComponent();
  }

  private void StartBtn_Click(object sender, EventArgs e) {
    StartProcess();
    FindCmd();
  }

  private void FindCmd() {
    handle = FindWindowW(null, KnownConsoleTitle);
    ShowBtn.Enabled = handle != IntPtr.Zero;
  }

  private void ShowBtn_Click(object sender, EventArgs e) {
    ShowWindow(handle, 1); // ShowNormal = 1
  }

  private static void StartProcess() {
    ProcessStartInfo psi = new ProcessStartInfo();
    psi.FileName = @"TestApp.exe";
    psi.UseShellExecute = true;
    psi.CreateNoWindow = false;
    psi.WindowStyle = ProcessWindowStyle.Hidden;
    Process p = Process.Start(psi);
    // Allow process to start. Can't use WaitForIdleInput
    Thread.Sleep(1000);
  }
}

[DllImportAttribute("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)] 
public static extern bool SetConsoleTitle(IntPtr lpConsoleTitle);