Changeset 1628


Ignore:
Timestamp:
Jun 13, 2010, 9:42:30 PM (11 years ago)
Author:
Sven Rech
Message:

lots of quadratic sieve plugin changes affecting the time approximation and peer2peer representation.

Location:
trunk
Files:
10 edited

Legend:

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

    r1615 r1628  
    3333    class PeerToPeer
    3434    {
     35        private struct PeerPerformanceInformations
     36        {
     37            public DateTime lastChecked;
     38            public int peerID;
     39            public double performance;
     40            public int lastAlive;           
     41
     42            public PeerPerformanceInformations(DateTime lastChecked, int peerID, double performance, int lastAlive)
     43            {
     44                this.lastAlive = lastAlive;
     45                this.lastChecked = lastChecked;
     46                this.peerID = peerID;
     47                this.performance = performance;
     48            }
     49        }
     50
    3551        private string channel;
    3652        private BigInteger number;
     
    4359        private QuadraticSievePresentation quadraticSieveQuickWatchPresentation;
    4460        private AutoResetEvent yieldEvent;
     61        private int ourID;           //Our ID
     62        private Dictionary<int, string> nameCache;  //associates the ids with the names
     63        private Queue<PeerPerformanceInformations> peerPerformances;      //A queue of performances from the different peers ordered by the date last checked.
     64        private HashSet<int> activePeers;                                 //A set of active peers
     65        private double ourPerformance = 0;
     66        private int aliveCounter = 0;       //This is stored together with the performance in the DHT
     67        private string ourName;
    4568
    4669        public delegate void P2PWarningHandler(String warning);
    47         public event P2PWarningHandler P2PWarning;
     70        public event P2PWarningHandler P2PWarning;       
    4871
    4972        public PeerToPeer(QuadraticSievePresentation presentation, AutoResetEvent yieldEvent)
     
    5174            quadraticSieveQuickWatchPresentation = presentation;
    5275            this.yieldEvent = yieldEvent;
    53         }
    54 
    55         private byte[] ReadYield(int index)
    56         {
     76            SetOurID();
     77        }
     78
     79        private void SetOurID()
     80        {
     81            Random random = new Random();
     82            ourID = random.Next(1, Int32.MaxValue);        //TODO: Maybe we should calculate an id based on mac address and username?
     83            quadraticSieveQuickWatchPresentation.ProgressYields.setOurID(ourID);
     84            ourName = System.Net.Dns.GetHostName();
     85        }
     86
     87        /// <summary>
     88        /// Reads yield at position "index" from DHT and returns the ownerID and the decompressed packet itself.
     89        /// </summary>
     90        private byte[] ReadYield(int index, out int ownerID)
     91        {
     92            ownerID = 0;
    5793            byte[] yield = P2PManager.Retrieve(YieldIdentifier(index));
    5894            if (yield == null)
    5995                return null;
    6096
    61             byte[] decompressedYield = DecompressYield(yield);           
    62             return decompressedYield;
     97            byte[] decompressedYield = DecompressYield(yield);
     98
     99            byte[] idbytes = new byte[4];
     100            Array.Copy(decompressedYield, idbytes, 4);
     101            ownerID = BitConverter.ToInt32(idbytes, 0);
     102            byte[] y = new byte[decompressedYield.Length - 4];
     103            Array.Copy(decompressedYield, 4, y, 0, y.Length);
     104
     105            return y;
    63106        }
    64107
     
    76119        }
    77120
     121        private uint ReadAndEnqueueYield(int loadIndex, uint downloaded, uint uploaded)
     122        {
     123            int ownerID;
     124            byte[] yield = ReadYield(loadIndex, out ownerID);
     125            if (yield != null)
     126            {
     127                downloaded += (uint)yield.Length;
     128                ShowTransfered(downloaded, uploaded);
     129                loadqueue.Enqueue(yield);
     130
     131                //Progress Yield:
     132                if (!nameCache.ContainsKey(ownerID))
     133                {
     134                    byte[] n = P2PManager.Retrieve(NameIdentifier(ownerID));
     135                    if (n != null)
     136                        nameCache.Add(ownerID, System.Text.ASCIIEncoding.ASCII.GetString(n));
     137                }
     138                string name = null;
     139                if (nameCache.ContainsKey(ownerID))
     140                    name = nameCache[ownerID];
     141                SetProgressYield(loadIndex, ownerID, name);
     142
     143                //Performance and alive informations:
     144                if (!activePeers.Contains(ownerID))
     145                {
     146                    UpdatePeerPerformance(ownerID);
     147                    activePeers.Add(ownerID);
     148                    UpdateActivePeerInformation();
     149                }
     150
     151                yieldEvent.Set();
     152                return downloaded;
     153            }
     154            return 0;
     155        }
     156
     157        /// <summary>
     158        /// Tries to read and enqueue yield on position "loadIndex".
     159        /// If it fails, it stores the index in lostIndices queue.
     160        /// </summary>
     161        private uint TryReadAndEnqueueYield(int index, uint downloaded, uint uploaded, Queue<KeyValuePair<int, DateTime>> lostIndices)
     162        {
     163            uint res = ReadAndEnqueueYield(index, downloaded, uploaded);
     164            if (res != 0)
     165                downloaded = res;
     166            else
     167            {
     168                var e = new KeyValuePair<int, DateTime>(index, DateTime.Now);
     169                lostIndices.Enqueue(e);
     170                SetProgressYield(index, -1, null);
     171            }
     172
     173            return downloaded;
     174        }
     175
    78176        private void LoadStoreThreadProc()
    79177        {
     
    84182            //Stores all the indices (together with there check date) which belong to lost packets (i.e. packets that can't be load anymore):
    85183            Queue<KeyValuePair<int, DateTime>> lostIndices = new Queue<KeyValuePair<int, DateTime>>();
     184            double lastPerformance = 0;
     185            DateTime performanceLastPut = new DateTime();
    86186
    87187            try
     
    89189                while (!stopLoadStoreThread)
    90190                {
     191                    //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:
     192                    if (ourPerformance != lastPerformance || performanceLastPut.CompareTo(DateTime.Now.Subtract(new TimeSpan(0, 1, 0))) < 0)
     193                    {
     194                        P2PManager.Retrieve(PerformanceIdentifier(ourID));      //just to outsmart the versioning system
     195                        P2PManager.Store(PerformanceIdentifier(ourID), concat(BitConverter.GetBytes(ourPerformance), BitConverter.GetBytes(aliveCounter++)));
     196                        lastPerformance = ourPerformance;
     197                        performanceLastPut = DateTime.Now;
     198                    }
     199
     200                    //updates all peer performances which have last been checked more than 2 minutes ago and check if they are still alive:
     201                    while (peerPerformances.Count != 0 && peerPerformances.Peek().lastChecked.CompareTo(DateTime.Now.Subtract(new TimeSpan(0, 2, 0))) < 0)
     202                    {
     203                        var e = peerPerformances.Dequeue();
     204
     205                        byte[] performancebytes = P2PManager.Retrieve(PerformanceIdentifier(e.peerID));
     206                        if (performancebytes != null)
     207                        {
     208                            double performance = BitConverter.ToDouble(performancebytes, 0);
     209                            int peerAliveCounter = BitConverter.ToInt32(performancebytes, 8);
     210                            if (peerAliveCounter <= e.lastAlive)
     211                            {
     212                                activePeers.Remove(e.peerID);
     213                                UpdateActivePeerInformation();
     214                            }
     215                            else
     216                                peerPerformances.Enqueue(new PeerPerformanceInformations(DateTime.Now, e.peerID, performance, peerAliveCounter));
     217                        }
     218                        else
     219                        {
     220                            activePeers.Remove(e.peerID);
     221                        }                       
     222                    }
     223
    91224                    SynchronizeHead();
    92225
    93                     if (storequeue.Count != 0)  //storing has priority
     226                    if (storequeue.Count != 0)  //store our packages
    94227                    {
    95228                        byte[] yield = (byte[])storequeue.Dequeue();
     
    100233                            success = P2PManager.Store(YieldIdentifier(head), yield);
    101234                        }
    102                         SetProgressYield(head, YieldStatus.Ours);
     235                        SetProgressYield(head, ourID, null);
    103236                        ourIndices.Add(head);
    104237                       
     
    111244                    else                      //if there is nothing to store, we can load the other yields.
    112245                    {
     246                        //skip all indices which are uploaded by us:
    113247                        while (ourIndices.Contains(loadIndex))
    114248                            loadIndex++;
     
    117251                        {
    118252                            downloaded = TryReadAndEnqueueYield(loadIndex, downloaded, uploaded, lostIndices);
    119 
    120253                            loadIndex++;
    121254                        }
    122255                        else
    123256                        {
     257                            int count = 0;
    124258                            //check all lost indices which are last checked longer than 1 minutes ago:
    125259                            //TODO: Maybe we should throw away those indices, which have been checked more than several times.
    126                             while (lostIndices.Peek().Value.CompareTo(DateTime.Now.Subtract(new TimeSpan(0,1,0))) < 0)
     260                            while (lostIndices.Count != 0 && lostIndices.Peek().Value.CompareTo(DateTime.Now.Subtract(new TimeSpan(0, 1, 0))) < 0)
    127261                            {
    128262                                var e = lostIndices.Dequeue();
    129263                                downloaded = TryReadAndEnqueueYield(loadIndex, downloaded, uploaded, lostIndices);
     264                                count++;
    130265                            }
    131                             Thread.Sleep(5000);    //Wait 5 seconds
     266
     267                            if (count == 0)
     268                                Thread.Sleep(5000);    //Wait 5 seconds
    132269                        }
    133270                    }
     
    140277        }
    141278
    142         /// <summary>
    143         /// Tries to read and enqueue yield on position "loadIndex".
    144         /// If it fails, it stores the index in lostIndices queue.
    145         /// </summary>
    146         private uint TryReadAndEnqueueYield(int loadIndex, uint downloaded, uint uploaded, Queue<KeyValuePair<int, DateTime>> lostIndices)
    147         {
    148             uint res = ReadAndEnqueueYield(loadIndex, downloaded, uploaded);
    149             if (res != 0)
    150                 downloaded = res;
    151             else
    152             {
    153                 var e = new KeyValuePair<int, DateTime>(loadIndex, DateTime.Now);
    154                 lostIndices.Enqueue(e);
    155             }
    156             return downloaded;
    157         }
    158 
    159         /// <summary>
    160         /// Loads head from DHT. If ours is greater, we store ours.
     279        private void UpdateActivePeerInformation()
     280        {
     281            quadraticSieveQuickWatchPresentation.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     282            {
     283                quadraticSieveQuickWatchPresentation.amountOfPeers.Content = "" + activePeers.Count + " peers active!";
     284            }, null);
     285        }
     286
     287        private void UpdatePeerPerformance(int peerID)
     288        {
     289            byte[] performancebytes = P2PManager.Retrieve(PerformanceIdentifier(peerID));
     290            if (performancebytes != null)
     291            {
     292                double performance = BitConverter.ToDouble(performancebytes, 0);
     293                int peerAliveCounter = BitConverter.ToInt32(performancebytes, 8);
     294                peerPerformances.Enqueue(new PeerPerformanceInformations(DateTime.Now, peerID, performance, peerAliveCounter));
     295            }
     296        }
     297
     298        /// <summary>
     299        /// Loads head from DHT. If ours is greater (or there is no entry yet), we store ours.
    161300        /// </summary>
    162301        private void SynchronizeHead()
     
    172311                        SynchronizeHead();
    173312                }
    174                 else
     313                else if (head < dhthead)
     314                {
    175315                    head = dhthead;
    176             }           
    177         }
    178 
    179         private uint ReadAndEnqueueYield(int loadIndex, uint downloaded, uint uploaded)
    180         {
    181             byte[] yield = ReadYield(loadIndex);
    182             if (yield != null)
    183             {
    184                 downloaded += (uint)yield.Length;
    185                 ShowTransfered(downloaded, uploaded);
    186                 loadqueue.Enqueue(yield);
    187                 SetProgressYield(loadIndex, YieldStatus.OthersLoaded);
    188                 yieldEvent.Set();
    189                 return downloaded;
    190             }
    191             return 0;
     316                    SetProgressYield(head - 1, 0, null);
     317                }
     318            }
     319            else
     320            {
     321                bool success = P2PManager.Store(HeadIdentifier(), System.Text.ASCIIEncoding.ASCII.GetBytes(head.ToString()));
     322                if (!success)
     323                    SynchronizeHead();
     324            }
    192325        }
    193326
     
    204337        }
    205338
    206         private void SetProgressYield(int index, YieldStatus status)
     339        private void SetProgressYield(int index, int id, string name)
    207340        {
    208341            quadraticSieveQuickWatchPresentation.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    209342            {
    210                 quadraticSieveQuickWatchPresentation.ProgressYields[index] = status;
     343                quadraticSieveQuickWatchPresentation.ProgressYields.Set(index, id, name);
    211344            }, null);
    212345        }
     
    234367            return channel + "#" + number + "-" + factor + "!" + index;
    235368        }
     369
     370        private string NameIdentifier(int ID)
     371        {
     372            return channel + "#" + number + "NAME" + ID.ToString();
     373        }
     374
     375        private string PerformanceIdentifier(int ID)
     376        {
     377            return channel + "#" + number + "-" + factor + "PERFORMANCE" + ID.ToString();
     378        }   
    236379
    237380        private void StartLoadStoreThread()
     
    243386            loadStoreThread = new Thread(LoadStoreThreadProc);
    244387            loadStoreThread.Start();
     388        }
     389
     390        /// <summary>
     391        /// Concatenates the two byte arrays a1 and a2 an returns the result array.
     392        /// </summary>
     393        private byte[] concat(byte[] a1, byte[] a2)
     394        {
     395            byte[] res = new byte[a1.Length + a2.Length];
     396            System.Buffer.BlockCopy(a1, 0, res, 0, a1.Length);
     397            System.Buffer.BlockCopy(a2, 0, res, a1.Length, a2.Length);
     398            return res;
    245399        }
    246400
     
    263417        public void Put(byte[] serializedYield)
    264418        {
     419            //Add our ID:
     420            byte[] idbytes = BitConverter.GetBytes(ourID);
     421            Debug.Assert(idbytes.Length == 4);
     422            serializedYield = concat(idbytes, serializedYield); ;
     423
    265424            //Compress:
    266425            MemoryStream memStream = new MemoryStream();
     
    303462
    304463            ClearProgressYields();
     464            nameCache = new Dictionary<int, string>();
     465            peerPerformances = new Queue<PeerPerformanceInformations>();
     466            activePeers = new HashSet<int>();
     467
     468            //load head:
    305469            byte[] h = P2PManager.Retrieve(HeadIdentifier());
    306470            if (h != null)
    307471            {               
    308472                head = int.Parse(System.Text.ASCIIEncoding.ASCII.GetString(h));
    309                 SetProgressYield(head-1, YieldStatus.OthersNotLoaded);
     473                SetProgressYield(head-1, 0, null);
    310474            }
    311475            else
    312476                head = 0;
     477
     478            SetOurID();
     479
     480            //store our name:
     481            P2PManager.Retrieve(NameIdentifier(ourID));     //just to outsmart the versioning system
     482            P2PManager.Store(NameIdentifier(ourID),  System.Text.ASCIIEncoding.ASCII.GetBytes(ourName.ToCharArray())); //TODO: proper name here!
    313483
    314484            if (loadStoreThread != null)
    315485                throw new Exception("LoadStoreThread already started");
    316486            StartLoadStoreThread();
    317         }       
     487        }
    318488
    319489        /// <summary>
     
    363533            return factorManager.ContainsComposite(this.factor);
    364534        }
     535
     536        /// <summary>
     537        /// Sets the performance of this machine, so that this class can write it to the DHT later.
     538        /// The performance is meassured in relations per ms.
     539        /// </summary>
     540        public void SetOurPerformance(double[] relationsPerMS)
     541        {
     542            double globalPerformance = 0;
     543            foreach (double r in relationsPerMS)
     544                globalPerformance += r;
     545
     546            ourPerformance = globalPerformance;
     547        }
     548
     549        /// <summary>
     550        /// Returns the performance of all peers (excluding ourselve) in relations per ms.
     551        /// </summary>
     552        public double GetP2PPerformance()
     553        {
     554            double perf = 0;
     555
     556            foreach (var p in peerPerformances)
     557                perf += p.performance;
     558
     559            return perf;
     560        }
    365561    }
    366562}
  • trunk/CrypPlugins/QuadraticSieve/ProgressYields.xaml.cs

    r1522 r1628  
    1515namespace Cryptool.Plugins.QuadraticSieve
    1616{
    17     public enum YieldStatus {Ours, OthersNotLoaded, OthersLoaded};
    18 
    1917    /// <summary>
    2018    /// Interaction logic for ProgressYields.xaml
     
    2220    public partial class ProgressYields : UserControl
    2321    {
    24         public YieldStatus this[int i]
     22        private int ourID;
     23        private Random random = new Random();
     24        private Dictionary<int, Brush> colorMap = new Dictionary<int, Brush>();     //maps user ids to their colors
     25        private int peerAmount;
     26
     27        public delegate void AmountOfClientsChangedHandler(int amount);
     28        public event AmountOfClientsChangedHandler AmountOfClientsChanged;
     29
     30        public void Set(int i, int id, string name)
    2531        {
    26             set
     32            if (root.Children.Count <= i)   //if no rect exists for this yield yet
    2733            {
    28                 if (root.Children.Count <= i)   //if no rect exists for this yield yet
    29                 {
    30                     //Create some rects to fill the gap:
    31                     for (int c = root.Children.Count; c < i; c++)
    32                         createYieldRect(c, YieldStatus.OthersNotLoaded);
    33                     //create the rect:
    34                     createYieldRect(i, value);
    35                 }
    36                 else
    37                 {
    38                     SetRectToStatus(root.Children[i] as Rectangle, value);                   
    39                 }
     34                //Create some rects to fill the gap:
     35                for (int c = root.Children.Count; c < i; c++)
     36                    createYieldRect(c, 0, name);
     37                //create the rect:
     38                createYieldRect(i, id, name);
     39            }
     40            else
     41            {
     42                SetRectToStatus(root.Children[i] as Rectangle, id, name);
    4043            }
    4144        }
     
    4447        {
    4548            root.Children.Clear();
     49            peerAmount = 0;
    4650        }
    4751
    48         private void SetRectToStatus(Rectangle rectangle, YieldStatus value)
     52        public void setOurID(int id)
     53        {
     54            ourID = id;
     55        }
     56
     57        private void SetRectToStatus(Rectangle rectangle, int uploaderID, string uploaderName)
    4958        {
    5059            ToolTip tooltip = new ToolTip();
    51             switch (value)
     60            if (uploaderID == ourID)
    5261            {
    53                 case YieldStatus.Ours:
    54                     rectangle.Fill = Brushes.Green;
    55                     tooltip.Content = "This yield was sieved by us";
    56                     break;
    57                 case YieldStatus.OthersLoaded:
    58                     rectangle.Fill = Brushes.Yellow;
    59                     tooltip.Content = "This yield was sieved by others but we loaded it";
    60                     break;
    61                 case YieldStatus.OthersNotLoaded:
    62                     rectangle.Fill = Brushes.Red;
    63                     tooltip.Content = "This yield was sieved by others but we didn't loaded it yet";
    64                     break;
     62                rectangle.Fill = Brushes.Green;
     63                tooltip.Content = "This yield was sieved by us";
    6564            }
     65            else if (uploaderID == 0)
     66            {
     67                rectangle.Fill = Brushes.Black;
     68                tooltip.Content = "This yield was sieved by an unknown user and we didn't load it yet";
     69            }
     70            else if (uploaderID == -1)
     71            {
     72                rectangle.Fill = Brushes.White;     //TODO: Proper representation here               
     73                tooltip.Content = "This yield got lost";
     74            }
     75            else
     76            {
     77                rectangle.Fill = GetColor(uploaderID);
     78                if (uploaderName == null)
     79                    uploaderName = "other user";
     80                tooltip.Content = "This yield was sieved by " + uploaderName + " but we loaded it";
     81            }           
    6682            rectangle.ToolTip = tooltip;
    6783        }
    6884
    69         private void createYieldRect(int c, YieldStatus yieldStatus)
     85        private Brush GetColor(int uploaderID)
    7086        {
    71             Rectangle rect = new Rectangle();           
    72             //rect.Margin = JobMargin;
     87            if (!colorMap.ContainsKey(uploaderID))
     88            {
     89                peerAmount++;
     90                AmountOfClientsChanged(peerAmount);
     91                SolidColorBrush color = new SolidColorBrush();
     92                color.Color = Color.FromRgb((byte)random.Next(256), (byte)random.Next(256), (byte)random.Next(256));
     93                colorMap[uploaderID] = color;
     94                return color;
     95            }
     96            else
     97                return colorMap[uploaderID];
     98        }
     99
     100        private void createYieldRect(int c, int id, string name)
     101        {
     102            Rectangle rect = new Rectangle();                       
    73103            rect.Width = 10;
    74104            rect.Height = rect.Width;
    75105            rect.Stroke = Brushes.White;
    76106            rect.StrokeThickness = 0.1;
    77             SetRectToStatus(rect, yieldStatus);
     107            SetRectToStatus(rect, id, name);
    78108            root.Children.Add(rect);
    79109        }
     
    82112        {
    83113            InitializeComponent();
    84 
    85114            root.Children.Clear();
    86115        }
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSieve.cs

    r1616 r1628  
    6565        private bool useGnuplot = false;
    6666        private StreamWriter gnuplotFile;
     67        private double[] relationsPerMS;
    6768
    6869        private static Assembly msieveDLL = null;
     
    7980        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
    8081        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
    81         public event PluginProgressChangedEventHandler OnPluginProcessChanged;       
     82        public event PluginProgressChangedEventHandler OnPluginProcessChanged;
    8283
    8384        #endregion
     
    192193                    quadraticSieveQuickWatchPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    193194                    {
     195                        quadraticSieveQuickWatchPresentation.ProgressYields.Clear();
    194196                        quadraticSieveQuickWatchPresentation.logging.Text = logging_message;
    195197                        quadraticSieveQuickWatchPresentation.endTime.Text = endtime_message;
     
    457459            running = true;
    458460            //start helper threads:
     461            relationsPerMS = new double[threads + 1];
    459462            for (int i = 0; i < threads+1; i++)
    460463            {
     
    463466                conf_list.Add(clone);
    464467                WaitCallback worker = new WaitCallback(MSieveJob);
    465                 ThreadPool.QueueUserWorkItem(worker, new object[] { clone, update, core_sieve_fcn, yieldqueue });
     468                ThreadPool.QueueUserWorkItem(worker, new object[] { clone, update, core_sieve_fcn, yieldqueue, i });
    466469            }
    467470
     
    533536                showProgressPresentation(max_relations, num_relations, start_relations, start_sieving_time);
    534537
    535                 if (usePeer2Peer && !peerToPeer.SyncFactorManager(factorManager))   //an other peer already finished sieving
     538                if (usePeer2Peer && !peerToPeer.SyncFactorManager(factorManager))   //another peer already finished sieving
    536539                {
    537540                    throw new AlreadySievedException();
     
    542545        private void showProgressPresentation(int max_relations, int num_relations, int start_relations, DateTime start_sieving_time)
    543546        {
    544             TimeSpan diff = DateTime.Now - start_sieving_time;
     547            String logging_message = "Found " + num_relations + " of " + max_relations + " relations!";
     548            double msleft = 0;
     549
     550            //calculate global performance in relations per ms:
     551            double globalPerformance = 0;
     552            foreach (double r in relationsPerMS)
     553                globalPerformance += r;
     554            if (usePeer2Peer)
     555                globalPerformance += peerToPeer.GetP2PPerformance();
     556
     557            //Calculate the total time assuming that we can sieve 10 minutes with the same performance:
     558            double relationsCalculatableIn10Minutes = 1000 * 60 * 1 * globalPerformance;
     559            if (relationsCalculatableIn10Minutes <= max_relations)
     560            {
     561                double p = ApproximatedPolynom(relationsCalculatableIn10Minutes / max_relations);
     562                double estimatedTotalTime = 1000 * 60 * 1 / p;
     563
     564                //Calculate the elapsed time assuming that we sieved with the same performance the whole time:
     565                p = ApproximatedPolynom((double)num_relations / max_relations);
     566                double estimatedElapsedTime = estimatedTotalTime * p;
     567
     568                //Calculate the time left:
     569                msleft = estimatedTotalTime - estimatedElapsedTime;
     570                GuiLogMessage("Total: " + new TimeSpan(0, 0, 0, 0, (int)estimatedTotalTime), NotificationLevel.Info);
     571                GuiLogMessage("Elapsed: " + new TimeSpan(0, 0, 0, 0, (int)estimatedElapsedTime), NotificationLevel.Info);
     572            }           
     573           
     574            String timeLeft_message = "";
     575            String endtime_message = "";
     576            if (msleft > 0 && !double.IsInfinity(msleft))
     577            {
     578                TimeSpan ts = new TimeSpan(0, 0, 0, 0, (int)msleft);
     579                timeLeft_message = showTimeSpan(ts) + " left";
     580                endtime_message = "" + DateTime.Now.AddMilliseconds((long)msleft);
     581            }
     582
     583            quadraticSieveQuickWatchPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     584            {
     585                quadraticSieveQuickWatchPresentation.logging.Text = logging_message;
     586                quadraticSieveQuickWatchPresentation.timeLeft.Text = timeLeft_message;
     587                quadraticSieveQuickWatchPresentation.endTime.Text = endtime_message;
     588            }, null);
     589
     590            if (useGnuplot)
     591            {
     592                double percentage = (double)num_relations / max_relations;
     593                double time = (DateTime.Now - start_sieving_time).TotalSeconds;
     594                gnuplotFile.WriteLine("" + time + "\t\t" + percentage);
     595            }
     596        }
     597
     598        private static double ApproximatedPolynom(double x)
     599        {
    545600            double a = -3.55504;
    546601            double b = 8.62296;
    547602            double c = -7.75103;
    548603            double d = 3.65871;
    549             double x = (double)num_relations / max_relations;
    550             double progress = a * x*x*x*x + b * x*x*x + c * x*x + d * x;
    551             double totalTime = diff.TotalMilliseconds / progress;
    552             double msleft = totalTime - diff.TotalMilliseconds;
    553             //double msleft = (diff.TotalMilliseconds / (num_relations - start_relations)) * (max_relations - num_relations);
    554             if (msleft > 0 && !double.IsInfinity(msleft))
    555             {
    556                 TimeSpan ts = new TimeSpan(0, 0, 0, 0, (int)msleft);
    557                 String logging_message = "Found " + num_relations + " of " + max_relations + " relations!";
    558                 String timeLeft_message = showTimeSpan(ts) + " left";
    559                 String endtime_message = "" + DateTime.Now.AddMilliseconds((long)msleft);
    560 
    561                 GuiLogMessage(logging_message + " " + timeLeft_message + ".", NotificationLevel.Debug);
    562                 quadraticSieveQuickWatchPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    563                 {
    564                     quadraticSieveQuickWatchPresentation.logging.Text = logging_message;
    565                     quadraticSieveQuickWatchPresentation.timeLeft.Text = timeLeft_message;
    566                     quadraticSieveQuickWatchPresentation.endTime.Text = endtime_message;
    567                 }
    568                 , null);
    569             }
    570 
    571             if (useGnuplot)
    572             {
    573                 double percentage = (double)num_relations / max_relations;
    574                 double time = (DateTime.Now - start_sieving_time).TotalSeconds;
    575                 gnuplotFile.WriteLine("" + time + "\t\t" + percentage);
    576             }
     604            double progress = a * x * x * x * x + b * x * x * x + c * x * x + d * x;
     605            return progress;
    577606        }
    578607
     
    645674            IntPtr core_sieve_fcn = (IntPtr)parameters[2];
    646675            Queue yieldqueue = (Queue)parameters[3];
     676            int threadNR = (int)parameters[4];
     677
     678            MethodInfo collectRelations = msieve.GetMethod("collectRelations");
     679            MethodInfo getYield = msieve.GetMethod("getYield");
     680            MethodInfo getAmountOfRelationsInYield = msieve.GetMethod("getAmountOfRelationsInYield");
    647681
    648682            while (running)
     
    650684                try
    651685                {
    652                     MethodInfo collectRelations = msieve.GetMethod("collectRelations");
    653                     collectRelations.Invoke(null, new object[] { clone, update, core_sieve_fcn });
    654                     MethodInfo getYield = msieve.GetMethod("getYield");
     686                    //Calculate the performance of this thread:
     687                    DateTime beginning = DateTime.Now;                   
     688                    collectRelations.Invoke(null, new object[] { clone, update, core_sieve_fcn });                   
    655689                    IntPtr yield = (IntPtr)getYield.Invoke(null, new object[] { clone });
     690
     691                    int amountOfFullRelations = (int)getAmountOfRelationsInYield.Invoke(null, new object[] { yield });
     692                    relationsPerMS[threadNR] = amountOfFullRelations / (DateTime.Now - beginning).TotalMilliseconds;
     693
     694                    if (usePeer2Peer)
     695                        peerToPeer.SetOurPerformance(relationsPerMS);
    656696
    657697                    yieldqueue.Enqueue(yield);
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSievePresentation.xaml

    r1522 r1628  
    3434                    <RowDefinition />
    3535                    <RowDefinition />
     36                    <RowDefinition />
    3637                </Grid.RowDefinitions>
    3738                <Grid.ColumnDefinitions>
     
    4041
    4142                <Label Grid.Row="1" Content="" HorizontalAlignment="Stretch" Name="relationsInfo" VerticalAlignment="Bottom" />
     43                <Label Grid.Row="2" Content="" HorizontalAlignment="Stretch" Name="amountOfPeers" VerticalAlignment="Bottom" />
    4244            </Grid>               
    4345        </Expander>
  • trunk/CrypPlugins/QuadraticSieve/QuadraticSievePresentation.xaml.cs

    r1561 r1628  
    3535            grid.Children.Add(progressYields);
    3636            progressYields.MaxWidth = 200;
     37            progressYields.AmountOfClientsChanged += new Plugins.QuadraticSieve.ProgressYields.AmountOfClientsChangedHandler(progressYields_AmountOfClientsChanged);
     38        }
     39
     40        void progressYields_AmountOfClientsChanged(int amount)
     41        {
     42            amountOfPeers.Content = "" + amount + " peers participated so far! ";
    3743        }
    3844
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.cpp

    r1468 r1628  
    361361                }
    362362
     363                static int getAmountOfRelationsInYield(IntPtr yield)
     364                {
     365                        relationYield* y = (relationYield*)yield.ToPointer();
     366                        return y->num_relations;
     367                }
     368
    363369                static int getNumRelations(IntPtr conf)
    364370                {
  • trunk/CrypPlugins/QuadraticSieve/msieve/build.vc9/msieve.dll/wrapper.h

    r1468 r1628  
    2626        int yield_count;
    2727        int yield_capacity;
    28         struct yield_element *yield_array;     
     28        struct yield_element *yield_array;
     29        int num_relations;
    2930} relationYield;
  • trunk/CrypPlugins/QuadraticSieve/msieve/mpqs/sieve.c

    r1468 r1628  
    762762                }
    763763        }
     764
     765        if (conf->slave)
     766                conf->yield->num_relations = relations_found;
    764767}
    765768
Note: See TracChangeset for help on using the changeset viewer.