Ignore:
Timestamp:
Sep 20, 2010, 10:10:35 PM (11 years ago)
Author:
kopal
Message:
  • some optimization
  • Benchmark now loggs Plugins/sec and Memory Usage to logg files (only for testing purposes; will be removed in later releases)
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/WorkspaceManager/Execution/ExecutionEngine.cs

    r1891 r1929  
    2828using System.Windows.Threading;
    2929using System.Runtime.Remoting.Contexts;
     30using System.IO;
     31using System.Diagnostics;
    3032
    3133namespace WorkspaceManager.Execution
     
    4446        private WorkspaceModel workspaceModel;
    4547        private volatile bool isRunning = false;
    46 
    47         public long ExecutedPluginsCounter { get; set; }
    48         public bool BenchmarkPlugins { get; set; }
    49         public long GuiUpdateInterval { get; set; }
    50         public int SleepTime { get; set; }
    51         public int ThreadPriority { get; set; }
     48        private BenchmarkProtocol BenchmarkProtocol;
     49
     50        public volatile int ExecutedPluginsCounter = 0;
     51        public bool BenchmarkPlugins = false;
     52        public int GuiUpdateInterval = 0;
     53        public int SleepTime = 0;
     54        public int ThreadPriority = 0;
    5255
    5356        /// <summary>
     
    98101                if (this.BenchmarkPlugins)
    99102                {
    100                     BenchmarkProtocol benchmarkProtocol = new BenchmarkProtocol(scheduler, this.workspaceModel, this);
    101                     scheduler.AddProtocol(benchmarkProtocol);
    102                     benchmarkProtocol.Start();
     103                    BenchmarkProtocol = new BenchmarkProtocol(scheduler, this.workspaceModel, this);
     104                    scheduler.AddProtocol(BenchmarkProtocol);
     105                    BenchmarkProtocol.Start();
    103106                }
    104107
     
    108111                //we also initalize each plugin
    109112                //It is possible that a plugin is also a PluginProtocol
    110                 //if that is true we do not create a new one but use the plugin instead the created one
    111                 int counter=0;
     113                //if that is true we do not create a new one but use the plugin instead the created one               
    112114                foreach (PluginModel pluginModel in workspaceModel.AllPluginModels)
    113115                {
    114116                    PluginProtocol pluginProtocol = new PluginProtocol(scheduler, pluginModel, this);
    115                    
     117                    MessageExecution message = new MessageExecution();
     118                    message.PluginModel = pluginModel;
     119                    pluginModel.MessageExecution = message;
     120
    116121                    pluginModel.Plugin.PreExecution();                   
    117122                    pluginModel.PluginProtocol = pluginProtocol;
     
    122127                        pluginProtocol.Start();
    123128                    }
    124 
    125                     counter = (counter + 1) % (amountThreads);
    126 
     129                 
    127130                    if (pluginModel.Startable)
    128131                    {
    129                         MessageExecution msg = new MessageExecution();
    130                         msg.PluginModel = pluginModel;
    131                         pluginProtocol.BroadcastMessageReliably(msg);
     132                        pluginProtocol.BroadcastMessage(pluginModel.MessageExecution);
    132133                    }
    133134                }
     
    144145        public void Stop()
    145146        {
    146             //First stop alle plugins
    147             foreach (PluginModel pluginModel in workspaceModel.AllPluginModels)
    148             {
    149                 pluginModel.Plugin.Stop();
    150                 pluginModel.Plugin.PostExecution();
    151             }           
    152 
    153             IsRunning = false;
    154             //Secondly stop all Gears4Net Schedulers
    155             scheduler.Shutdown();
    156            
     147            try
     148            {
     149                //First stop alle plugins
     150                foreach (PluginModel pluginModel in workspaceModel.AllPluginModels)
     151                {
     152                    pluginModel.Plugin.Stop();
     153                    pluginModel.Plugin.PostExecution();
     154                }
     155
     156                IsRunning = false;
     157                //Secondly stop all Gears4Net Schedulers
     158                scheduler.Shutdown();
     159
     160                foreach (PluginModel pluginModel in workspaceModel.AllPluginModels)
     161                {
     162                    pluginModel.PluginProtocol = null;
     163                }
     164
     165
     166
     167                this.WorkspaceManagerEditor = null;
     168                this.workspaceModel = null;
     169            }
     170            finally
     171            {
     172                BenchmarkProtocol.CloseWriters();
     173            }
    157174        }
    158175
     
    171188        /// <param name="level"></param>
    172189        public void GuiLogMessage(string message, NotificationLevel level)
    173         {           
    174             WorkspaceManagerEditor.GuiLogMessage(message, level);
     190        {
     191            if (WorkspaceManagerEditor != null)
     192            {
     193                WorkspaceManagerEditor.GuiLogMessage(message, level);
     194            }
    175195        }
    176196    }
     
    190210    {
    191211        private WorkspaceModel workspaceModel;
    192         private ExecutionEngine executionEngine;     
     212        private ExecutionEngine executionEngine;
    193213
    194214        /// <summary>
     
    203223            this.executionEngine = executionEngine;           
    204224        }
    205 
     225       
    206226        /// <summary>
    207227        /// The main function of the protocol
     
    210230        /// <returns></returns>
    211231        public override System.Collections.Generic.IEnumerator<ReceiverBase> Execute(AbstractStateMachine stateMachine)
    212         {
    213             while (this.executionEngine.IsRunning)
    214             {
    215                 yield return Timeout(this.executionEngine.GuiUpdateInterval, HandleUpdateGui);
    216             }
     232        {           
     233            yield return new IntervalReceiver(this.executionEngine.GuiUpdateInterval,this.executionEngine.GuiUpdateInterval, HandleUpdateGui);
    217234        }
    218235
     
    253270            }
    254271            , null);
     272
    255273        }
    256274    }
     
    263281        private WorkspaceModel workspaceModel;
    264282        private ExecutionEngine executionEngine;
     283        private StreamWriter PerformanceWriter;
     284        private StreamWriter MemoryPerformanceWriter;
    265285
    266286        /// <summary>
     
    274294            this.workspaceModel = workspaceModel;
    275295            this.executionEngine = executionEngine;
     296            string sFilename = "benchmark_" + DateTime.Now.Hour + DateTime.Now.Minute + DateTime.Now.Second + ".txt";
     297            PerformanceWriter = new StreamWriter("plugins_" + sFilename);
     298            MemoryPerformanceWriter = new StreamWriter("memory_" + sFilename);
    276299        }
    277300
     
    283306        public override System.Collections.Generic.IEnumerator<ReceiverBase> Execute(AbstractStateMachine stateMachine)
    284307        {
    285             while (this.executionEngine.IsRunning)
    286             {
    287                 yield return Timeout(1000, HandleBenchmark);
    288             }
     308            yield return new IntervalReceiver(1000,1000, HandleBenchmark);           
    289309        }
    290310
     
    296316        private void HandleBenchmark()
    297317        {
    298             this.workspaceModel.WorkspaceManagerEditor.GuiLogMessage("Executing at about " + this.executionEngine.ExecutedPluginsCounter + " Plugins/s", NotificationLevel.Debug);
     318            StringBuilder sb = new StringBuilder();
     319            sb.Append("Executing at about ");
     320            sb.Append(this.executionEngine.ExecutedPluginsCounter);
     321            sb.Append(" Plugins/s");
     322
     323            this.workspaceModel.WorkspaceManagerEditor.GuiLogMessage(sb.ToString(), NotificationLevel.Debug);
     324            PerformanceWriter.WriteLine(this.executionEngine.ExecutedPluginsCounter);
     325            PerformanceWriter.Flush();
     326            MemoryPerformanceWriter.WriteLine(Process.GetCurrentProcess().WorkingSet64);
     327            MemoryPerformanceWriter.Flush();
    299328            this.executionEngine.ExecutedPluginsCounter = 0;
    300329        }
    301330
     331        public void CloseWriters()
     332        {
     333            PerformanceWriter.Close();
     334            MemoryPerformanceWriter.Close();
     335        }
    302336    }
    303337
     
    320354            this.PluginModel = pluginModel;
    321355            this.executionEngine = executionEngine;
    322         }
     356        }       
    323357
    324358        /// <summary>
     
    342376        /// <returns></returns>
    343377        public override System.Collections.Generic.IEnumerator<ReceiverBase> Execute(AbstractStateMachine stateMachine)
    344         {
    345             while (this.executionEngine.IsRunning)
    346             {
    347                 yield return Receive<MessageExecution>(this.Filter, HandleExecute);
    348             }
     378        {           
     379            yield return new PersistentReceiver(Receive<MessageExecution>(this.Filter, HandleExecute));               
    349380        }
    350381
     
    414445                try
    415446                {
    416                     if (connectorModel.HasData && connectorModel.Data.value != null)
     447                    if (connectorModel.HasData && connectorModel.Data != null)
    417448                    {
    418449                        if (connectorModel.IsDynamic)
    419450                        {
    420451                            MethodInfo propertyInfo = PluginModel.Plugin.GetType().GetMethod(connectorModel.DynamicSetterName);
    421                             propertyInfo.Invoke(PluginModel.Plugin, new object[] { connectorModel.PropertyName, connectorModel.Data.value });
     452                            propertyInfo.Invoke(PluginModel.Plugin, new object[] { connectorModel.PropertyName, connectorModel.Data });
    422453                        }
    423454                        else
    424455                        {
    425456                            PropertyInfo propertyInfo = PluginModel.Plugin.GetType().GetProperty(connectorModel.PropertyName);
    426                             propertyInfo.SetValue(PluginModel.Plugin, connectorModel.Data.value, null);
     457                            propertyInfo.SetValue(PluginModel.Plugin, connectorModel.Data, null);
    427458                        }
    428459                    }
     
    459490            if (this.executionEngine.BenchmarkPlugins)
    460491            {
    461                 this.executionEngine.ExecutedPluginsCounter++;
     492                this.executionEngine.ExecutedPluginsCounter++;               
    462493            }
    463494
     
    470501                Thread.Sleep(this.executionEngine.SleepTime);
    471502            }
    472 
    473503        }       
    474504
     
    539569            this.executionEngine.GuiLogMessage(Thread.CurrentThread.Name + " up and running", NotificationLevel.Debug);
    540570            Queue<ProtocolBase> waitingProtocols = this.waitingProtocols;
     571            int i = 0;
    541572
    542573            // Loop forever
    543574            while (true)
    544             {
     575            {               
    545576                this.wakeup.WaitOne();
    546577
     
    551582                    if (this.shutdown)
    552583                    {
     584                        this.waitingProtocols.Clear();
     585                        this.protocols.Clear();
    553586                        this.executionEngine.GuiLogMessage(Thread.CurrentThread.Name + " terminated", NotificationLevel.Debug);
    554587                        return;
     
    640673            this.shutdown = true;
    641674            this.wakeup.Set();
    642         }
     675        }       
    643676    }
    644677}
Note: See TracChangeset for help on using the changeset viewer.