source: trunk/CrypPlugins/KeySearcher/P2P/Presentation/StatisticsGenerator.cs @ 2359

Last change on this file since 2359 was 2359, checked in by nolte, 11 years ago

Added extension for the key values.
(Commited as comments. Needs to be tested before release)
Still using Version 4 -> No DHT changes yet.

File size: 10.6 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Diagnostics;
4using System.Numerics;
5using System.Text;
6using System.Threading;
7using System.Windows.Threading;
8using Cryptool.P2P;
9using KeySearcher.KeyPattern;
10using KeySearcherPresentation.Controls;
11using Timer = System.Timers.Timer;
12
13namespace KeySearcher.P2P.Presentation
14{
15    class StatisticsGenerator
16    {
17        public readonly BigInteger TotalAmountOfChunks;
18        private readonly StatusContainer status;
19        private readonly P2PQuickWatchPresentation quickWatch;
20        private readonly KeySearcher keySearcher;
21        private readonly DistributedBruteForceManager distributedBruteForceManager;
22        private readonly Stopwatch stopWatch;
23        private readonly Timer elapsedTimeTimer;
24        private readonly Timer trafficUpdateTimer;
25
26        public BigInteger HighestChunkCalculated;
27        private DateTime lastDateOfGlobalStatistics;
28        private BigInteger totalRequestsAtStartOfNodeSearch;
29
30        public StatisticsGenerator(StatusContainer status, P2PQuickWatchPresentation quickWatch, KeySearcher keySearcher, KeySearcherSettings settings, DistributedBruteForceManager distributedBruteForceManager)
31        {
32            this.status = status;
33            this.quickWatch = quickWatch;
34            this.keySearcher = keySearcher;
35            this.distributedBruteForceManager = distributedBruteForceManager;
36
37            lastDateOfGlobalStatistics = DateTime.Now;
38            HighestChunkCalculated = -1;
39            stopWatch = new Stopwatch();
40
41            var keyPattern = new KeyPattern.KeyPattern(keySearcher.ControlMaster.getKeyPattern())
42                                 {WildcardKey = settings.Key};
43            var keysPerChunk = Math.Pow(2, settings.ChunkSize);
44            var keyPatternPool = new KeyPatternPool(keyPattern, new BigInteger(keysPerChunk));
45
46            TotalAmountOfChunks = keyPatternPool.Length;
47
48            status.PropertyChanged += StatusPropertyChanged;
49
50            elapsedTimeTimer = new Timer(1000);
51            elapsedTimeTimer.Elapsed += ElapsedTimeTimerTick;
52            elapsedTimeTimer.Start();
53
54            trafficUpdateTimer = new Timer(10000);
55            trafficUpdateTimer.Elapsed += TrafficUpdateTimerTick;
56            trafficUpdateTimer.Start();
57        }
58
59        public void CalculationStopped()
60        {
61            elapsedTimeTimer.Stop();
62            trafficUpdateTimer.Stop();
63        }
64
65        void TrafficUpdateTimerTick(object sender, System.Timers.ElapsedEventArgs e)
66        {
67            UpdateTrafficStatistics();
68        }
69
70        void ElapsedTimeTimerTick(object sender, EventArgs e)
71        {
72            if (status.StartDate != DateTime.MinValue)
73                status.ElapsedTime = DateTime.Now.Subtract(status.StartDate);
74
75            if (status.RemainingTimeTotal > new TimeSpan(0))
76                status.RemainingTimeTotal = status.RemainingTimeTotal.Subtract(TimeSpan.FromSeconds(1));
77        }
78
79        void StatusPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
80        {
81            switch (e.PropertyName)
82            {
83                case "DhtOverheadInReadableTime":
84                    HandleUpdateOfOverheadTime();
85                    break;
86                case "StoredBytes":
87                    UpdateTrafficStatistics();
88                    break;
89                case "RetrievedBytes":
90                    UpdateTrafficStatistics();
91                    break;
92            }
93        }
94
95        private void UpdateTrafficStatistics()
96        {
97            status.SentBytesByLinkManager = P2PManager.P2PBase.TotalBytesSentOnAllLinks();
98            status.ReceivedBytesByLinkManager = P2PManager.P2PBase.TotalBytesReceivedOnAllLinks();
99            status.TotalBytesByLinkManager = status.ReceivedBytesByLinkManager + status.SentBytesByLinkManager;
100        }
101
102        private void HandleUpdateOfOverheadTime()
103        {
104            if (distributedBruteForceManager.StopWatch.Elapsed.Ticks == 0)
105            {
106                status.DhtOverheadInPercent = "0 %";
107                return;
108            }
109
110            var overheadInTicks = (double)status.DhtOverheadInReadableTime.Ticks /
111                           distributedBruteForceManager.StopWatch.Elapsed.Ticks;
112            var overheadInPercent = overheadInTicks * 100;
113            overheadInPercent = Math.Round(overheadInPercent, 2);
114           
115            status.DhtOverheadInPercent = overheadInPercent + " %";
116        }
117
118        public void MarkStartOfNodeSearch()
119        {
120            totalRequestsAtStartOfNodeSearch = status.TotalDhtRequests;
121            stopWatch.Start();
122        }
123
124        public void MarkEndOfNodeSearch()
125        {
126            stopWatch.Stop();
127            var elapsedTime = stopWatch.Elapsed.Add(status.DhtOverheadInReadableTime);
128            status.DhtOverheadInReadableTime = new TimeSpan(((long) Math.Round((1.0*elapsedTime.Ticks/5))*5));
129            stopWatch.Reset();
130           
131            var requestsForThisNode = status.TotalDhtRequests - totalRequestsAtStartOfNodeSearch;
132
133            if (status.RequestsPerNode == 0)
134            {
135                status.RequestsPerNode = requestsForThisNode;
136                return;
137            }
138
139            status.RequestsPerNode = (status.RequestsPerNode + requestsForThisNode)/2;
140        }
141
142        public void CalculateGlobalStatistics(BigInteger currentChunkCalculated)
143        {
144            if (HighestChunkCalculated == -1) HighestChunkCalculated = currentChunkCalculated;
145            if (currentChunkCalculated < HighestChunkCalculated) return;
146
147            var totalAmountOfParticipants = currentChunkCalculated - HighestChunkCalculated;
148            if (totalAmountOfParticipants == 0)
149                totalAmountOfParticipants = 1;
150           
151            status.TotalAmountOfParticipants = totalAmountOfParticipants;
152
153
154            var timeUsedForLatestProgress = DateTime.Now.Subtract(lastDateOfGlobalStatistics);
155            var secondsForOneChunk = timeUsedForLatestProgress.TotalSeconds/(double) totalAmountOfParticipants;
156            var remainingChunks = TotalAmountOfChunks - currentChunkCalculated;
157            var secondsRemaining = (double) remainingChunks*secondsForOneChunk;
158
159            try
160            {
161                var estimatedFinishDate = DateTime.Now.AddSeconds(secondsRemaining);
162                status.EstimatedFinishDate = estimatedFinishDate.ToString("g", Thread.CurrentThread.CurrentCulture);
163                status.RemainingTimeTotal = estimatedFinishDate.Subtract(DateTime.Now);
164            }
165            catch (ArgumentOutOfRangeException)
166            {
167                status.RemainingTimeTotal = TimeSpan.MaxValue;
168                var yearsRemaining = secondsRemaining/60/60/24/365;
169                status.EstimatedFinishDate = string.Format("{0:0.00e+0} years", yearsRemaining);
170            }
171
172            lastDateOfGlobalStatistics = DateTime.Now;
173
174            HighestChunkCalculated = currentChunkCalculated;
175            status.GlobalProgress = (double) HighestChunkCalculated/(double) TotalAmountOfChunks;
176            keySearcher.ProgressChanged(status.GlobalProgress, 1);
177        }
178
179        public void ProcessPatternResults(LinkedList<KeySearcher.ValueKey> result)
180        {
181            ProcessResultList(result);
182        }
183
184        public void ShowProgress(LinkedList<KeySearcher.ValueKey> bestResultList, BigInteger keysInThisChunk, BigInteger keysFinishedInThisChunk, long keysPerSecond)
185        {
186            status.ProgressOfCurrentChunk = (double) keysFinishedInThisChunk/(double) keysInThisChunk;
187            status.KeysPerSecond = keysPerSecond;
188
189            var time = (Math.Pow(10, BigInteger.Log((keysInThisChunk - keysFinishedInThisChunk), 10) - Math.Log10(keysPerSecond)));
190            var timeleft = new TimeSpan(-1);
191
192            try
193            {
194                if (time / (24 * 60 * 60) <= int.MaxValue)
195                {
196                    var days = (int)(time / (24 * 60 * 60));
197                    time = time - (days * 24 * 60 * 60);
198                    var hours = (int)(time / (60 * 60));
199                    time = time - (hours * 60 * 60);
200                    var minutes = (int)(time / 60);
201                    time = time - (minutes * 60);
202                    var seconds = (int)time;
203
204                    timeleft = new TimeSpan(days, hours, minutes, seconds, 0);
205                }
206            }
207            catch
208            {
209                //can not calculate time span
210            }
211
212            status.RemainingTime = timeleft;
213
214            ProcessResultList(bestResultList);
215        }
216
217        private void ProcessResultList(LinkedList<KeySearcher.ValueKey> bestResultList)
218        {
219            quickWatch.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
220            {
221
222                var enc = Encoding.Default;
223                LinkedListNode<KeySearcher.ValueKey> linkedListNode;
224                status.TopList.Clear();
225                linkedListNode = bestResultList.First;
226
227                int i = 0;
228                while (linkedListNode != null && i < 10)
229                {
230                    i++;
231
232                    var entry = new ResultEntry();
233                    entry.Ranking = i.ToString();
234                    entry.Value = Math.Round(linkedListNode.Value.value, 2).ToString();
235                    entry.Key = linkedListNode.Value.key;
236                    var plainText = enc.GetString(linkedListNode.Value.decryption);
237
238                    const string replaceWith = "";
239                    plainText = plainText.Replace("\r\n", replaceWith).Replace("\n", replaceWith).Replace("\r", replaceWith);
240                    if (plainText.Length > 30)
241                        plainText = plainText.Substring(0, 30) + "...";
242
243                    entry.Text = plainText;
244/*                    //-------
245                    entry.User = linkedListNode.Value.user;
246                    entry.Time = linkedListNode.Value.time;
247                    entry.Maschid = linkedListNode.Value.maschid;
248                    entry.Maschname = linkedListNode.Value.maschname;
249*/                    //-------
250
251//--------------------------------------
252                    entry.User = "Unknown";
253                    entry.Time = DateTime.MinValue;
254                    entry.Maschid = 666;
255                    entry.Maschname = "Devil";
256//--------------------------------------
257
258                    status.TopList.Add(entry);
259                    linkedListNode = linkedListNode.Next;
260                }
261            }, null);
262        }
263    }
264}
Note: See TracBrowser for help on using the repository browser.