Free cookie consent management tool by TermsFeed Policy Generator

source: branches/Benchmarking/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Dhrystone.cs @ 6920

Last change on this file since 6920 was 6920, checked in by ascheibe, 13 years ago

#1659 added benchmarking algorithms

File size: 10.9 KB
Line 
1using System;
2using System.Diagnostics;
3using System.Threading;
4using System.Threading.Tasks;
5using HeuristicLab.Common;
6using HeuristicLab.Core;
7using HeuristicLab.Data;
8using HeuristicLab.Optimization;
9using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
10
11namespace HeuristicLab.Algorithms.Benchmarks {
12  [Item("Dhrystone Algorithm", "A Dhrystone benchmark algorithm.")]
13  [Creatable("Benchmarks")]
14  [StorableClass]
15  public class Dhrystone : Algorithm {
16    private DateTime lastUpdateTime;
17
18    [Storable]
19    private ResultCollection results;
20
21    #region Benchmark Fields
22
23    private const int Ident_1 = 0;
24    private const int Ident_2 = 1;
25    private const int Ident_3 = 2;
26    private const int Ident_4 = 3;
27    private const int Ident_5 = 4;
28
29    private Record_Type Record_Glob;
30    private Record_Type Next_Record_Glob;
31
32    private int Int_Glob;
33    private Boolean Bool_Glob;
34
35    private char Char_Glob_1;
36    private char Char_Glob_2;
37
38    private int[] Array_Glob_1 = new int[128];
39    private int[][] Array_Glob_2 = new int[128][];
40
41    private Record_Type First_Record = new Record_Type();
42    private Record_Type Second_Record = new Record_Type();
43
44    private long Number_Of_Runs = 10000000;
45
46    #endregion
47
48    #region Properties
49
50    public override ResultCollection Results {
51      get { return results; }
52    }
53
54    #endregion
55
56    #region Costructors
57
58    public Dhrystone()
59      : base() {
60      results = new ResultCollection();
61    }
62
63    private Dhrystone(Dhrystone original, Cloner cloner)
64      : base(original, cloner) {
65      results = new ResultCollection();
66    }
67
68    #endregion
69
70    public override IDeepCloneable Clone(Cloner cloner) {
71      return new Dhrystone(this, cloner);
72    }
73
74    public override void Prepare() {
75      results.Clear();
76      OnPrepared();
77    }
78
79    public override void Start() {
80      var cancellationTokenSource = new CancellationTokenSource();
81      OnStarted();
82      Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token);
83      task.ContinueWith(t => {
84        try {
85          t.Wait();
86        }
87        catch (AggregateException ex) {
88          try {
89            ex.Flatten().Handle(x => x is OperationCanceledException);
90          }
91          catch (AggregateException remaining) {
92            if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
93            else OnExceptionOccurred(remaining);
94          }
95        }
96        cancellationTokenSource.Dispose();
97        cancellationTokenSource = null;
98        OnStopped();
99      });
100    }
101
102    private void Run(object state) {
103      CancellationToken cancellationToken = (CancellationToken)state;
104      lastUpdateTime = DateTime.Now;
105      System.Timers.Timer timer = new System.Timers.Timer(250);
106      timer.AutoReset = true;
107      timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
108      timer.Start();
109      try {
110        RunBenchmark();
111      }
112      finally {
113        timer.Elapsed -= new System.Timers.ElapsedEventHandler(timer_Elapsed);
114        timer.Stop();
115        ExecutionTime += DateTime.Now - lastUpdateTime;
116      }
117
118      cancellationToken.ThrowIfCancellationRequested();
119    }
120
121    private void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) {
122      System.Timers.Timer timer = (System.Timers.Timer)sender;
123      timer.Enabled = false;
124      DateTime now = DateTime.Now;
125      ExecutionTime += now - lastUpdateTime;
126      lastUpdateTime = now;
127      timer.Enabled = true;
128    }
129
130    #region Dhrystone Benchmark
131
132    private void RunBenchmark() {
133      int Int_Loc_1;
134      int Int_Loc_2;
135      int Int_Loc_3;
136
137      int[] Int_Loc_1_Ref = new int[1];
138      int[] Int_Loc_3_Ref = new int[1];
139
140      char Char_Index;
141      int[] Enum_Loc = new int[1];
142
143      string String_Loc_1;
144      string String_Loc_2;
145
146      long total_time;
147
148      int Run_Index;
149
150      Next_Record_Glob = Second_Record;
151      Record_Glob = First_Record;
152
153      Record_Glob.Record_Comp = Next_Record_Glob;
154      Record_Glob.Discr = Ident_1;
155      Record_Glob.Enum_Comp = Ident_3;
156      Record_Glob.Int_Comp = 40;
157      Record_Glob.String_Comp = "DHRYSTONE PROGRAM, SOME STRING";
158      String_Loc_1 = "DHRYSTONE PROGRAM, 1'ST STRING";
159
160      for (int i = 0; i < 128; i++) {
161        Array_Glob_2[i] = new int[128];
162      }
163
164      //System.Console.WriteLine("Execution start, " + Number_Of_Runs + " runs through Dhrystone");
165      Stopwatch sw = new Stopwatch();
166      sw.Start();
167
168
169      for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index) {
170        Proc_5();
171        Proc_4();
172
173        Int_Loc_1 = 2;
174        Int_Loc_2 = 3;
175
176        String_Loc_2 = "DHRYSTONE PROGRAM, 2'ND STRING";
177
178        Enum_Loc[0] = Ident_2;
179        Bool_Glob = !Func_2(String_Loc_1, String_Loc_2);
180
181        while (Int_Loc_1 < Int_Loc_2) {
182          Int_Loc_3_Ref[0] = 5 * Int_Loc_1 - Int_Loc_2;
183          Proc_7(Int_Loc_1, Int_Loc_2, Int_Loc_3_Ref);
184          Int_Loc_1 += 1;
185        }
186
187        Int_Loc_3 = Int_Loc_3_Ref[0];
188        Proc_8(Array_Glob_1, Array_Glob_2, Int_Loc_1, Int_Loc_3);
189        Proc_1(Record_Glob);
190
191        for (Char_Index = 'A'; Char_Index <= Char_Glob_2; ++Char_Index) {
192          if (Enum_Loc[0] == Func_1(Char_Index, 'C'))
193            Proc_6(Ident_1, Enum_Loc);
194        }
195
196        Int_Loc_3 = Int_Loc_2 * Int_Loc_1;
197        Int_Loc_2 = Int_Loc_3 / Int_Loc_1;
198        Int_Loc_2 = 7 * (Int_Loc_3 - Int_Loc_2) - Int_Loc_1;
199
200        Int_Loc_1_Ref[0] = Int_Loc_1;
201        Proc_2(Int_Loc_1_Ref);
202        Int_Loc_1 = Int_Loc_1_Ref[0];
203      }
204
205      sw.Stop();
206      total_time = sw.ElapsedMilliseconds;
207      //System.Console.WriteLine("total time: {0} ms", total_time);
208      //System.Console.WriteLine("Result: " + Number_Of_Runs * 1000 / total_time + " dhrystone/ms.");
209
210      Results.Add(new Result("DIPS", new DoubleValue(Number_Of_Runs * 1000 / total_time)));
211    }
212
213    private int Func_1(char Char_Par_1_Val, char Char_Par_2_Val) {
214      char Char_Loc_1;
215      char Char_Loc_2;
216
217      Char_Loc_1 = Char_Par_1_Val;
218      Char_Loc_2 = Char_Loc_1;
219      if (Char_Loc_2 != Char_Par_2_Val)
220        return Ident_1;
221      else
222        return Ident_2;
223    }
224
225    private bool Func_2(string String_Par_1_Ref, string String_Par_2_Ref) {
226      int Int_Loc;
227      char Char_Loc = '\0';
228
229      Int_Loc = 2;
230
231      while (Int_Loc <= 2) {
232        if (Func_1(String_Par_1_Ref[Int_Loc], String_Par_2_Ref[Int_Loc + 1]) == Ident_1) {
233          Char_Loc = 'A';
234          Int_Loc += 1;
235        }
236      }
237      if (Char_Loc >= 'W' && Char_Loc < 'z')
238        Int_Loc = 7;
239      if (Char_Loc == 'X')
240        return true;
241      else {
242        if (String_Par_1_Ref.CompareTo(String_Par_2_Ref) > 0) {
243          Int_Loc += 7;
244          return true;
245        } else
246          return false;
247      }
248    }
249
250    private bool Func_3(int Enum_Par_Val) {
251      int Enum_Loc;
252
253      Enum_Loc = Enum_Par_Val;
254      if (Enum_Loc == Ident_3)
255        return true;
256      else
257        return false;
258    }
259
260    private void Proc_1(Record_Type Pointer_Par_Val) {
261      Record_Type Next_Record = Pointer_Par_Val.Record_Comp;
262
263      Pointer_Par_Val.Record_Comp = Record_Glob;
264
265      Pointer_Par_Val.Int_Comp = 5;
266
267      Next_Record.Int_Comp = Pointer_Par_Val.Int_Comp;
268      Next_Record.Record_Comp = Pointer_Par_Val.Record_Comp;
269      Proc_3(Next_Record.Record_Comp);
270
271      int[] Int_Ref = new int[1];
272
273      if (Next_Record.Discr == Ident_1) {
274        Next_Record.Int_Comp = 6;
275        Int_Ref[0] = Next_Record.Enum_Comp;
276        Proc_6(Pointer_Par_Val.Enum_Comp, Int_Ref);
277        Next_Record.Enum_Comp = Int_Ref[0];
278        Next_Record.Record_Comp = Record_Glob.Record_Comp;
279        Int_Ref[0] = Next_Record.Int_Comp;
280        Proc_7(Next_Record.Int_Comp, 10, Int_Ref);
281        Next_Record.Int_Comp = Int_Ref[0];
282      } else
283        Pointer_Par_Val = Pointer_Par_Val.Record_Comp;
284    }
285
286    private void Proc_2(int[] Int_Par_Ref) {
287      int Int_Loc;
288      int Enum_Loc;
289
290      Int_Loc = Int_Par_Ref[0] + 10;
291      Enum_Loc = 0;
292
293      do
294        if (Char_Glob_1 == 'A') {
295          Int_Loc -= 1;
296          Int_Par_Ref[0] = Int_Loc - Int_Glob;
297          Enum_Loc = Ident_1;
298        }
299      while (Enum_Loc != Ident_1);
300    }
301
302    private void Proc_3(Record_Type Pointer_Par_Ref) {
303      if (Record_Glob != null)
304        Pointer_Par_Ref = Record_Glob.Record_Comp;
305      else
306        Int_Glob = 100;
307
308      int[] Int_Comp_Ref = new int[1];
309      Int_Comp_Ref[0] = Record_Glob.Int_Comp;
310      Proc_7(10, Int_Glob, Int_Comp_Ref);
311      Record_Glob.Int_Comp = Int_Comp_Ref[0];
312    }
313
314    private void Proc_4() {
315      bool Bool_Loc;
316
317      Bool_Loc = Char_Glob_1 == 'A';
318      Bool_Loc = Bool_Loc || Bool_Glob;
319      Char_Glob_2 = 'B';
320    }
321
322    private void Proc_5() {
323      Char_Glob_1 = 'A';
324      Bool_Glob = false;
325    }
326
327    private void Proc_6(int Enum_Par_Val, int[] Enum_Par_Ref) {
328
329      Enum_Par_Ref[0] = Enum_Par_Val;
330
331      if (!Func_3(Enum_Par_Val))
332        Enum_Par_Ref[0] = Ident_4;
333
334      switch (Enum_Par_Val) {
335        case Ident_1:
336          Enum_Par_Ref[0] = Ident_1;
337          break;
338
339        case Ident_2:
340          if (Int_Glob > 100)
341            Enum_Par_Ref[0] = Ident_1;
342          else
343            Enum_Par_Ref[0] = Ident_4;
344          break;
345
346        case Ident_3:
347          Enum_Par_Ref[0] = Ident_2;
348          break;
349
350        case Ident_4:
351          break;
352
353        case Ident_5:
354          Enum_Par_Ref[0] = Ident_3;
355          break;
356      }
357    }
358
359    private void Proc_7(int Int_Par_Val1, int Int_Par_Val2, int[] Int_Par_Ref) {
360      int Int_Loc;
361      Int_Loc = Int_Par_Val1 + 2;
362      Int_Par_Ref[0] = Int_Par_Val2 + Int_Loc;
363    }
364
365    private void Proc_8(int[] Array_Par_1_Ref, int[][] Array_Par_2_Ref, int Int_Par_Val_1, int Int_Par_Val_2) {
366      int Int_Index;
367      int Int_Loc;
368
369      Int_Loc = Int_Par_Val_1 + 5;
370      Array_Par_1_Ref[Int_Loc] = Int_Par_Val_2;
371      Array_Par_1_Ref[Int_Loc + 1] = Array_Par_1_Ref[Int_Loc];
372      Array_Par_1_Ref[Int_Loc + 30] = Int_Loc;
373
374      for (Int_Index = Int_Loc; Int_Index <= Int_Loc + 1; ++Int_Index)
375        Array_Par_2_Ref[Int_Loc][Int_Index] = Int_Loc;
376      Array_Par_2_Ref[Int_Loc][Int_Loc - 1] += 1;
377      Array_Par_2_Ref[Int_Loc + 20][Int_Loc] = Array_Par_1_Ref[Int_Loc];
378      Int_Glob = 5;
379    }
380
381    #endregion
382
383    #region Private Class
384
385    private class Record_Type {
386      public Record_Type Record_Comp;
387      public int Discr;
388      public int Enum_Comp;
389      public int Int_Comp;
390      public string String_Comp;
391      /*
392      public int Enum_Comp_2;
393      public string String_Comp_2;
394      public char Char_Comp_1;
395      public char Char_Comp_2;
396       */
397    }
398
399    #endregion
400  }
401}
Note: See TracBrowser for help on using the repository browser.