source: trunk/CrypPlugins/KeySearcher/KeySearcherSettings.cs @ 2194

Last change on this file since 2194 was 2194, checked in by Sven Rech, 11 years ago

it should be possible now to use more opencl devices simultaneously (can't test it, because I only have one).

File size: 14.7 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Windows;
4using Cryptool.PluginBase;
5using System.ComponentModel;
6using System.Collections.ObjectModel;
7using KeySearcher.P2P.Storage;
8using OpenCLNet;
9
10namespace KeySearcher
11{
12    public class KeySearcherSettings : ISettings
13    {
14        private readonly KeySearcher keysearcher;
15        private int coresUsed;
16        private const string GroupPeerToPeer = "Peer-to-Peer network";
17        private const string GroupEvaluation = "Evaluation";
18        private const string GroupOpenCL = "OpenCL";
19
20        public class OpenCLDeviceSettings
21        {
22            public string name;
23            public int index;
24            public bool useDevice;
25            public int mode;
26        }
27
28        private List<OpenCLDeviceSettings> deviceSettings = new List<OpenCLDeviceSettings>();
29        public List<OpenCLDeviceSettings> DeviceSettings
30        {
31            get
32            {
33                return deviceSettings;
34            }
35        }
36
37        public event TaskPaneAttributeChangedHandler TaskPaneAttributeChanged;
38
39        public KeySearcherSettings(KeySearcher ks, OpenCLManager oclManager)
40        {
41            keysearcher = ks;
42
43            devicesAvailable.Clear();
44            int c = 0;
45            if (oclManager != null)
46                foreach (var device in oclManager.Context.Devices)
47                {
48                    string deviceName = device.Vendor + ":" + device.Name;
49                    deviceSettings.Add(new OpenCLDeviceSettings() {name = deviceName, index = c, mode = 1, useDevice = false});
50                    devicesAvailable.Add(deviceName);
51                    c++;
52                }
53
54            CoresAvailable.Clear();
55            for (int i = -1; i < Environment.ProcessorCount; i++)
56                CoresAvailable.Add((i + 1).ToString());
57            CoresUsed = Environment.ProcessorCount - 1;
58
59            chunkSize = 21;
60        }
61
62        public void Initialize()
63        {
64            OpenCLGroupVisiblity();
65        }
66
67        private string key;
68        [TaskPane("Key", "Key pattern used to bruteforce", null, 1, false, DisplayLevel.Beginner, ControlType.TextBox)]
69        public String Key
70        {
71            get
72            {
73                return key;
74            }
75            set
76            {
77                key = value;
78                OnPropertyChanged("Key");
79                if (!(keysearcher.Pattern != null && keysearcher.Pattern.testWildcardKey(value)))
80                    keysearcher.GuiLogMessage("Wrong key pattern!", NotificationLevel.Error);
81                HasChanges = true;
82            }
83        }
84
85        [TaskPane("Reset", "Reset Key", null, 2, false, DisplayLevel.Beginner, ControlType.Button)]
86        public void Reset()
87        {
88            Key = keysearcher.Pattern.giveInputPattern();
89        }
90       
91        [TaskPane("CoresUsed", "Choose how many cores should be used", null, 3, false, DisplayLevel.Beginner, ControlType.DynamicComboBox, new string[] { "CoresAvailable" })]
92        public int CoresUsed
93        {
94            get { return this.coresUsed; }
95            set
96            {
97                if (value != this.coresUsed)
98                {
99                    this.coresUsed = value;
100                    OnPropertyChanged("CoresUsed");
101                    HasChanges = true;
102                }
103            }
104        }
105
106        private bool usePeerToPeer;
107        [TaskPane("Use Peer-to-Peer network", "Distributes the operation on available peers by using the built-in peer-to-peer network.", GroupPeerToPeer, 0, false, DisplayLevel.Beginner,
108            ControlType.CheckBox)]
109        public bool UsePeerToPeer
110        {
111            get { return usePeerToPeer; }
112            set
113            {
114                if (value != usePeerToPeer)
115                {
116                    usePeerToPeer = value;
117                    OnPropertyChanged("UsePeerToPeer");
118                    HasChanges = true;
119                }
120            }
121        }
122
123        private bool autoconnectPeerToPeer;
124        [TaskPane("Autoconnect network", "Establish a connection to the network if the workspace is started without the background connection being active.", GroupPeerToPeer, 1, false, DisplayLevel.Beginner,
125            ControlType.CheckBox)]
126        public bool AutoconnectPeerToPeer
127        {
128            get { return autoconnectPeerToPeer; }
129            set
130            {
131                if (value != autoconnectPeerToPeer)
132                {
133                    autoconnectPeerToPeer = value;
134                    OnPropertyChanged("AutoconnectPeerToPeer");
135                    HasChanges = true;
136                }
137            }
138        }
139
140        private bool verbosePeerToPeerDisplay;
141        [TaskPane("Display verbose information", "Display verbose information about network requests in the quick watch.", GroupPeerToPeer, 2, true, DisplayLevel.Beginner,
142            ControlType.CheckBox)]
143        public bool VerbosePeerToPeerDisplay
144        {
145            get { return verbosePeerToPeerDisplay; }
146            set
147            {
148                if (value != verbosePeerToPeerDisplay)
149                {
150                    verbosePeerToPeerDisplay = value;
151                    OnPropertyChanged("VerbosePeerToPeerDisplay");
152                    HasChanges = true;
153                }
154            }
155        }
156
157        private int chunkSize;
158        [TaskPane("Chunk size", "Amount of keys, that will be calculated by one peer at a time. This value is the exponent of the power of two used for the chunk size.", GroupPeerToPeer, 3, false, DisplayLevel.Professional,
159            ControlType.NumericUpDown, ValidationType.RangeInteger, 1, 1000)]
160        public int ChunkSize
161        {
162            get { return chunkSize; }
163            set
164            {
165                if (value != chunkSize)
166                {
167                    chunkSize = value;
168                    OnPropertyChanged("ChunkSize");
169                    HasChanges = true;
170                }
171            }
172        }
173
174        [TaskPane("Copy status key", "Copy status key to clipboard. The key can than be used to upload it together with the job using the P2PEditor.", GroupPeerToPeer, 4, true, DisplayLevel.Professional, ControlType.Button)]
175        public void StatusKeyButton()
176        {
177            if (!keysearcher.IsKeySearcherRunning)
178            {
179                keysearcher.GuiLogMessage("KeySearcher must be running to copy the status key.", NotificationLevel.Error);
180                return;
181            }
182
183            var generator = new StorageKeyGenerator(keysearcher, this);
184            var statusKey = generator.GenerateStatusKey();
185
186            Clipboard.SetDataObject(statusKey, true);
187            keysearcher.GuiLogMessage("Status key '" + statusKey + "' has been copied to clipboard.",
188                                      NotificationLevel.Info);
189        }
190
191        private string evaluationHost;
192        [TaskPane("Host", "Database host with evaluation database", GroupEvaluation, 0, false, DisplayLevel.Expert, ControlType.TextBox)]
193        public String EvaluationHost
194        {
195            get
196            {
197                return evaluationHost;
198            }
199            set
200            {
201                if (value != evaluationHost)
202                {
203                    evaluationHost = value;
204                    OnPropertyChanged("EvaluationHost");
205                    HasChanges = true;
206                }
207            }
208        }
209
210        private string evaluationUser;
211        [TaskPane("User", "Username for evaluation database", GroupEvaluation, 1, false, DisplayLevel.Expert, ControlType.TextBox)]
212        public String EvaluationUser
213        {
214            get
215            {
216                return evaluationUser;
217            }
218            set
219            {
220                if (value != evaluationUser)
221                {
222                    evaluationUser = value;
223                    OnPropertyChanged("EvaluationUser");
224                    HasChanges = true;
225                }
226            }
227        }
228
229        private string evaluationPassword;
230        [TaskPane("Password", "Password for evaluation database", GroupEvaluation, 2, false, DisplayLevel.Expert, ControlType.TextBox)]
231        public String EvaluationPassword
232        {
233            get
234            {
235                return evaluationPassword;
236            }
237            set
238            {
239                if (value != evaluationPassword)
240                {
241                    evaluationPassword = value;
242                    OnPropertyChanged("EvaluationPassword");
243                    HasChanges = true;
244                }
245            }
246        }
247
248        private string evaluationDatabase;
249        [TaskPane("Database", "Name of the evaluation database", GroupEvaluation, 3, false, DisplayLevel.Expert, ControlType.TextBox)]
250        public String EvaluationDatabase
251        {
252            get
253            {
254                return evaluationDatabase;
255            }
256            set
257            {
258                if (value != evaluationDatabase)
259                {
260                    evaluationDatabase = value;
261                    OnPropertyChanged("EvaluationDatabase");
262                    HasChanges = true;
263                }
264            }
265        }
266
267        #region OpenCL
268
269        [TaskPane("No OpenCL available", null, GroupOpenCL, 1, false, DisplayLevel.Experienced, ControlType.TextBoxReadOnly)]
270        public string NoOpenCL
271        {
272            get { return "No OpenCL Device available!"; }
273            set {}
274        }
275
276        private void OpenCLGroupVisiblity()
277        {
278            if (TaskPaneAttributeChanged == null)
279                return;
280
281            if (DevicesAvailable.Count == 0)
282            {
283                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Collapsed)));
284                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLMode", Visibility.Collapsed)));
285                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Collapsed)));
286                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("NoOpenCL", Visibility.Visible)));
287            }
288            else
289            {
290                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLDevice", Visibility.Visible)));
291                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("OpenCLMode", Visibility.Visible)));
292                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("UseOpenCL", Visibility.Visible)));
293                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("NoOpenCL", Visibility.Collapsed)));
294            }
295        }
296
297        private int openCLDevice;
298        [TaskPane("OpenCL Device", "Choose the OpenCL device you want to use.", GroupOpenCL, 1, false, DisplayLevel.Experienced, ControlType.DynamicComboBox, new string[] { "DevicesAvailable" })]
299        public int OpenCLDevice
300        {
301            get { return this.openCLDevice; }
302            set
303            {
304                if (value != this.openCLDevice)
305                {
306                    this.openCLDevice = value;
307                    UseOpenCL = deviceSettings[value].useDevice;
308                    OpenCLMode = deviceSettings[value].mode;
309                    OnPropertyChanged("OpenCLDevice");
310                    HasChanges = true;
311                }
312            }
313        }
314
315        [TaskPane("Use selected device", "If checked, the selected OpenCL device is used for bruteforcing.",
316            GroupOpenCL, 2, false, DisplayLevel.Experienced, ControlType.CheckBox)]
317        public bool UseOpenCL
318        {
319            get { return deviceSettings[OpenCLDevice].useDevice; }
320            set
321            {
322                if (value != deviceSettings[OpenCLDevice].useDevice)
323                {
324                    deviceSettings[OpenCLDevice].useDevice = value;
325                    hasChanges = true;
326                    OnPropertyChanged("UseOpenCL");
327                    //DeviceVisibility();
328                }
329            }
330        }
331
332        [TaskPane("OpenCL Mode", "Choose the OpenCL mode you want to use.", GroupOpenCL, 3, false, DisplayLevel.Experienced, ControlType.RadioButton, new string[] { "Low Load", "Normal Load", "High Load (use with caution)" })]
333        public int OpenCLMode
334        {
335            get { return deviceSettings[OpenCLDevice].mode; }
336            set
337            {
338                if (value != deviceSettings[OpenCLDevice].mode)
339                {
340                    deviceSettings[OpenCLDevice].mode = value;
341                    OnPropertyChanged("OpenCLMode");
342                    HasChanges = true;
343                }
344            }
345        }
346
347        private ObservableCollection<string> devicesAvailable = new ObservableCollection<string>();
348        public ObservableCollection<string> DevicesAvailable
349        {
350            get { return devicesAvailable; }
351            set
352            {
353                if (value != devicesAvailable)
354                {
355                    devicesAvailable = value;
356                }
357                OnPropertyChanged("DevicesAvailable");
358            }
359        }
360
361        #endregion
362
363        private ObservableCollection<string> coresAvailable = new ObservableCollection<string>();
364        public ObservableCollection<string> CoresAvailable
365        {
366            get { return coresAvailable; }
367            set
368            {
369                if (value != coresAvailable)
370                {
371                    coresAvailable = value;
372                }
373                OnPropertyChanged("CoresAvailable");
374            }
375        }
376
377        #region ISettings Members
378
379        private bool hasChanges;
380
381        public bool HasChanges
382        {
383            get
384            {
385                return hasChanges;
386            }
387            set
388            {
389                hasChanges = value;
390                OnPropertyChanged("HasChanges");
391            }
392        }
393
394        #endregion
395
396        #region INotifyPropertyChanged Members
397
398        public event PropertyChangedEventHandler PropertyChanged;
399
400        private void OnPropertyChanged(string p)
401        {
402            if (PropertyChanged != null)
403            {
404                PropertyChanged(this, new PropertyChangedEventArgs(p));
405            }
406        }
407
408        #endregion
409    }
410}
Note: See TracBrowser for help on using the repository browser.