Changeset 1929


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)
Location:
trunk/CrypPlugins/WorkspaceManager
Files:
5 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}
  • trunk/CrypPlugins/WorkspaceManager/Model/ConnectorModel.cs

    r1905 r1929  
    191191        /// </summary>
    192192        [NonSerialized]
    193         public volatile Data Data = null;
     193        public object Data = null;
    194194
    195195        /// <summary>
     
    237237                }
    238238
    239                 Data Data = new Data();
    240                 Data.value = data;
    241                 this.Data = Data;
     239                this.Data = data;
    242240
    243241                List<ConnectionModel> outputConnections = this.OutputConnections;
    244242                foreach (ConnectionModel connectionModel in outputConnections)
    245243                {
    246                     Data = new Data();
    247                     Data.value = data;
    248                     connectionModel.To.Data = Data;
     244                    connectionModel.To.Data = data;
    249245                    connectionModel.To.HasData = true;
    250246                    connectionModel.Active = true;
     
    256252                foreach (ConnectionModel connectionModel in outputConnections)
    257253                {
    258                     MessageExecution msg = new MessageExecution();
    259                     msg.PluginModel = connectionModel.To.PluginModel;
    260                     connectionModel.To.PluginModel.PluginProtocol.BroadcastMessageReliably(msg);
     254                    if (connectionModel.To.PluginModel.PluginProtocol.QueueLength == 0)
     255                    {
     256                        connectionModel.To.PluginModel.PluginProtocol.BroadcastMessage(connectionModel.To.PluginModel.MessageExecution);
     257                    }
    261258                }
    262259            }
     
    278275                        (connectionModel.From.PluginModel.Startable && connectionModel.From.PluginModel.RepeatStart))
    279276                    {
    280                         MessageExecution message_exec = new MessageExecution();
    281                         message_exec.PluginModel = connectionModel.From.PluginModel;
    282                         connectionModel.From.PluginModel.PluginProtocol.BroadcastMessageReliably(message_exec);
     277                        if (connectionModel.From.PluginModel.PluginProtocol.QueueLength == 0)
     278                        {
     279                            connectionModel.From.PluginModel.PluginProtocol.BroadcastMessage(connectionModel.From.PluginModel.MessageExecution);
     280                        }
    283281                    }
    284282                }
     
    319317               
    320318    }
    321 
    322     public class Data
    323     {
    324         public volatile object value;
    325     }
    326 
    327319}
  • trunk/CrypPlugins/WorkspaceManager/Model/PluginModel.cs

    r1903 r1929  
    4747    public class PluginModel : VisualElementModel
    4848    {
     49        [NonSerialized]
     50        public MessageExecution MessageExecution = null;
     51
    4952        #region private members
    5053
  • trunk/CrypPlugins/WorkspaceManager/View/VisualComponents/DataPresentation.xaml.cs

    r1807 r1929  
    4343        {
    4444            if(Connector.Model.HasData)
    45                 Data.Text = Connector.Model.Data.value.ToString();
     45                Data.Text = Connector.Model.Data.ToString();
    4646
    4747            return;
  • trunk/CrypPlugins/WorkspaceManager/WorkspaceManager.cs

    r1884 r1929  
    6565            WorkspaceModel.WorkspaceManagerEditor = this;
    6666            WorkspaceSpaceEditorView = new WorkSpaceEditorView(WorkspaceModel);
    67             ExecutionEngine = new ExecutionEngine(this);
    6867            HasChanges = false;                               
    6968        }
     
    378377                    this.WorkspaceSpaceEditorView.State = EditorState.BUSY;                   
    379378                }
    380                 , null);               
     379                , null);
     380
     381                this.ExecutionEngine = new ExecutionEngine(this);
    381382
    382383                try
    383384                {
    384                     ExecutionEngine.GuiUpdateInterval = long.Parse(((WorkspaceManagerSettings)this.Settings).GuiUpdateInterval);
     385                    ExecutionEngine.GuiUpdateInterval = int.Parse(((WorkspaceManagerSettings)this.Settings).GuiUpdateInterval);
    385386                    if (ExecutionEngine.GuiUpdateInterval <= 0)
    386387                    {
     
    456457        /// </summary>
    457458        public void Pause()
    458         {
    459             ExecutionEngine.Pause();
     459        {   
     460            //to be implemented
    460461        }
    461462
     
    497498            }
    498499            executing = false;
     500            this.ExecutionEngine = null;
     501            GC.Collect();
    499502        }
    500503
     
    512515        public void Dispose()
    513516        {
    514             if (ExecutionEngine.IsRunning)
     517            if (ExecutionEngine != null && ExecutionEngine.IsRunning)
    515518            {
    516519                ExecutionEngine.Stop();
Note: See TracChangeset for help on using the changeset viewer.