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 static bool ConfigProgress = Config.Get("block/progress", true);
 125                 private Schematic s;
 126                 private ArrayList Threads = new ArrayList();
 127                 private bool stop = false;
 128                 private bool running = false;
 129                 private FinishCallback finish;
 130                 private Progress progress;
 131                 private DateTime start, end;
 132
 133                 public delegate void FinishCallback();
 134                 public delegate void Progress();
 135
 136                 public Engine2(Schematic s, FinishCallback finish, Progress progress)
 137                 {
 138                         this.s = s;
 139                         this.finish = finish;
 140                         this.progress = progress;
 141                 }
 142
 143                 private bool Tick()
 144                 {
 145                         if(stop)
 146                         {
 147                                 running = false;
 148                                 end = DateTime.Now;
 149                                 finish();
 150                                 return false;
 151                         }
 152
 153                         // sprawdzenie, czy jakiś wątek nie skończył pracy
 154                         for(int i=Threads.Count-1; i>=0; i--)
 155                                 if(((EngineThread)Threads[i]).Finished)
 156                                 {
 157                                         // w przypadku błędu praca jest skończona
 158                                         if(stop)
 159                                         {
 160                                                 running = false;
 161                                                 end = DateTime.Now;
 162                                                 finish();
 163                                                 return false;
 164                                         }
 165
 166                                         Threads.RemoveAt(i);
 167                                 }
 168
 169                         // jeżeli są jakieś wolne sloty na wątki, to trzeba spróbować je wypełnić
 170                         if(Threads.Count < ConfigThreads)
 171                         {
 172                                 ArrayList Blocks = s.Blocks;
 173
 174                                 for(int i=0; i<Blocks.Count; i++)
 175                                 {
 176                                         // sprawdzenie czy są wolne wątki
 177                                         if(Threads.Count >= ConfigThreads)
 178                                                 break;
 179
 180                                         Block b = (Block)Blocks[i];
 181
 182                                         if(b.CheckState() == Block.State.Ready && b.Working != true)
 183                                                 Threads.Add(new EngineThread(this, b));
 184                                 }
 185                         }
 186
 187                         // sprawdzenie czy zostały jakieś wątki
 188                         if(Threads.Count == 0)
 189                         {
 190                                 running = false;
 191                                 end = DateTime.Now;
 192                                 finish();
 193                                 return false;
 194                         }
 195
 196                         progress();
 197
 198                         if(ConfigProgress)
 199                                 MainWindow.RedrawSchematic();
 200
 201                         return true;
 202                 }
 203
 204                 public void Start()
 205                 {
 206                         // nie powinno nigdy się zdarzyć
 207                         if(running)
 208                                 throw new Exception(Catalog.GetString("Engine is already running."));
 209
 210                         start = DateTime.Now;
 211
 212                         ArrayList Blocks = s.Blocks;
 213
 214                         stop = false;
 215                         running = true;
 216
 217                         // przejrzenie wszystkich bloków i dodanie gotowych do pracy do listy wątków
 218                         for(int i=0; i<Blocks.Count; i++)
 219                         {
 220                                 // sprawdzenie czy są wolne wątki
 221                                 if(Threads.Count >= ConfigThreads)
 222                                         break;
 223
 224                                 Block b = (Block)Blocks[i];
 225
 226                                 if(b.CheckState() == Block.State.Ready)
 227                                         Threads.Add(new EngineThread(this, b));
 228                         }
 229
 230                         // sprawdzanie stanu wątków co 50 ms
 231                         GLib.Timeout.Add(50, new GLib.TimeoutHandler(Tick));
 232                 }
 233
 234                 // zatrzymuje wszystkie wątki
 235                 public void Stop()
 236                 {
 237                         stop = true;
 238
 239                         foreach(EngineThread t in Threads)
 240                                 t.Stop();
 241
 242                         Threads.RemoveRange(0, Threads.Count);
 243                 }
 244
 245                 public static void CheckGConf()
 246                 {
 247                         ConfigThreads = Config.Get("engine/threads", 1);
 248                         ConfigProgress = Config.Get("block/progress", true);
 249                 }
 250
 251                 public bool Running
 252                 {
 253                         get { return running; }
 254                 }
 255
 256                 public string ElapsedTime
 257                 {
 258                         get
 259                         {
 260                                 TimeSpan ts = end - start;
 261
 262                                 if(ts.Days == 0)
 263                                         if(ts.Hours == 0)
 264                                                 if(ts.Minutes == 0)
 265                                                         return String.Format("{0:00}.{1}", ts.Seconds, ts.Milliseconds);
 266                                                 else
 267                                                         return String.Format("{0:00}:{1:00}.{2}", ts.Minutes, ts.Seconds, ts.Milliseconds);
 268                                         else
 269                                                 return String.Format("{0:00}:{1:00}:{2:00}.{3}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds);
 270                                 else
 271                                         return String.Format("{0}.{1:00}:{2:00}:{3:00}.{4}", ts.Days, ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds);
 272                         }
 273                 }
 274         }
 275 }