...Evaluation of baseSim for C# Simulation (.NET Framework 3.5)

This White Paper evaluates the porting of the baseSim Simulation Components from Delphi object pascal (Win32) into Visual Studio 2008 to create C# Simulation Models (.NET Framework 3.5).

The mission is to produce a set of Simulation Components in pure .NET (C# Simulation) that is as feature rich, flexible and fast as those already created in Delphi object pascal (Win32).

The conversion of baseSim to .NET is ongoing and will be completed in the following evaluation stages:

		Evaluation v.1 - completed 31 May 2008 Initial 'command line only' (console) release to support the 'Aircraft Assembly Line' demonstration Model. baseSim assembles will be required to be copied to the Model folder i.e. not installed into the Global Assembly Cache (GAC)
		Evaluation v.2 - completed 30 Jun 2008 Second (console) release, supporting the 'Automotive Supplier' demonstration Model
		Evaluation v.3 - completed 12 Aug 2008 Third (console) release, completing the baseSim migration up to baseSim v.3 (baseSim Standard and baseSim Professional modules). Also supporting the 'Customer Services' demonstration Model
		Evaluation v.4 - TBC Fourth release incorporating the GUI elements to produce visual simulation Models (matching those created with Delphi). baseSim assemblies will now be installable in the GAC
		Evaluation v.5 - TBC Fifth release including Design-time support in Visual Studio

Rationale

iBright began coding baseSim in Delphi 6 object pascal (Win32) back in 2001.

Delphi was and is a fantastically rich development environment - allowing the creation of graphically rich, easy to use and most importantly fast Simulation Models. Code produced by Delphi easily matched the performance of other Win32 development tools, such as C++, but allowed for much quicker application development (Rapid Application Development - RAD).

However, Delphi has never been as popular as it's Microsoft rivals such as Microsoft C++ and latterly Microsoft C# (and other .NET equivalents) - this is just a simple fact.

So, back in 2003 we investigated the possibility of creating a version of baseSim for the newly released .NET framework 1.1.

After a period of evaluation we came to the conclusion that the .NET Framework was considerably slower than Delphi for Win32. We couldn't justify creating a 'slower' version of baseSim as speed has always been one of baseSim's key strengths!

So the plan to create a .NET version of baseSim has largely been on hold since then.

However, when we re-evaluated the situation after the release of .NET Framework 3.5 in late 2007 we were pleasantly surprised. In fact, our initial tests have proved that baseSim for .NET (C# Simulation) performs just as fast as baseSim for Delphi Win32 (written in object pascal).

Therefore, we feel the time is now right for a fully ported version of baseSim for the .NET Framework 3.5, which can be used to create high speed Simulation Models with Microsoft Visual Studio 2008 (C# or Visual Basic languages).

Evaluation v.1

This is the initial 'command line only' (console) release to support the 'Aircraft Assembly Line' demonstration Model.

The accompanying compiled programs and source code for this evaluation can be downloaded free of charge from the iBright Shop.

The Evaluation Package is divided into three sections...

Visual Studio 2008 (C# Simulation Console)

This Model is based on the baseSim 'Aircraft Assembly Line' demonstration Model and has been compiled with Microsoft Visual Studio 2008.

It uses the .NET assembly 'baseSimControl_v3_VS2008.dll' which has been included in the same folder as the Model (the baseSim assemblies are not currently integrated into the Global Assembly Cache - GAC).

If you run the 'Aircraft Assembly Line' demonstration Model 'MainConsolePrj.exe' then you will see the Model execution illustrated in Figure 1.

Aircraft Assembly Line C# Simulation Model, compiled in .NET

Figure 1 - Aircraft Assembly Line Model compiled in .NET

The key metric of this Model is that it processes 8 million Simulation Events in 2.2 seconds. This directly compares with the same demonstration Model compiled in Delphi (Win32) as seen in Figure 3.

The Model was written in C# - a source listing can be seen in Figure 2 below. The Model construction can be directly compared to that created in Delphi (object pascal) in Figure 4.

using System;
using System.Collections.Generic;
using System.Text;
using iBright.baseEngine.Controls;
using iBright.baseSim.Controls;
using iBright.baseEngine.Professional;
using iBright.baseSim.Professional;

namespace MainConsolePrj
{
    class MainConsoleUnt
    {
        public Tbs3ModelManager ModelManager;
        public Tbs3EventManager EventManager;
        public Tbs3SubNodeCacheManager SubNodeCacheManager;
        public Tbs3EventCacheManager EventCacheManager;
        public Tbs3LogManager LogManager;

        public void CreateInfrastructure()
        {
            EventManager = new Tbs3EventManager();
            EventManager.MultiThreaded = false;
            LogManager = new Tbs3LogManager();
            LogManager.LogOutput = TLogOutput.loConsole;
            ModelManager = new Tbs3ModelManager();
            ModelManager.ModelEventControl = EventManager;
            SubNodeCacheManager = new Tbs3SubNodeCacheManager();
            SubNodeCacheManager.ModelControl = ModelManager;
            EventCacheManager = new Tbs3EventCacheManager();
            EventManager.EventCacheControl = EventCacheManager;
        }

        public void BuildModel()
        {
            Tbs3ProcessSource ProcSrc;
            Tbs3ProcessFlow Proc1;
            Tbs3ProcessFlow Proc2;
            Tbs3ProcessFlow Proc3;
            Tbs3ProcessFlow Proc4;
            Tbs3DistributionManager Dist1;
            Tbs3DistributionManager Dist2;
            Tbs3DistributionManager Dist3;
            Tbs3DistributionManager Dist4;
            Tbs3DistributionManager Dist5;
            Tbs3ProcessDrain ProcDrn;
            Tbs3FrameManager FrameManager;

            Console.WriteLine("Building Model...");
            LogManager.StartWatch();

            FrameManager = ModelManager.Add();
            FrameManager.Width = 620;
            FrameManager.Height = 390;

            //Add Controls
            ProcSrc = FrameManager.Add() as Tbs3ProcessSource;
            ProcSrc.Left = 40;
            ProcSrc.Top = 120;
            ProcSrc.SubNodeClassName = "iBright.baseSim.Controls.Tbs3BaseSubNode";
            ProcSrc.NumToGen = 1000000;
            ProcSrc.Name = "SimSource1";
            ProcSrc.SubNodeCacheControl = SubNodeCacheManager;

            Proc1 = FrameManager.Add() as Tbs3ProcessFlow;
            Proc1.Capacity = 2;
            Proc1.Left = 144;
            Proc1.Top = 120;
            Proc1.Name = "Build_Op";

            Proc2 = FrameManager.Add() as Tbs3ProcessFlow;
            Proc2.Left = 248;
            Proc2.Top = 120;
            Proc2.Name = "Finish_Op_1";

            Proc3 = FrameManager.Add() as Tbs3ProcessFlow;
            Proc3.Left = 352;
            Proc3.Top = 120;
            Proc3.Name = "Finish_Op_2";

            Proc4 = FrameManager.Add() as Tbs3ProcessFlow;
            Proc4.Left = 456;
            Proc4.Top = 120;
            Proc4.Name = "Finish Op 3";

            ProcDrn = FrameManager.Add() as Tbs3ProcessDrain;
            ProcDrn.Left = 552;
            ProcDrn.Top = 120;
            ProcDrn.Name = "SimSink1";
            ProcDrn.SubNodeCacheControl = SubNodeCacheManager;

            Dist1 = FrameManager.Add() as Tbs3DistributionManager;
            Dist1.DistributionDefault = TDistributionType.ddConstant;
            Dist1.DistributionParameters.dpConst = 60000;
            Dist1.Left = 40;
            Dist1.Top = 216;
            ProcSrc.IntervalDist = Dist1;
            Dist1.LayerLevel = -1;
            Dist1.Name = "SimDist1";

            Dist2 = FrameManager.Add() as Tbs3DistributionManager;
            Dist2.DistributionDefault = TDistributionType.ddConstant;
            Dist2.DistributionParameters.dpConst = 120000;
            Dist2.Left = 144;
            Dist2.Top = 216;
            Proc1.ProcessDist = Dist2;
            Dist2.LayerLevel = -1;
            Dist2.Name = "Build_Op_Time";

            Dist3 = FrameManager.Add() as Tbs3DistributionManager;
            Dist3.DistributionDefault = TDistributionType.ddConstant;
            Dist3.DistributionParameters.dpConst = 60000;
            Dist3.Left = 352;
            Dist3.Top = 216;
            Proc2.ProcessDist = Dist3;
            ProcDrn.ProcessDist = Dist3;
            Dist3.LayerLevel = -1;
            Dist3.Name = "Standard_Finish_Op_Time";

            Dist4 = FrameManager.Add() as Tbs3DistributionManager;
            Dist4.DistributionDefault = TDistributionType.ddTriangle;
            Dist4.UpperBound = 90000;
            Dist4.DistributionParameters.dpA = 50000;
            Dist4.DistributionParameters.dpB = 120000;
            Dist4.DistributionParameters.dpC = 55000;
            Dist4.Left = 352;
            Dist4.Top = 40;
            Proc3.ProcessDist = Dist3;
            Dist4.LayerLevel = -1;
            Dist4.Name = "Finish_Op_2_New_Time";

            Dist5 = FrameManager.Add() as Tbs3DistributionManager;
            Dist5.DistributionDefault = TDistributionType.ddTriangle;
            Dist5.UpperBound = 90000;
            Dist5.DistributionParameters.dpA = 45000;
            Dist5.DistributionParameters.dpB = 120000;
            Dist5.DistributionParameters.dpC = 50000;
            Dist5.Left = 456;
            Dist5.Top = 24;
            Proc4.ProcessDist = Dist3;
            Dist5.LayerLevel = -1;
            Dist5.Name = "Finish_Op_3_Time";

            //Link Controls
            ProcSrc.Successors.Add().Connection = Proc1;
            Proc1.Successors.Add().Connection = Proc2;
            Proc2.Successors.Add().Connection = Proc3;
            Proc3.Successors.Add().Connection = Proc4;
            Proc4.Successors.Add().Connection = ProcDrn;

            Console.WriteLine("Elaspsed Time  : " + String.Format("{0:f3}", 
                LogManager.StopWatch().TotalSeconds) + " (Seconds)");
        }

        public void StartModel()
        {
            Console.WriteLine("Starting Model...");
            LogManager.StartWatch();
            EventManager.Init();
            Console.WriteLine("Elaspsed Time  : " + String.Format("{0:f3}", 
               LogManager.StopWatch().TotalSeconds) + " (Seconds)");
            Console.WriteLine("Running...");
            EventManager.Start();
        }

        public void OutputResults()
        {
            Console.WriteLine("Simulation Summary Results...");
            Console.WriteLine("Simulation Time: " + be2Utilities.SimTimeToStr(
                EventManager.CurrentTime));
            Console.WriteLine("Elaspsed Time  : " + String.Format("{0:f3}", 
                (double)EventManager.ElapsedTime / be2Constants.C_MSECS_PER_SEC) + 
                " (Seconds)");
            Console.WriteLine("Event Count    : " + String.Format("{0:n0}", 
                EventManager.EventCount) + " (Events)");
            Console.WriteLine("Hit  to exit...");
            Console.ReadLine();
        }
    }
}

Figure 2 - Aircraft Assembly Line Model C# Simulation Source Code

If you would like to have examine this Model in Visual Studio 2008 then the .NET source code is included in a sub folder. Please open the project in Visual Studio 2008 and change the 'reference path' of the ' baseSimControl_v3_VS2008.dll' assembly to the appropriate location on your system.

Delphi 2007 (Win32 Console)

This Model is based on the baseSim 'Aircraft Assembly Line' demonstration Model and has been compiled with Delphi 2007 (Win32).

If you run the 'Aircraft Assembly Line' demonstration Model 'MainConsolePrj.exe' then you will see the Model execution illustrated in Figure 3.

Aircraft Assembly Line Model compiled in .NET

Figure 3 - Aircraft Assembly Line Model compiled in Delphi Win32

The key metric of this Model is that it processes 8 million Simulation Events in 2.2 seconds. This directly compares with the same demonstration Model compiled in Visual Studio 2008 (C# Simulation) as seen in Figure 1.

The Model was written in Delphi 2007 object pascal (Win32) - a source listing can be seen in Figure 4 below. The Model construction can be directly compared to that created in C# in Figure 2.

unit MainConsoleUnt;

interface

uses
  SysUtils, be2Constants, be2Types, be2Utilities, be2Controls, be2ModelManager,
  bs3ModelManager, bs3EventManager, bs3ProcessSource, bs3ProcessFlow,
  bs3DistributionManager, bs3ProcessDrain, bs3SubNodeCacheManager,
  bs3EventCacheManager, be2LogManager, bs3LogManager;

procedure BuildModel;
procedure CreateInfrastructure;
procedure DestroyInfrastructure;
procedure StartModel;
procedure OutputResults;

implementation

var
  ModelManager: Tbs3ModelManager;
  EventManager: Tbs3EventManager;
  SubNodeCacheManager: Tbs3SubNodeCacheManager;
  EventCacheManager: Tbs3EventCacheManager;
  LogManager: Tbs3LogManager;

procedure CreateInfrastructure;
begin
  EventManager := Tbs3EventManager.Create(nil);
  with EventManager do
  begin
    MultiThreaded := False;
  end;
  LogManager := Tbs3LogManager.Create(nil);
  with LogManager do
  begin
    LogOutput := loConsole;
  end;
  ModelManager := Tbs3ModelManager.Create(nil);
  with ModelManager do
  begin
    ModelEventControl := EventManager;
  end;
  SubNodeCacheManager := Tbs3SubNodeCacheManager.Create(nil);
  SubNodeCacheManager.ModelControl := ModelManager;
  EventCacheManager := Tbs3EventCacheManager.Create(nil);
  EventManager.EventCacheControl := EventCacheManager;
end;

procedure DestroyInfrastructure;
begin
  EventManager.Free;
  ModelManager.Free;
  LogManager.Free;
  SubNodeCacheManager.Free;
  EventCacheManager.Free;
end;

procedure BuildModel;
var
  ProcSrc: Tbs3ProcessSource;
  Proc1, Proc2, Proc3, Proc4: Tbs3ProcessFlow;
  Dist1, Dist2, Dist3, Dist4, Dist5: Tbs3DistributionManager;
  ProcDrn: Tbs3ProcessDrain;
begin
  with LogManager do
  begin
    WriteLine('Building Model...');
    StartWatch;
  end;

  with Tbs3FrameManager(ModelManager.Add) do
  begin
    Width := 620;
    Height := 390;

    //Add Controls
    ProcSrc := Tbs3ProcessSource(Add(Tbs3ProcessSource));
    ProcSrc.Left := 40;
    ProcSrc.Top := 120;
    ProcSrc.SubNodeClassName := 'Tbs3BaseSubNode';
    ProcSrc.NumToGen := 1000000;
    ProcSrc.Name := 'SimSource1';
    ProcSrc.SubNodeCacheControl := SubNodeCacheManager;

    Proc1 := Tbs3ProcessFlow(Add(Tbs3ProcessFlow));
    Proc1.Capacity := 2;
    Proc1.Left := 144;
    Proc1.Top := 120;
    Proc1.Name := 'Build_Op';

    Proc2 := Tbs3ProcessFlow(Add(Tbs3ProcessFlow));
    Proc2.Left := 248;
    Proc2.Top := 120;
    Proc2.Name := 'Finish_Op_1';

    Proc3 := Tbs3ProcessFlow(Add(Tbs3ProcessFlow));
    Proc3.Left := 352;
    Proc3.Top := 120;
    Proc3.Name := 'Finish_Op_2';

    Proc4 := Tbs3ProcessFlow(Add(Tbs3ProcessFlow));
    Proc4.Left := 456;
    Proc4.Top := 120;
    Proc4.Name := 'Finish Op 3';

    ProcDrn := Tbs3ProcessDrain(Add(Tbs3ProcessDrain));
    ProcDrn.Left := 552;
    ProcDrn.Top := 120;
    ProcDrn.Name := 'SimSink1';
    ProcDrn.SubNodeCacheControl := SubNodeCacheManager; 

    Dist1 := Tbs3DistributionManager(Add(Tbs3DistributionManager));
    Dist1.DistributionDefault := ddConstant;
    Dist1.DistributionParameters.dpConst := 60000;
    Dist1.Left := 40;
    Dist1.Top := 216;
    ProcSrc.IntervalDist := Dist1;
    Dist1.LayerLevel := -1;
    Dist1.Name := 'SimDist1';

    Dist2 := Tbs3DistributionManager(Add(Tbs3DistributionManager));
    Dist2.DistributionDefault := ddConstant;
    Dist2.DistributionParameters.dpConst := 120000;
    Dist2.Left := 144;
    Dist2.Top := 216;
    Proc1.ProcessDist := Dist2;
    Dist2.LayerLevel := -1;
    Dist2.Name := 'Build_Op_Time';

    Dist3 := Tbs3DistributionManager(Add(Tbs3DistributionManager));
    Dist3.DistributionDefault := ddConstant;
    Dist3.DistributionParameters.dpConst := 60000;
    Dist3.Left := 352;
    Dist3.Top := 216;
    Proc2.ProcessDist := Dist3;
    ProcDrn.ProcessDist := Dist3;
    Dist3.LayerLevel := -1;
    Dist3.Name := 'Standard_Finish_Op_Time';

    Dist4 := Tbs3DistributionManager(Add(Tbs3DistributionManager));
    Dist4.DistributionDefault := ddTriangle;
    Dist4.UpperBound := 90000;
    Dist4.DistributionParameters.dpA := 50000;
    Dist4.DistributionParameters.dpB := 120000;
    Dist4.DistributionParameters.dpC := 55000;
    Dist4.Left := 352;
    Dist4.Top := 40;
    Proc3.ProcessDist := Dist3;
    Dist4.LayerLevel := -1;
    Dist4.Name := 'Finish_Op_2_New_Time';

    Dist5 := Tbs3DistributionManager(Add(Tbs3DistributionManager));
    Dist5.DistributionDefault := ddTriangle;
    Dist5.UpperBound := 90000;
    Dist5.DistributionParameters.dpA := 45000;
    Dist5.DistributionParameters.dpB := 120000;
    Dist5.DistributionParameters.dpC := 50000;
    Dist5.Left := 456;
    Dist5.Top := 24;
    Proc4.ProcessDist := Dist3;
    Dist5.LayerLevel := -1;
    Dist5.Name := 'Finish_Op_3_Time';

    //Link Controls
    ProcSrc.Successors.Add.Connection := Proc1;
    Proc1.Successors.Add.Connection := Proc2;
    Proc2.Successors.Add.Connection := Proc3;
    Proc3.Successors.Add.Connection := Proc4;
    Proc4.Successors.Add.Connection := ProcDrn;
  end;

  with LogManager do
    WriteLine('Elaspsed Time  : ' + Format('%0.3n', [StopWatch * 86400]) + ' (Seconds)');
end;

procedure StartModel;
begin
  with LogManager do
  begin
    WriteLine('Starting Model...');
    StartWatch;
  end;
  EventManager.Init;
  with LogManager do
  begin
    WriteLine('Elaspsed Time  : ' + Format('%0.3n', [StopWatch * 86400]) + ' (Seconds)');
    WriteLine('Running...');
  end;
  EventManager.Start;
end;

procedure OutputResults;
begin
  with LogManager, EventManager do
  begin
    WriteLine('Simulation Summary Results...');
    WriteLine('Simulation Time: ' + SimTimeToStr(CurrentTime));
    WriteLine('Elaspsed Time  : ' + Format('%0.3n', [ElapsedTime / 1000]) + ' (Seconds)');
    WriteLine('Event Count    : ' + Format('%0.0n', [EventCount * 1.0]) + ' (Events)');
    WriteLine('Hit  to exit...');
  end;
  Readln;
end;

end.

Figure 4 - Aircraft Assembly Line Model Delphi Source Code

Delphi 2007 (Win32 GUI)

This Model is based on the baseSim 'Aircraft Assembly Line' demonstration Model and has been compiled with Delphi 2007 (Win32), incorporating baseSim's Graphical User Interface capabilities (in this example compiled with the 'Application' User Interface).

If you run the 'Aircraft Assembly Line' demonstration Model 'MainConsolePrj.exe' then you will see the Model execution illustrated in Figure 5 (please first disable 'Show All Animation' and 'Update SimTime' options prior to execution, in order to fully compare performance).

Figure 5 - Aircraft Assembly Line Model compiled in Delphi Win32 with the baseSim Application User Interface

Conclusion

This first Evaluation release proves that baseSim for .NET produces exactly the same results as baseSim for Delphi (Win32) with identical performance, therefore providing baseSim Users with a viable and popular alternative to Delphi and object pascal.

Evaluation v.2

In addition to the Model(s) and functionality contained in Evaluation 1, this release includes the 'Automotive Supplier' demonstration Model, compiled in Visual Studio 2008 (.NET console), Delphi 2007 (Win32 console) and Delphi 2007 (Win32 GUI). The latter two Delphi Models are included for comparison purposes.

The 'Automotive Supplier' C# Simulation Model source code is also included.

The accompanying compiled programs and source code for this evaluation can be downloaded free of charge from the iBright Shop.

This Evaluation Package is divided into three sections...

Visual Studio 2008 (C# Simulation Console)

This Model is based on the baseSim 'Automotive Supplier' demonstration Model and has been compiled with Microsoft Visual Studio 2008.

It uses the .NET assemblies 'baseSimControl_v3_VS2008.dll' and 'baseSimProfessional_v3_VS2008.dll' which have been included in the same folder as the Model (the baseSim assemblies are not currently integrated into the Global Assembly Cache - GAC).

If you run the 'Automotive Supplier' demonstration Model 'MainConsolePrj.exe' then you will see the Model execution illustrated in Figure 6.

Automotive Supplier C# Simulation Model, compiled in .NET

Figure 6 - Automotive Supplier Model compiled in .NET

The key metric of this Model is that it processes 95,769 Simulation Events in 0.1 seconds. This directly compares with the same demonstration Model compiled in Delphi (Win32) as seen in Figure 7.

Delphi 2007 (Win32 Console)

This Model is based on the baseSim 'Automotive Supplier' demonstration Model and has been compiled with Delphi 2007 (Win32).

If you run the 'Automotive Supplier' demonstration Model 'MainConsolePrj.exe' then you will see the Model execution illustrated in Figure 7.

Automotive Supplier Model compiled in .NET

Figure 7 - Automotive Supplier Model compiled in Delphi Win32

The key metric of this Model is that it processes 95,769 Simulation Events in 0.07 seconds. This directly compares with the same demonstration Model compiled in Visual Studio 2008 (C# Simulation) as seen in Figure 6.

Delphi 2007 (Win32 GUI)

This Model is based on the baseSim 'Automotive Supplier' demonstration Model and has been compiled with Delphi 2007 (Win32), incorporating baseSim's Graphical User Interface capabilities (in this example compiled with the 'Application' User Interface).

If you run the 'Automotive Supplier' demonstration Model 'MainConsolePrj.exe' then you will see the Model execution illustrated in Figure 8 (please first disable 'Show All Animation' and 'Update SimTime' options prior to execution, in order to fully compare performance).

Figure 8 - Automotive Supplier Model compiled in Delphi Win32 with the baseSim Application User Interface

The key metric of this Model is that it processes 95,768 Simulation Events in 0.08 seconds. This directly compares with the same demonstration Model compiled in Visual Studio 2008 (C# Simulation) as seen in Figure 6.

Conclusion

The .NET Assemblies 'baseSimControl_v3_VS2008.dll ' (Standard Module) and 'baseSimProfessional_v3_VS2008.dll' (Professional Module) have been further developed to support advanced baseSim functionality such as hierarchical Models and tabular data storage.

Evaluation v.3

In addition to the Model(s) and functionality contained in Evaluation 2, this release includes the 'Customer Services' demonstration Model, compiled in Visual Studio 2008 (.NET console) and Delphi 2007 (Win32 console). The latter Delphi Model is included for comparison purposes.

The 'Customer Services' C# Simulation Model source code is also included.

The accompanying compiled programs and source code for this evaluation can be downloaded free of charge from the iBright Shop.

This Evaluation Package is divided into two sections...

Visual Studio 2008 (C# Simulation Console)

This Model is based on the baseSim 'Customer Services' demonstration Model and has been compiled with Microsoft Visual Studio 2008.

The key metric of this Model is that it processes 405 Simulation Events in 0.02 seconds. This directly compares with the same demonstration Model compiled in Delphi (Win32).

Delphi 2007 (Win32 Console)

This Model is based on the baseSim 'Customer Services' demonstration Model and has been compiled with Delphi 2007 (Win32).

The key metric of this Model is that it processes 405 Simulation Events in 0.01 seconds. This directly compares with the same demonstration Model compiled in Visual Studio 2008 (C# Simulation).

Conclusion

Search | Privacy | Disclaimer | Contact

Top