Changeset 1558


Ignore:
Timestamp:
Jun 1, 2010, 5:23:21 PM (12 years ago)
Author:
Sven Rech
Message:

some more quadratic sieve changes

Location:
trunk/CrypPlugins/QuadraticSieve
Files:
2 edited

Legend:

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

    r1557 r1558  
    4444        private AutoResetEvent yieldEvent;
    4545
     46        public delegate void P2PWarningHandler(String warning);
     47        public event P2PWarningHandler P2PWarning;
     48
    4649        public PeerToPeer(QuadraticSievePresentation presentation, AutoResetEvent yieldEvent)
    4750        {
     
    5659                return null;
    5760
    58             byte[] decompressedYield = decompressYield(yield);
     61            byte[] decompressedYield = DecompressYield(yield);
    5962           
    6063            return decompressedYield;
    6164        }
    6265
    63         private static byte[] decompressYield(byte[] yield)
     66        private static byte[] DecompressYield(byte[] yield)
    6467        {
    6568            MemoryStream memStream = new MemoryStream();
     
    7982            int loadIndex = 0;
    8083
    81             while (!stopLoadStoreThread)
    82             {               
    83                 if (storequeue.Count != 0)  //storing has priority
     84            try
     85            {
     86                while (!stopLoadStoreThread)
    8487                {
    85                     byte[] yield = (byte[])storequeue.Dequeue();
    86                     P2PManager.Store(YieldIdentifier(head), yield);
    87                     //TODO: If versioning sytem tells us, that there is already a newer entry here, we load this value, enqueue it in loadqueue and try again with head++
    88                     SetProgressYield(head, YieldStatus.Ours);
    89                     head++;
    90                     P2PManager.Store(HeadIdentifier(), System.Text.ASCIIEncoding.ASCII.GetBytes(head.ToString()));
    91                     //TODO: If versioning system tells us, that there is already a newer head entry, we ignore this and don't store ours
    92                 }
    93                 else                      //if there is nothing to store, we can load the yields up to "loadEnd".
    94                 {
    95                     if (loadIndex < loadEnd)
     88                    if (storequeue.Count != 0)  //storing has priority
    9689                    {
    97                         byte[] yield = ReadYield(loadIndex);
    98                         loadqueue.Enqueue(yield);
    99                         SetProgressYield(loadIndex, YieldStatus.OthersLoaded);
    100                         loadIndex++;
    101                         yieldEvent.Set();
     90                        byte[] yield = (byte[])storequeue.Dequeue();
     91                        P2PManager.Store(YieldIdentifier(head), yield);
     92                        //TODO: If versioning sytem tells us, that there is already a newer entry here, we load this value, enqueue it in loadqueue and try again with head++
     93                        SetProgressYield(head, YieldStatus.Ours);
     94                        head++;
     95                        P2PManager.Store(HeadIdentifier(), System.Text.ASCIIEncoding.ASCII.GetBytes(head.ToString()));
     96                        //TODO: If versioning system tells us, that there is already a newer head entry, we ignore this and don't store ours
    10297                    }
    103                     else                //if there is nothing left to load, we can slow down.
     98                    else                      //if there is nothing to store, we can load the yields up to "loadEnd".
    10499                    {
    105                         Thread.Sleep(10000);        //wait 10 seconds
     100                        if (loadIndex < loadEnd)
     101                        {
     102                            byte[] yield = ReadYield(loadIndex);
     103                            loadqueue.Enqueue(yield);
     104                            SetProgressYield(loadIndex, YieldStatus.OthersLoaded);
     105                            loadIndex++;
     106                            yieldEvent.Set();
     107                        }
     108                        else                //if there is nothing left to load, we can slow down.
     109                        {
     110                            Thread.Sleep(10000);        //wait 10 seconds
     111                        }
    106112                    }
    107113                }
     114            }
     115            catch (ThreadInterruptedException)
     116            {
     117                return;
    108118            }
    109119        }
     
    153163        {
    154164            stopLoadStoreThread = true;
     165            loadStoreThread.Interrupt();
    155166            loadStoreThread.Join();
    156167            loadStoreThread = null;
     
    168179        public int Put(byte[] serializedYield)
    169180        {
     181            //Compress:
    170182            MemoryStream memStream = new MemoryStream();
    171183            DeflateStream defStream = new DeflateStream(memStream, CompressionMode.Compress);
     
    174186            byte[] compressedYield = memStream.ToArray();
    175187
    176             byte[] decompr = decompressYield(compressedYield);
     188            //Debug stuff:
     189            byte[] decompr = DecompressYield(compressedYield);
    177190            Debug.Assert(decompr.Length == serializedYield.Length);
    178191
     192            //store in queue, so the LoadStoreThread can store it in the DHT later:
    179193            storequeue.Enqueue(compressedYield);
    180194            return compressedYield.Length;
     
    240254                catch (System.Runtime.Serialization.SerializationException)
    241255                {
    242                     //TODO: GuiLogMessage here
     256                    P2PWarning("DHT factor list is broken!");
    243257                    P2PManager.Remove(FactorListIdentifier());
    244258                    return SyncFactorManager(factorManager);
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSieve.cs

    r1557 r1558  
    9999
    100100            peerToPeer = new PeerToPeer(quadraticSieveQuickWatchPresentation, yieldEvent);
     101            peerToPeer.P2PWarning += new PeerToPeer.P2PWarningHandler(peerToPeer_P2PWarning);
    101102           
    102103            quadraticSieveQuickWatchPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     
    108109            }
    109110            , null);
    110         }               
     111        }
    111112
    112113        /// <summary>
     
    754755            initMsieve.Invoke(null, new object[1] { callback_struct });
    755756        }
     757
     758        private void peerToPeer_P2PWarning(string warning)
     759        {
     760            GuiLogMessage(warning, NotificationLevel.Warning);
     761        }
     762
    756763        #endregion
    757764
Note: See TracChangeset for help on using the changeset viewer.