Engine.cs

   1 using System;
   2 using System.Collections;
   3 using System.Threading;
   4 using Gtk;
   5 using Mono.Unix;
   6
   7 namespace Eithne
   8 {
   9         class EngineThread
  10         {
  11                 private IPlugin Plugin;
  12                 private Block b;
  13                 private Thread t;
  14                 private Exception Error;
  15                 private Engine2 engine;
  16                 private bool finished = false;
  17
  18                 private void ThreadedWork()
  19                 {
  20                         Error = null;
  21
  22                         try
  23                         {
  24                                 Plugin.Work();
  25                         }
  26                         catch(Exception e)
  27                         {
  28                                 Error = e;
  29                         }
  30                 }
  31
  32                 public EngineThread(Engine2 engine, Block b)
  33                 {
  34                         this.b = b;
  35                         this.engine = engine;
  36
  37                         b.Working = true;
  38                         MainWindow.RedrawSchematic();
  39
  40                         try
  41                         {
  42                                 if(b.Plugin.NumIn != 0)
  43                                 {
  44                                         CommSocket cs = new CommSocket(b.Plugin.NumIn);
  45
  46                                         for(int i=0; i<b.Plugin.NumIn; i++)
  47                                         {
  48                                                 Socket other = b.SocketIn[i].Other;
  49
  50                                                 if(other.Parent.Plugin.Out == null)
  51                                                 {
  52                                                         b.Working = false;
  53                                                         b = other.Parent;
  54                                                         throw new PluginException(Catalog.GetString("Plugin has no data on output sockets."));
  55                                                 }
  56
  57                                                 cs[i] = other.Parent.Plugin.Out[other.Num];
  58                                         }
  59
  60                                         b.Plugin.In = cs;
  61                                 }
  62
  63                                 Plugin = b.Plugin;
  64                                 t = new Thread(ThreadedWork);
  65                                 t.Start();
  66                         }
  67                         catch(Exception e)
  68                         {
  69                                 engine.Stop();
  70
  71                                 b.ShowError = true;
  72                                 MainWindow.RedrawSchematic();
  73                                 new PluginError(e, b, false);
  74                         }
  75                 }
  76
  77                 public void Stop()
  78                 {
  79                         if(!finished)
  80                                 t.Abort();
  81
  82                         b.Working = false;
  83                         MainWindow.RedrawSchematic();
  84                 }
  85
  86                 public bool Finished
  87                 {
  88                         get
  89                         {
  90                                 if(finished)
  91                                         return true;
  92
  93                                 try
  94                                 {
  95                                         if(t.Join(0))
  96                                         {
  97                                                 finished = true;
  98                                                 b.Working = false;
  99
 100                                                 if(Error != null)
 101                                                         throw Error;
 102
 103                                                 MainWindow.RedrawSchematic();
 104                                         }
 105                                 }
 106                                 catch(Exception e)
 107                                 {
 108                                         engine.Stop();
 109
 110                                         b.ShowError = true;
 111                                         MainWindow.RedrawSchematic();
 112                                         new PluginError(e, b, false);
 113                                         finished = true;
 114                                 }
 115
 116                                 return finished;
 117                         }
 118                 }
 119         }
 120
 121         class Engine2
 122         {
 123                 private static int ConfigThreads = Config.Get("engine/threads", 1);
 124                 private Schematic s;
 125                 private ArrayList Threads = new ArrayList();
 126                 private bool stop = false;
 127                 private bool running = false;
 128                 private FinishCallback finish;
 129                 private DateTime start, end;
 130
 131                 public delegate void FinishCallback();
 132
 133                 public Engine2(Schematic s, FinishCallback finish)
 134                 {
 135                         this.s = s;
 136                         this.finish = finish;
 137                 }
 138
 139                 private bool Tick()
 140                 {
 141                         if(stop)
 142                         {
 143                                 running = false;
 144                                 end = DateTime.Now;
 145                                 finish();
 146                                 return false;
 147                         }
 148
 149                         // sprawdzenie, czy jakiś wątek nie skończył pracy
 150                         for(int i=Threads.Count-1; i>=0; i--)
 151                                 if(((EngineThread)Threads[i]).Finished)
 152                                 {
 153                                         // w przypadku błędu praca jest skończona
 154                                         if(stop)
 155                                         {
 156                                                 running = false;
 157                                                 end = DateTime.Now;
 158                                                 finish();
 159                                                 return false;
 160                                         }
 161
 162                                         Threads.RemoveAt(i);
 163                                 }
 164
 165                         // jeżeli są jakieś wolne sloty na wątki, to trzeba spróbować je wypełnić
 166                         if(Threads.Count < ConfigThreads)
 167                         {
 168                                 ArrayList Blocks = s.Blocks;
 169
 170                                 for(int i=0; i<Blocks.Count; i++)
 171                                 {
 172                                         // sprawdzenie czy są wolne wątki
 173                                         if(Threads.Count >= ConfigThreads)
 174                                                 break;
 175
 176                                         Block b = (Block)Blocks[i];
 177
 178                                         if(b.CheckState() == Block.State.Ready && b.Working != true)
 179                                                 Threads.Add(new EngineThread(this, b));
 180                                 }
 181                         }
 182
 183                         // sprawdzenie czy zostały jakieś wątki
 184                         if(Threads.Count == 0)
 185                         {
 186                                 running = false;
 187                                 end = DateTime.Now;
 188                                 finish();
 189                                 return false;
 190                         }
 191
 192                         return true;
 193                 }
 194
 195                 public void Start()
 196                 {
 197                         // nie powinno nigdy się zdarzyć
 198                         if(running)
 199                                 throw new Exception(Catalog.GetString("Engine is already running."));
 200
 201                         start = DateTime.Now;
 202
 203                         ArrayList Blocks = s.Blocks;
 204
 205                         stop = false;
 206                         running = true;
 207
 208                         // przejrzenie wszystkich bloków i dodanie gotowych do pracy do listy wątków
 209                         for(int i=0; i<Blocks.Count; i++)
 210                         {
 211                                 // sprawdzenie czy są wolne wątki
 212                                 if(Threads.Count >= ConfigThreads)
 213                                         break;
 214
 215                                 Block b = (Block)Blocks[i];
 216
 217                                 if(b.CheckState() == Block.State.Ready)
 218                                         Threads.Add(new EngineThread(this, b));
 219                         }
 220
 221                         // sprawdzanie stanu wątków co 50 ms
 222                         GLib.Timeout.Add(50, new GLib.TimeoutHandler(Tick));
 223                 }
 224
 225                 // zatrzymuje wszystkie wątki
 226                 public void Stop()
 227                 {
 228                         stop = true;
 229
 230                         foreach(EngineThread t in Threads)
 231                                 t.Stop();
 232
 233                         Threads.RemoveRange(0, Threads.Count);
 234                 }
 235
 236                 public static void CheckGConf()
 237                 {
 238                         ConfigThreads = Config.Get("engine/threads", 1);
 239                 }
 240
 241                 public bool Running
 242                 {
 243                         get { return running; }
 244                 }
 245
 246                 public string ElapsedTime
 247                 {
 248                         get
 249                         {
 250                                 TimeSpan ts = end - start;
 251
 252                                 if(ts.Days == 0)
 253                                         if(ts.Hours == 0)
 254                                                 if(ts.Minutes == 0)
 255                                                         return String.Format("{0:00}.{1}", ts.Seconds, ts.Milliseconds);
 256                                                 else
 257                                                         return String.Format("{0:00}:{1:00}.{2}", ts.Minutes, ts.Seconds, ts.Milliseconds);
 258                                         else
 259                                                 return String.Format("{0:00}:{1:00}:{2:00}.{3}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds);
 260                                 else
 261                                         return String.Format("{0}.{1:00}:{2:00}:{3:00}.{4}", ts.Days, ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds);
 262                         }
 263                 }
 264         }
 265 }