Changeset 1763


Ignore:
Timestamp:
Aug 5, 2010, 9:18:43 PM (11 years ago)
Author:
Sven Rech
Message:

QuadraticSieve:

  • is now able to use p2p later, when connection was established
  • uses status key

Both untested!

Location:
trunk/CrypPlugins/QuadraticSieve
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/QuadraticSieve/PeerToPeer.cs

    r1692 r1763  
    3131using System.Security.Principal;
    3232using System.Security.Cryptography;
     33using Cryptool.P2P.Internal;
    3334
    3435namespace Cryptool.Plugins.QuadraticSieve
     
    7778        private Queue<KeyValuePair<int, DateTime>> lostIndices;
    7879        private int loadIndex;
     80        private AutoResetEvent waitForConnection = new AutoResetEvent(false);
    7981
    8082        public delegate void P2PWarningHandler(String warning);
     
    8688            this.newRelationPackageEvent = newRelationPackageEvent;
    8789            SetOurID();
     90        }
     91
     92        public int getActivePeers()
     93        {
     94            return activePeers.Count;
    8895        }
    8996
     
    212219            try
    213220            {
     221                WaitTillConnected();
     222                head = 0;
    214223                SynchronizeHead();
    215224                int startHead = head;
     
    217226                while (!stopLoadStoreThread)
    218227                {
    219                     //Store our performance and our alive counter in the DHT, either if the performance changed or when the last write was more than 1 minute ago:
    220                     if (ourPerformance != lastPerformance || performanceLastPut.CompareTo(DateTime.Now.Subtract(new TimeSpan(0, 1, 0))) < 0)
     228                    try
    221229                    {
    222                         P2PManager.Retrieve(PerformanceIdentifier(ourID));      //just to outsmart the versioning system
    223                         P2PManager.Store(PerformanceIdentifier(ourID), concat(BitConverter.GetBytes(ourPerformance), BitConverter.GetBytes(aliveCounter++)));
    224                         lastPerformance = ourPerformance;
    225                         performanceLastPut = DateTime.Now;
    226                     }
    227 
    228                     //updates all peer performances which have last been checked more than 1 minutes and 20 seconds ago and check if they are still alive:
    229                     while (peerPerformances.Count != 0 && peerPerformances.Peek().lastChecked.CompareTo(DateTime.Now.Subtract(new TimeSpan(0, 1, 20))) < 0)
    230                     {
    231                         var e = peerPerformances.Dequeue();
    232 
    233                         byte[] performancebytes = P2PManager.Retrieve(PerformanceIdentifier(e.peerID)).Data;
    234                         if (performancebytes != null)
     230                        //Store our performance and our alive counter in the DHT, either if the performance changed or when the last write was more than 1 minute ago:
     231                        if (ourPerformance != lastPerformance || performanceLastPut.CompareTo(DateTime.Now.Subtract(new TimeSpan(0, 1, 0))) < 0)
    235232                        {
    236                             double performance = BitConverter.ToDouble(performancebytes, 0);
    237                             int peerAliveCounter = BitConverter.ToInt32(performancebytes, 8);
    238                             if (peerAliveCounter <= e.lastAlive)
     233                            P2PManager.Retrieve(PerformanceIdentifier(ourID));      //just to outsmart the versioning system
     234                            P2PManager.Store(PerformanceIdentifier(ourID), concat(BitConverter.GetBytes(ourPerformance), BitConverter.GetBytes(aliveCounter++)));
     235                            lastPerformance = ourPerformance;
     236                            performanceLastPut = DateTime.Now;
     237                        }
     238
     239                        //updates all peer performances which have last been checked more than 1 minutes and 20 seconds ago and check if they are still alive:
     240                        while (peerPerformances.Count != 0 && peerPerformances.Peek().lastChecked.CompareTo(DateTime.Now.Subtract(new TimeSpan(0, 1, 20))) < 0)
     241                        {
     242                            var e = peerPerformances.Dequeue();
     243
     244                            byte[] performancebytes = P2PManager.Retrieve(PerformanceIdentifier(e.peerID)).Data;
     245                            if (performancebytes != null)
     246                            {
     247                                double performance = BitConverter.ToDouble(performancebytes, 0);
     248                                int peerAliveCounter = BitConverter.ToInt32(performancebytes, 8);
     249                                if (peerAliveCounter <= e.lastAlive)
     250                                {
     251                                    activePeers.Remove(e.peerID);
     252                                    UpdateActivePeerInformation();
     253                                }
     254                                else
     255                                    peerPerformances.Enqueue(new PeerPerformanceInformations(DateTime.Now, e.peerID, performance, peerAliveCounter));
     256                            }
     257                            else
    239258                            {
    240259                                activePeers.Remove(e.peerID);
    241260                                UpdateActivePeerInformation();
     261                            }                       
     262                        }
     263                                       
     264                        SynchronizeHead();
     265                        UpdateStoreLoadQueueInformation();
     266
     267                        bool busy = false;
     268
     269                        if (storequeue.Count != 0)  //store our packages
     270                        {
     271                            byte[] relationPackage = (byte[])storequeue.Dequeue();
     272                            bool success = P2PManager.Store(RelationPackageIdentifier(head), relationPackage).IsSuccessful();
     273                            while (!success)
     274                            {
     275                                SynchronizeHead();
     276                                success = P2PManager.Store(RelationPackageIdentifier(head), relationPackage).IsSuccessful();
     277                            }
     278                            SetProgressRelationPackage(head, ourID, null);
     279                            ourIndices.Add(head);
     280                       
     281                            head++;
     282
     283                            //show informations about the uploaded relation package:
     284                            uploaded += (uint)relationPackage.Length;
     285                            ShowTransfered(downloaded, uploaded);
     286                            UpdateStoreLoadQueueInformation();
     287                            busy = true;
     288                        }
     289
     290                        //load the other relation packages:
     291
     292                        //skip all indices which are uploaded by us:
     293                        while (ourIndices.Contains(loadIndex))
     294                            loadIndex++;
     295
     296                        if (loadIndex < head)
     297                        {
     298                            bool checkAlive = loadIndex >= startHead;       //we don't check the peer alive informations of the packages that existed before we joined
     299                            TryReadAndEnqueueRelationPackage(loadIndex, checkAlive, lostIndices);
     300                            loadIndex++;
     301                            UpdateStoreLoadQueueInformation();
     302                            busy = true;
     303                        }
     304                   
     305                        //check lost indices which are last checked longer than 2 minutes ago (but only if we have nothing else to do):
     306                        if (!busy)
     307                        {
     308                            //TODO: Maybe we should throw away those indices, which have been checked more than several times.
     309                            if (lostIndices.Count != 0 && lostIndices.Peek().Value.CompareTo(DateTime.Now.Subtract(new TimeSpan(0, 2, 0))) < 0)
     310                            {
     311                                var e = lostIndices.Dequeue();
     312                                TryReadAndEnqueueRelationPackage(loadIndex, true, lostIndices);
     313                                UpdateStoreLoadQueueInformation();                           
    242314                            }
    243315                            else
    244                                 peerPerformances.Enqueue(new PeerPerformanceInformations(DateTime.Now, e.peerID, performance, peerAliveCounter));
     316                                Thread.Sleep(5000);    //Wait 5 seconds
    245317                        }
    246                         else
    247                         {
    248                             activePeers.Remove(e.peerID);
    249                             UpdateActivePeerInformation();
    250                         }                       
     318
    251319                    }
    252                                        
    253                     SynchronizeHead();
    254                     UpdateStoreLoadQueueInformation();
    255 
    256                     bool busy = false;
    257 
    258                     if (storequeue.Count != 0)  //store our packages
     320                    catch (NotConnectedException)
    259321                    {
    260                         byte[] relationPackage = (byte[])storequeue.Dequeue();
    261                         bool success = P2PManager.Store(RelationPackageIdentifier(head), relationPackage).IsSuccessful();
    262                         while (!success)
    263                         {
    264                             SynchronizeHead();
    265                             success = P2PManager.Store(RelationPackageIdentifier(head), relationPackage).IsSuccessful();
    266                         }
    267                         SetProgressRelationPackage(head, ourID, null);
    268                         ourIndices.Add(head);
    269                        
    270                         head++;
    271 
    272                         //show informations about the uploaded relation package:
    273                         uploaded += (uint)relationPackage.Length;
    274                         ShowTransfered(downloaded, uploaded);
    275                         UpdateStoreLoadQueueInformation();
    276                         busy = true;
     322                        WaitTillConnected();
    277323                    }
    278 
    279                     //load the other relation packages:
    280 
    281                     //skip all indices which are uploaded by us:
    282                     while (ourIndices.Contains(loadIndex))
    283                         loadIndex++;
    284 
    285                     if (loadIndex < head)
    286                     {
    287                         bool checkAlive = loadIndex >= startHead;       //we don't check the peer alive informations of the packages that existed before we joined
    288                         TryReadAndEnqueueRelationPackage(loadIndex, checkAlive, lostIndices);
    289                         loadIndex++;
    290                         UpdateStoreLoadQueueInformation();
    291                         busy = true;
    292                     }
    293                    
    294                     //check lost indices which are last checked longer than 2 minutes ago (but only if we have nothing else to do):
    295                     if (!busy)
    296                     {
    297                         //TODO: Maybe we should throw away those indices, which have been checked more than several times.
    298                         if (lostIndices.Count != 0 && lostIndices.Peek().Value.CompareTo(DateTime.Now.Subtract(new TimeSpan(0, 2, 0))) < 0)
    299                         {
    300                             var e = lostIndices.Dequeue();
    301                             TryReadAndEnqueueRelationPackage(loadIndex, true, lostIndices);
    302                             UpdateStoreLoadQueueInformation();                           
    303                         }
    304                         else
    305                             Thread.Sleep(5000);    //Wait 5 seconds
    306                     }
    307 
    308324                }
    309325            }
     
    312328                return;
    313329            }
     330            catch (NotConnectedException)
     331            {
     332                WaitTillConnected();
     333                LoadStoreThreadProc();
     334            }
     335        }
     336
     337        private void WaitTillConnected()
     338        {
     339            if (!P2PManager.IsConnected)
     340            {
     341                P2PManager.ConnectionManager.OnP2PConnectionStateChangeOccurred += HandleConnectionStateChange;
     342                waitForConnection.WaitOne();
     343                P2PManager.ConnectionManager.OnP2PConnectionStateChangeOccurred -= HandleConnectionStateChange;
     344            }
     345        }
     346
     347        private void HandleConnectionStateChange(object sender, bool newState)
     348        {
     349            if (newState)
     350                waitForConnection.Set();
    314351        }
    315352
     
    417454        {
    418455            return channel + "#" + number + "-" + factor + "PERFORMANCE" + ID.ToString();
    419         }   
     456        }
     457
     458        public string StatusIdentifier()
     459        {
     460            return channel + "#" + number + "-status";
     461        }
    420462
    421463        private void StartLoadStoreThread()
     
    523565            peerPerformances = new Queue<PeerPerformanceInformations>();
    524566            activePeers = new HashSet<int>();
    525 
    526             head = 0;
    527             SynchronizeHead();
    528567           
    529568            //store our name:
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSieve.cs

    r1739 r1763  
    6363        private FactorManager factorManager;
    6464        private PeerToPeer peerToPeer;
     65        private PeerToPeerStatusUpdater peerToPeerStatusUpdater;
    6566        private bool usePeer2Peer;
    6667        private bool useGnuplot = false;
     
    7273        private static bool alreadyInUse = false;
    7374        private static Mutex alreadyInUseMutex = new Mutex();
    74         private AutoResetEvent waitForConnection = new AutoResetEvent(false);
     75        private AutoResetEvent waitForConnection = new AutoResetEvent(false);       
    7576
    7677        #endregion
     
    103104
    104105            peerToPeer = new PeerToPeer(quadraticSieveQuickWatchPresentation, newRelationPackageEvent);
     106            peerToPeerStatusUpdater = new PeerToPeerStatusUpdater(peerToPeer);
    105107            peerToPeer.P2PWarning += new PeerToPeer.P2PWarningHandler(peerToPeer_P2PWarning);
    106108           
     
    169171                else if (usePeer2Peer && !P2PManager.IsConnected)
    170172                {
    171                     GuiLogMessage("No connection to Peer2Peer network. Sieving locally now!", NotificationLevel.Warning);
     173                    GuiLogMessage("No connection to Peer2Peer network. Sieving locally now but waiting for connection...", NotificationLevel.Warning);
     174                    P2PManager.ConnectionManager.OnP2PConnectionStateChangeOccurred += OnP2PConnectionStateChangeOccurred;
    172175                    usePeer2Peer = false;
    173176                }
     
    285288            {
    286289                alreadyInUse = false;
    287             }
     290                P2PManager.ConnectionManager.OnP2PConnectionStateChangeOccurred -= OnP2PConnectionStateChangeOccurred;
     291            }
     292        }
     293
     294        private void OnP2PConnectionStateChangeOccurred(object sender, bool newState)
     295        {
     296            usePeer2Peer = newState;
     297            if (usePeer2Peer)
     298                GuiLogMessage("Using Peer2Peer network now!", NotificationLevel.Info);
     299            else
     300                GuiLogMessage("Lost Peer2Peer network connection... Sieving locally now!", NotificationLevel.Info);
    288301        }
    289302
     
    521534            while (num_relations < max_relations)
    522535            {
    523                 ProgressChanged((double)num_relations / max_relations * 0.8 + 0.1, 1.0);
     536                double progress = (double)num_relations / max_relations * 0.8 + 0.1;
     537                ProgressChanged(progress, 1.0);               
    524538               
    525539                newRelationPackageEvent.WaitOne();               //wait until there is a new relation package in the queue
     
    529543                while (relationPackageQueue.Count != 0)       //get all the results from the helper threads, and store them
    530544                {
    531                     IntPtr relationPackage = (IntPtr)relationPackageQueue.Dequeue();                   
    532 
    533                     if (usePeer2Peer)
     545                    IntPtr relationPackage = (IntPtr)relationPackageQueue.Dequeue();
     546
     547                    if (settings.UsePeer2Peer)
    534548                    {
    535549                        byte[] serializedRelationPackage = (byte[])serializeRelationPackage.Invoke(null, new object[] { relationPackage });
     
    562576
    563577        private void showProgressPresentation(int max_relations, int num_relations, int start_relations, DateTime start_sieving_time)
    564         {
     578        {           
    565579            String logging_message = "Found " + num_relations + " of " + max_relations + " relations!";
    566580            double msleft = 0;
     
    651665                    BigInteger compositeFactor = factorManager.GetCompositeFactor();
    652666                    showFactorInformations(compositeFactor);
    653                     if (usePeer2Peer)
     667                    if (settings.UsePeer2Peer)
    654668                        peerToPeer.SetFactor(compositeFactor);
    655669
     
    795809        {
    796810            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
     811            peerToPeerStatusUpdater.UpdateStatus(value/max);
    797812        }
    798813
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSieve.csproj

    r1695 r1763  
    111111    <Compile Include="NotSievableException.cs" />
    112112    <Compile Include="PeerToPeer.cs" />
     113    <Compile Include="PeerToPeerStatusUpdater.cs" />
    113114    <Compile Include="ProgressRelationPackages.xaml.cs">
    114115      <DependentUpon>ProgressRelationPackages.xaml</DependentUpon>
     
    131132      <Name>CrypPluginBase</Name>
    132133      <Private>False</Private>
     134    </ProjectReference>
     135    <ProjectReference Include="..\P2PEditor\P2PEditor.csproj">
     136      <Project>{59DEB752-BEB6-4B2B-86A9-78B150537529}</Project>
     137      <Name>P2PEditor</Name>
    133138    </ProjectReference>
    134139  </ItemGroup>
Note: See TracChangeset for help on using the changeset viewer.