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

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

Keysearcher:
Expanded the TopListWindow content (still default values).
(Showing which User/Maschine found a top10-key)

File size: 10.3 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 = "Unknown";
246                    entry.Time = DateTime.MinValue;
247                    entry.Maschid = 666;
248                    entry.Maschname = "Devil";
249                    //-------
250
251                    status.TopList.Add(entry);
252                    linkedListNode = linkedListNode.Next;
253                }
254            }, null);
255        }
256    }
257}
Note: See TracBrowser for help on using the repository browser.