Changeset 2115


Ignore:
Timestamp:
Nov 20, 2010, 2:16:16 PM (11 years ago)
Author:
Sven Rech
Message:

some p2p keysearcher changes (all related to better disconnect handling)

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypP2P/Internal/ConnectionManager.cs

    r2081 r2115  
    1717using System;
    1818using System.Threading;
     19using System.Windows.Threading;
    1920using Cryptool.P2P.Worker;
    2021using Cryptool.PluginBase;
     
    3334        private readonly P2PBase p2PBase;
    3435        private DateTime lastConnectionAttempt;
     36        private Dispatcher guiLogDispatcher = null;
    3537
    3638        public ConnectionManager(P2PBase p2PBase)
     
    4951                                                                   reconnecting = true;
    5052                                                                   this.Connect();
     53                                                                   guiLogDispatcher = Dispatcher.CurrentDispatcher;
    5154                                                               });
    5255            p2PBase.OnSystemJoined += new P2PBase.SystemJoined(delegate
     
    5457                                                                       if (p2PBase.IsConnected && reconnecting)
    5558                                                                       {
    56                                                                            P2PManager.GuiLogMessage("Successfully reconnected!",
    57                                                                                 NotificationLevel.Balloon);
     59                                                                           //TODO: This doesn't work. GuiLogMessage will never be shown:
     60                                                                           if (guiLogDispatcher != null)
     61                                                                                guiLogDispatcher.Invoke(DispatcherPriority.Send, (SendOrPostCallback)delegate
     62                                                                                {
     63                                                                                    P2PManager.GuiLogMessage("Successfully reconnected!",
     64                                                                                        NotificationLevel.Balloon);
     65                                                                                }, null);
    5866                                                                           reconnecting = false;
    5967                                                                       }
  • trunk/CrypPlugins/KeySearcher/KeySearcher.cs

    r2114 r2115  
    5555        private int maxThread;
    5656        private readonly Mutex maxThreadMutex = new Mutex();
     57        private ArrayList threadsStopEvents;
    5758
    5859        public bool IsKeySearcherRunning;
     
    359360        private void KeySearcherJob(object param)
    360361        {
     362            AutoResetEvent stopEvent = new AutoResetEvent(false);
     363            threadsStopEvents.Add(stopEvent);
     364
    361365            object[] parameters = (object[])param;
    362366            KeyPattern.KeyPattern[] patterns = (KeyPattern.KeyPattern[])parameters[0];
     
    426430            {
    427431                sender.Dispose();
     432                stopEvent.Set();
    428433            }
    429434        }
     
    438443                int deviceIndex = settings.OpenCLDevice;
    439444               
    440                 Mem costs = oclManager.Context.CreateBuffer(MemFlags.READ_ONLY, costArray.Length * 4);
     445                Mem costs = oclManager.Context.CreateBuffer(MemFlags.READ_WRITE, costArray.Length * 4);
    441446                IntPtr[] globalWorkSize = { (IntPtr)keyTranslator.GetOpenCLBatchSize() };
    442447
     
    707712            BigInteger[] keysleft = new BigInteger[patterns.Length];
    708713            Stack threadStack = Stack.Synchronized(new Stack());
     714            threadsStopEvents = ArrayList.Synchronized(new ArrayList());
    709715            StartThreads(sender, bytesToUse, patterns, doneKeysA, keycounters, keysleft, threadStack);
    710716
     
    780786            while (threadStack.Count != 0)
    781787                ((ThreadStackElement)threadStack.Pop()).ev.Set();
     788
     789            //wait until all threads finished:
     790            foreach (AutoResetEvent stopEvent in threadsStopEvents)
     791            {
     792                stopEvent.WaitOne();
     793            }
    782794
    783795            if (!stop && !redirectResultsToStatisticsGenerator)
  • trunk/CrypPlugins/KeySearcher/P2P/DistributedBruteForceManager.cs

    r2094 r2115  
    33using System.Diagnostics;
    44using System.Numerics;
     5using System.Threading;
    56using System.Windows.Threading;
    67using Cryptool.P2P;
     8using Cryptool.P2P.Internal;
    79using Cryptool.PluginBase;
    810using KeySearcher.Helper;
     
    1517using KeySearcherPresentation.Controls;
    1618using System.Timers;
     19using Timer = System.Timers.Timer;
    1720
    1821namespace KeySearcher.P2P
     
    3134
    3235        private KeyPoolTree keyPoolTree;
     36        private AutoResetEvent systemJoinEvent = new AutoResetEvent(false);
    3337
    3438        public DistributedBruteForceManager(KeySearcher keySearcher, KeyPattern.KeyPattern keyPattern, KeySearcherSettings settings,
     
    125129                }
    126130
     131                bool reservationRemoved = false;
    127132                var reservationTimer = new Timer {Interval = 5*60*1000};    //Every 5 minutes
    128133                reservationTimer.Elapsed += new ElapsedEventHandler(delegate
     
    132137                                                                            keySearcher.GuiLogMessage(message, NotificationLevel.Info);
    133138                                                                            status.CurrentOperation = message;
    134                                                                             currentLeaf.ReserveLeaf();
     139                                                                            try
     140                                                                            {
     141                                                                                if (!currentLeaf.ReserveLeaf())
     142                                                                                {
     143                                                                                    keySearcher.GuiLogMessage("Rereserving pattern failed! Skipping to next pattern!",
     144                                                                                        NotificationLevel.Warning);
     145                                                                                    reservationRemoved = true;
     146                                                                                    keySearcher.stop = true;
     147                                                                                }
     148                                                                            }
     149                                                                            catch (Cryptool.P2P.Internal.NotConnectedException)
     150                                                                            {
     151                                                                                keySearcher.GuiLogMessage("Rereserving pattern failed, because there is no connection!",
     152                                                                                        NotificationLevel.Warning);
     153                                                                                //TODO: Register OnSystemJoined event to rereserve pattern immediately after reconnect
     154                                                                            }
    135155                                                                            status.CurrentOperation = oldMessage;
    136156                                                                        });
     
    152172                    {
    153173                        result = keySearcher.BruteForceWithLocalSystem(patternPool[currentLeaf.PatternId()], true);
     174                        if (reservationRemoved)
     175                        {
     176                            keySearcher.stop = false;
     177                            throw new ReservationRemovedException("");
     178                        }
    154179                    }
    155180                    finally
     
    163188                    if (!keySearcher.stop)
    164189                    {
     190                        if (!P2PManager.IsConnected)
     191                        {
     192                            status.CurrentOperation = "Connection lost! Waiting for reconnection to store the results!";
     193                            keySearcher.GuiLogMessage(status.CurrentOperation, NotificationLevel.Info);
     194                           
     195                            P2PManager.P2PBase.OnSystemJoined += new P2PBase.SystemJoined(P2PBase_OnSystemJoined);
     196                            systemJoinEvent.WaitOne();
     197                        }
     198
    165199                        status.CurrentOperation = "Processing results of calculation";
    166200                        KeyPoolTree.ProcessCurrentPatternCalculationResult(currentLeaf, result);
     
    225259        }
    226260
     261        void P2PBase_OnSystemJoined()
     262        {
     263            P2PManager.P2PBase.OnSystemJoined -= P2PBase_OnSystemJoined;
     264            systemJoinEvent.Set();
     265        }
     266
    227267        private void UpdateStatusContainerInQuickWatch()
    228268        {
Note: See TracChangeset for help on using the changeset viewer.