1 | using System.Threading.Tasks;
|
---|
2 |
|
---|
3 | namespace TestPooling {
|
---|
4 | using System;
|
---|
5 | using System.Collections.Generic;
|
---|
6 | using System.Diagnostics;
|
---|
7 | using System.Linq;
|
---|
8 | using System.Text;
|
---|
9 | using System.Threading;
|
---|
10 | using DirtyList;
|
---|
11 | using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
|
---|
12 | using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
|
---|
13 | using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
|
---|
14 | using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
|
---|
15 | using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
|
---|
16 | using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
|
---|
17 | using HeuristicLab.Problems.ProgramSynthesis.Push.Parser;
|
---|
18 | using HeuristicLab.Problems.ProgramSynthesis.Push.Simplifier;
|
---|
19 | using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
|
---|
20 | using HeuristicLab.Random;
|
---|
21 |
|
---|
22 | class Program {
|
---|
23 | private const int PartitionSize = 512;
|
---|
24 | private const int ExampleCount = 200;
|
---|
25 | private const int InstanceCount = 1024;
|
---|
26 | private const int PopulationCount = 1000;
|
---|
27 |
|
---|
28 | private static int TotalInstanceCount => PopulationCount * InstanceCount * ExampleCount;
|
---|
29 |
|
---|
30 | static void Main(string[] args) {
|
---|
31 | // object pooling
|
---|
32 | //Test1();
|
---|
33 | Test1_2();
|
---|
34 | //Test3();
|
---|
35 |
|
---|
36 | //TestCollectionPooling();
|
---|
37 |
|
---|
38 | //DirtyListTest();
|
---|
39 |
|
---|
40 | //TestAddRangeNConcat();
|
---|
41 |
|
---|
42 | //TestStacks();
|
---|
43 |
|
---|
44 | //SimpleTest();
|
---|
45 | //Stepwise().Wait();
|
---|
46 | //PerformanceTestInterpreter();
|
---|
47 | //PerformanceParallelTestInterpreter();
|
---|
48 | //PerformanceTestLinearCodeGenerator();
|
---|
49 | //TestRobustness();
|
---|
50 | //TestPool();
|
---|
51 | //TestPoolPerformance();
|
---|
52 | //TestSimplifier();
|
---|
53 | //FlagsTest();
|
---|
54 | //TestExpressionDependencies();
|
---|
55 | //TestSplitLogic();
|
---|
56 | //TestStringBuilder();
|
---|
57 | //TestRandomReset();
|
---|
58 |
|
---|
59 | //TestRandomBiased(0, 4, 0.01);
|
---|
60 | //TestRandomBiased(0, 4, 0.25);
|
---|
61 | //TestRandomBiased(0, 4, 0.5);
|
---|
62 | //TestRandomBiased(0, 4, 1);
|
---|
63 | //TestRandomBiased(0, 4, 2);
|
---|
64 | //TestRandomBiased(0, 4, 3);
|
---|
65 | //TestRandomBiased(0, 4, 4);
|
---|
66 |
|
---|
67 |
|
---|
68 | Console.WriteLine("\nPress any key to continue...");
|
---|
69 | Console.ReadKey(false);
|
---|
70 | }
|
---|
71 |
|
---|
72 | private static void TestRandomBiased(int min, int max, double bias) {
|
---|
73 | var random = new MersenneTwister();
|
---|
74 | var total = 100000;
|
---|
75 |
|
---|
76 | var distribution = Enumerable
|
---|
77 | .Range(0, total)
|
---|
78 | .Select(_ => random.NextBiased(min, max, bias))
|
---|
79 | .GroupBy(x => x)
|
---|
80 | .OrderBy(g => g.Key)
|
---|
81 | .ToDictionary(g => g.Key, g => g.Count() / (double)total * 100);
|
---|
82 |
|
---|
83 | Console.WriteLine($@"{min}|{max}|{bias}");
|
---|
84 |
|
---|
85 | foreach (var entry in distribution) {
|
---|
86 | Console.WriteLine($@"{entry.Key}: {entry.Value}");
|
---|
87 | }
|
---|
88 |
|
---|
89 | Console.WriteLine();
|
---|
90 | }
|
---|
91 |
|
---|
92 | private static void TestStringBuilder() {
|
---|
93 | var sb = new StringBuilder();
|
---|
94 | sb.Append("test");
|
---|
95 |
|
---|
96 | var s1 = sb.ToString();
|
---|
97 | var s2 = sb.ToString();
|
---|
98 |
|
---|
99 | // false
|
---|
100 | var equal = ReferenceEquals(s1, s2);
|
---|
101 | }
|
---|
102 |
|
---|
103 | private static void TestRandomReset() {
|
---|
104 | var random = new MersenneTwister(1000);
|
---|
105 |
|
---|
106 | var x = random.Next();
|
---|
107 | random.Reset();
|
---|
108 | var y = random.Next();
|
---|
109 |
|
---|
110 | if (x != y) {
|
---|
111 | throw new InvalidOperationException();
|
---|
112 | }
|
---|
113 | }
|
---|
114 |
|
---|
115 | private static void TestSplitLogic() {
|
---|
116 | var sw = new Stopwatch();
|
---|
117 | var iMax = 100000000u;
|
---|
118 | var repeats = 10;
|
---|
119 | var or = new BooleanOrExpression();
|
---|
120 | var and = new BooleanAndExpression();
|
---|
121 | var ors = new Expression[iMax];
|
---|
122 | var ands = new Expression[iMax];
|
---|
123 | var booleans = new bool[iMax];
|
---|
124 |
|
---|
125 | for (var i = 0u; i < iMax; i++) {
|
---|
126 | ors[i] = or;
|
---|
127 | ands[i] = and;
|
---|
128 | booleans[i] = i % 2 == 0;
|
---|
129 | }
|
---|
130 |
|
---|
131 | var orsProgram = new PushProgram(ors);
|
---|
132 | var andsProgram = new PushProgram(ands);
|
---|
133 |
|
---|
134 | using (var interpreter = new PushInterpreter()) {
|
---|
135 | for (var i = 0u; i < repeats; i++) {
|
---|
136 | interpreter.BooleanStack.Push(booleans);
|
---|
137 |
|
---|
138 | sw.Start();
|
---|
139 | interpreter.Run(orsProgram);
|
---|
140 | sw.Stop();
|
---|
141 | interpreter.Reset();
|
---|
142 | }
|
---|
143 |
|
---|
144 | Console.WriteLine("ors:\t" + sw.ElapsedTicks / repeats + " - " + sw.ElapsedMilliseconds);
|
---|
145 |
|
---|
146 | sw.Reset();
|
---|
147 | interpreter.Reset();
|
---|
148 |
|
---|
149 | for (var i = 0u; i < repeats; i++) {
|
---|
150 | interpreter.BooleanStack.Push(booleans);
|
---|
151 |
|
---|
152 | sw.Start();
|
---|
153 | interpreter.Run(andsProgram);
|
---|
154 | sw.Stop();
|
---|
155 | interpreter.Reset();
|
---|
156 | }
|
---|
157 |
|
---|
158 | Console.WriteLine("ands:\t" + sw.ElapsedTicks / repeats + " - " + sw.ElapsedMilliseconds);
|
---|
159 |
|
---|
160 | sw.Reset();
|
---|
161 | interpreter.Reset();
|
---|
162 |
|
---|
163 | for (var i = 0u; i < repeats; i++) {
|
---|
164 | interpreter.BooleanStack.Push(booleans);
|
---|
165 |
|
---|
166 | sw.Start();
|
---|
167 | interpreter.Run(orsProgram);
|
---|
168 | sw.Stop();
|
---|
169 | interpreter.Reset();
|
---|
170 | }
|
---|
171 |
|
---|
172 | Console.WriteLine("ors:\t" + sw.ElapsedTicks / repeats + " - " + sw.ElapsedMilliseconds);
|
---|
173 |
|
---|
174 | sw.Reset();
|
---|
175 | interpreter.Reset();
|
---|
176 |
|
---|
177 | for (var i = 0u; i < repeats; i++) {
|
---|
178 | interpreter.BooleanStack.Push(booleans);
|
---|
179 |
|
---|
180 | sw.Start();
|
---|
181 | interpreter.Run(andsProgram);
|
---|
182 | sw.Stop();
|
---|
183 | interpreter.Reset();
|
---|
184 | }
|
---|
185 |
|
---|
186 | Console.WriteLine("ands:\t" + sw.ElapsedTicks / repeats + " - " + sw.ElapsedMilliseconds);
|
---|
187 | }
|
---|
188 | }
|
---|
189 |
|
---|
190 | private static void TestExpressionDependencies() {
|
---|
191 | var enabledExpressions = ExpressionTable.GetExpressionsByStackTypes(StackTypes.Boolean | StackTypes.Integer);
|
---|
192 | }
|
---|
193 |
|
---|
194 | private static void FlagsTest() {
|
---|
195 | var types = StackTypes.Boolean | StackTypes.Char | StackTypes.Integer;
|
---|
196 |
|
---|
197 | StackTypes test1 = (StackTypes)(StackTypes.Boolean - types);
|
---|
198 | StackTypes test2 = (StackTypes)((StackTypes.Boolean | StackTypes.Float) - types);
|
---|
199 | StackTypes test3 = ((StackTypes.Boolean | StackTypes.Float) & types);
|
---|
200 | StackTypes test4 = ((StackTypes.Boolean | StackTypes.Float) ^ types);
|
---|
201 | StackTypes test5 = ((StackTypes.Boolean | StackTypes.Float) | types);
|
---|
202 | StackTypes test6 = (StackTypes.Boolean | StackTypes.Float) & ~types;
|
---|
203 | StackTypes test7 = StackTypes.Boolean & ~types;
|
---|
204 | }
|
---|
205 |
|
---|
206 | private static void TestStacks() {
|
---|
207 | var sw = new Stopwatch();
|
---|
208 | var stack = new DirtyList.PushStack<int>();
|
---|
209 | var stack2 = new PushStack2<int>();
|
---|
210 | var stack3 = new PushStack3<int>();
|
---|
211 | var listC = new List<int>(1000);
|
---|
212 | var count = 200000;
|
---|
213 | var repeats = 10;
|
---|
214 |
|
---|
215 | for (var i = 0; i < 100; i++) {
|
---|
216 | listC.Add(i);
|
---|
217 | }
|
---|
218 |
|
---|
219 | sw.Start();
|
---|
220 | for (var j = 0; j < repeats; j++) {
|
---|
221 | stack.Clear();
|
---|
222 |
|
---|
223 | for (int i = 0; i < count; i++) {
|
---|
224 | stack.Push(listC);
|
---|
225 | }
|
---|
226 | }
|
---|
227 | sw.Stop();
|
---|
228 |
|
---|
229 | Console.WriteLine("{0}", sw.ElapsedMilliseconds / repeats);
|
---|
230 |
|
---|
231 | sw.Restart();
|
---|
232 | for (var j = 0; j < repeats; j++) {
|
---|
233 | stack2.Clear();
|
---|
234 |
|
---|
235 | for (int i = 0; i < count; i++) {
|
---|
236 | stack2.PushRange(listC);
|
---|
237 | }
|
---|
238 | }
|
---|
239 | sw.Stop();
|
---|
240 |
|
---|
241 | Console.WriteLine("{0}", sw.ElapsedMilliseconds / repeats);
|
---|
242 |
|
---|
243 | sw.Restart();
|
---|
244 | for (var j = 0; j < repeats; j++) {
|
---|
245 | stack3.Clear();
|
---|
246 |
|
---|
247 | for (int i = 0; i < count; i++) {
|
---|
248 | stack3.PushRange(listC);
|
---|
249 | }
|
---|
250 | }
|
---|
251 | sw.Stop();
|
---|
252 |
|
---|
253 | Console.WriteLine("{0}", sw.ElapsedMilliseconds / repeats);
|
---|
254 |
|
---|
255 | sw.Restart();
|
---|
256 | for (int i = 0; i < count * listC.Count; i++) {
|
---|
257 | stack.Pop();
|
---|
258 | }
|
---|
259 |
|
---|
260 | Console.WriteLine("{0}", sw.ElapsedMilliseconds);
|
---|
261 |
|
---|
262 | sw.Restart();
|
---|
263 | for (int i = 0; i < count * listC.Count; i++) {
|
---|
264 | stack2.Pop();
|
---|
265 | }
|
---|
266 |
|
---|
267 | Console.WriteLine("{0}", sw.ElapsedMilliseconds);
|
---|
268 |
|
---|
269 |
|
---|
270 | }
|
---|
271 |
|
---|
272 | private static void TestAddRangeNConcat() {
|
---|
273 | var sw = new Stopwatch();
|
---|
274 | var count = 10000;
|
---|
275 | var listA = new List<int>();
|
---|
276 | var listB = new List<int>();
|
---|
277 | var listC = new List<int>(1000);
|
---|
278 |
|
---|
279 | for (var i = 0; i < 1000; i++) {
|
---|
280 | listC.Add(i);
|
---|
281 | }
|
---|
282 |
|
---|
283 | sw.Start();
|
---|
284 | for (int i = 0; i < count; i++) {
|
---|
285 | listA.AddRange(listC);
|
---|
286 | }
|
---|
287 | sw.Stop();
|
---|
288 |
|
---|
289 | Console.WriteLine("{0}", sw.ElapsedMilliseconds);
|
---|
290 |
|
---|
291 | sw.Restart();
|
---|
292 | for (int i = 0; i < count; i++) {
|
---|
293 | listB = listB.Concat(listC).ToList();
|
---|
294 | }
|
---|
295 | sw.Stop();
|
---|
296 |
|
---|
297 | Console.WriteLine("{0}", sw.ElapsedMilliseconds);
|
---|
298 |
|
---|
299 | }
|
---|
300 |
|
---|
301 | private static void DirtyListTest() {
|
---|
302 | var sw = new Stopwatch();
|
---|
303 | var provider = new ManagedPoolProvider<Person>(100, () => new Person());
|
---|
304 | var provider2 = new ManagedPoolProvider<Person>(100, () => new Person());
|
---|
305 | var dl = new DirtyList<Person>();
|
---|
306 | var l = new List<Person>();
|
---|
307 |
|
---|
308 | sw.Start();
|
---|
309 | for (var i = 0; i < 30000000; i++) {
|
---|
310 | using (var pool = provider.CreatePool()) {
|
---|
311 | for (var j = 0; j < 2; j++) {
|
---|
312 | var person = pool.Get();
|
---|
313 | person.Age = i + j;
|
---|
314 | person.Name = (i + j).ToString();
|
---|
315 |
|
---|
316 | dl.Add(person);
|
---|
317 | }
|
---|
318 | }
|
---|
319 |
|
---|
320 | dl.Clear();
|
---|
321 | }
|
---|
322 | sw.Stop();
|
---|
323 |
|
---|
324 | Console.WriteLine("DirtyList: {0}", sw.Elapsed.TotalSeconds);
|
---|
325 |
|
---|
326 | sw.Restart();
|
---|
327 | for (var i = 0; i < 30000000; i++) {
|
---|
328 | using (var pool = provider2.CreatePool()) {
|
---|
329 | for (var j = 0; j < 2; j++) {
|
---|
330 | var person = pool.Get();
|
---|
331 | person.Age = i + j;
|
---|
332 | person.Name = (i + j).ToString();
|
---|
333 |
|
---|
334 | l.Add(person);
|
---|
335 | }
|
---|
336 | }
|
---|
337 |
|
---|
338 | l.Clear();
|
---|
339 | }
|
---|
340 | sw.Stop();
|
---|
341 |
|
---|
342 | Console.WriteLine("List: {0}", sw.Elapsed.TotalSeconds);
|
---|
343 | }
|
---|
344 |
|
---|
345 | private static void TestCollectionPooling() {
|
---|
346 | var sw = new Stopwatch();
|
---|
347 | sw.Start();
|
---|
348 |
|
---|
349 | var provider = new ManagedPoolProvider<PooledList<Person>>(PartitionSize, () => new PooledList<Person>());
|
---|
350 |
|
---|
351 | Parallel.For(0, PopulationCount, pc => {
|
---|
352 | for (var e = 0; e < ExampleCount; e++) {
|
---|
353 | using (var pool = provider.CreatePool()) {
|
---|
354 | var list = pool.Get();
|
---|
355 |
|
---|
356 | for (var i = 0; i < InstanceCount; i++)
|
---|
357 | list.Add(new Person {
|
---|
358 | Age = pc + e + i,
|
---|
359 | Name = string.Format("{0} - {1} - {2}", pc, e, i)
|
---|
360 | });
|
---|
361 | }
|
---|
362 | }
|
---|
363 | });
|
---|
364 | sw.Stop();
|
---|
365 |
|
---|
366 | Console.WriteLine("Collection Pooling - Duration: {0} - {1} for {2}/{3} instances", sw.ElapsedTicks, sw.Elapsed.TotalSeconds, provider.InstanceCount, TotalInstanceCount);
|
---|
367 | }
|
---|
368 |
|
---|
369 | private static void Test1_2() {
|
---|
370 | var sw = new Stopwatch();
|
---|
371 | sw.Start();
|
---|
372 |
|
---|
373 | var provider = new ManagedPoolProvider<Person>(PartitionSize, () => new Person());
|
---|
374 |
|
---|
375 | Parallel.For(0, PopulationCount, pc => {
|
---|
376 | for (var e = 0; e < ExampleCount; e++) {
|
---|
377 | using (var pool = provider.CreatePool()) {
|
---|
378 | for (var i = 0; i < InstanceCount; i++) {
|
---|
379 | var person = pool.Get();
|
---|
380 | person.Age = pc + e + i;
|
---|
381 | person.Name = string.Format("{0} - {1} - {2}", pc, e, i);
|
---|
382 | }
|
---|
383 | }
|
---|
384 | }
|
---|
385 | });
|
---|
386 | sw.Stop();
|
---|
387 |
|
---|
388 | Console.WriteLine("1_2 - Duration: {0} - {1} for {2}/{3} instances", sw.ElapsedTicks, sw.Elapsed.TotalSeconds, provider.InstanceCount, TotalInstanceCount);
|
---|
389 | }
|
---|
390 |
|
---|
391 | private static void Test3() {
|
---|
392 | var count = 0;
|
---|
393 | var sw = new Stopwatch();
|
---|
394 |
|
---|
395 | sw.Start();
|
---|
396 | Parallel.For(0, PopulationCount, pc => {
|
---|
397 | for (var e = 0; e < ExampleCount; e++) {
|
---|
398 | var list = new Person[InstanceCount];
|
---|
399 | for (var i = 0; i < InstanceCount; i++) {
|
---|
400 | list[i] = new Person {
|
---|
401 | Age = pc + e + i,
|
---|
402 | Name = string.Format("{0} - {1} - {2}", pc, e, i)
|
---|
403 | };
|
---|
404 | }
|
---|
405 |
|
---|
406 | Interlocked.Add(ref count, list.Length);
|
---|
407 | }
|
---|
408 | });
|
---|
409 | sw.Stop();
|
---|
410 |
|
---|
411 | Console.WriteLine("3 - Duration: {0} - {1}", sw.ElapsedTicks, sw.Elapsed.TotalSeconds);
|
---|
412 | Console.WriteLine("PartitionSize: {0}", count);
|
---|
413 | }
|
---|
414 |
|
---|
415 | private static void Test2() {
|
---|
416 | var pool = new ObjectPool<Person>(() => new Person(), 2048);
|
---|
417 |
|
---|
418 | Parallel.For(0, 10000, i => {
|
---|
419 | for (var j = 0; j < 3000; j++) {
|
---|
420 | var person = pool.Allocate();
|
---|
421 | person.Age = i + j;
|
---|
422 | person.Name = string.Format("{0} - {1}", i, j);
|
---|
423 | }
|
---|
424 |
|
---|
425 | //pool.Free()
|
---|
426 | });
|
---|
427 | }
|
---|
428 |
|
---|
429 | static void SimpleTest() {
|
---|
430 | var interpreter = new PushInterpreter();
|
---|
431 |
|
---|
432 | interpreter.Run("5 INTEGER.DUP INTEGER.+");
|
---|
433 |
|
---|
434 | interpreter.PrintStacks();
|
---|
435 | }
|
---|
436 |
|
---|
437 | static async Task Stepwise() {
|
---|
438 | var interpreter = new PushInterpreter();
|
---|
439 |
|
---|
440 | interpreter.Run("( 0 2 CODE.QUOTE ( 1 INTEGER.+ 0 3 CODE.QUOTE ( 1 INTEGER.+ INTEGER.* ) CODE.DO*RANGE INTEGER.+ ) CODE.DO*RANGE )");
|
---|
441 |
|
---|
442 | while (!interpreter.IsCompleted) {
|
---|
443 | Console.Clear();
|
---|
444 | interpreter.PrintStacks();
|
---|
445 | interpreter.Step();
|
---|
446 |
|
---|
447 | var input = Console.ReadKey();
|
---|
448 | if (input.Key == ConsoleKey.Escape) {
|
---|
449 | break;
|
---|
450 | } else if (input.Key == ConsoleKey.Spacebar) {
|
---|
451 | await interpreter.ResumeAsync();
|
---|
452 | }
|
---|
453 | }
|
---|
454 |
|
---|
455 | Console.Clear();
|
---|
456 | interpreter.PrintStacks();
|
---|
457 | }
|
---|
458 |
|
---|
459 | static void PerformanceTestInterpreter() {
|
---|
460 | var program = PushParser.Parse("( 5 INTEGER.DUP INTEGER.+ )");
|
---|
461 |
|
---|
462 | var interpreter = new PushInterpreter();
|
---|
463 | var sw = new Stopwatch();
|
---|
464 |
|
---|
465 | sw.Start();
|
---|
466 | for (var i = 0; i < 60000000; i++) {
|
---|
467 | interpreter.Run(program);
|
---|
468 | interpreter.ClearStacks();
|
---|
469 | }
|
---|
470 | sw.Stop();
|
---|
471 |
|
---|
472 | Console.WriteLine(sw.Elapsed);
|
---|
473 | }
|
---|
474 |
|
---|
475 | static void PerformanceParallelTestInterpreter() {
|
---|
476 | var program = PushParser.Parse("( 5 INTEGER.DUP INTEGER.+ )");
|
---|
477 |
|
---|
478 | var sw = new Stopwatch();
|
---|
479 | var iterations = 100;
|
---|
480 | var amount = 600000;
|
---|
481 | var pool = new PushInterpreterPool(iterations, 1024);
|
---|
482 |
|
---|
483 | sw.Start();
|
---|
484 | Parallel.For(0, iterations, i => {
|
---|
485 | using (var interpreter = pool.Create()) {
|
---|
486 | for (var j = 0; j < amount; j++) {
|
---|
487 | interpreter.Run(program);
|
---|
488 | interpreter.ClearStacks();
|
---|
489 | }
|
---|
490 | }
|
---|
491 | });
|
---|
492 | sw.Stop();
|
---|
493 |
|
---|
494 | Console.WriteLine(sw.Elapsed);
|
---|
495 | }
|
---|
496 |
|
---|
497 | static void PerformanceTestRecursiveCodeGenerator() {
|
---|
498 | var sw = new Stopwatch();
|
---|
499 | var random = new FastRandom(1337);
|
---|
500 |
|
---|
501 | sw.Start();
|
---|
502 | var expressions = RecursiveCodeGenerator.RandomCode(60000000, random).ToList();
|
---|
503 | sw.Stop();
|
---|
504 |
|
---|
505 | Console.WriteLine("Generated {0} in {1}", expressions.Count, sw.Elapsed);
|
---|
506 | }
|
---|
507 |
|
---|
508 | static void PerformanceTestLinearCodeGenerator() {
|
---|
509 | var sw = new Stopwatch();
|
---|
510 | var random = new FastRandom(1337);
|
---|
511 | var config = new PushConfiguration();
|
---|
512 |
|
---|
513 | sw.Start();
|
---|
514 | var expressions = LinearCodeGenerator.RandomCode(60000000, null, random, config).ToList();
|
---|
515 | sw.Stop();
|
---|
516 |
|
---|
517 | Console.WriteLine("Generated {0} in {1}", expressions.Count, sw.Elapsed);
|
---|
518 | }
|
---|
519 |
|
---|
520 | static void TestRobustness() {
|
---|
521 | var sw = new Stopwatch();
|
---|
522 | var parallelism = Environment.ProcessorCount;
|
---|
523 | var maxProgramSizeLimit = 1024;
|
---|
524 | var partitionSize = 100000;
|
---|
525 | var execCounters = new long[parallelism];
|
---|
526 |
|
---|
527 | var config = new PushConfiguration {
|
---|
528 | EvalPushLimit = 1024,
|
---|
529 | MaxProgramLength = 1024
|
---|
530 | };
|
---|
531 |
|
---|
532 | config.DisableStack(StackTypes.Exec);
|
---|
533 | config.DisableStack(StackTypes.Code);
|
---|
534 | config.DisableStack(StackTypes.Float);
|
---|
535 |
|
---|
536 | var errors = config.EnabledExpressions.Where(
|
---|
537 | name => {
|
---|
538 | var type = ExpressionTable.NameToTypeTable[name];
|
---|
539 | var attribute = ExpressionTable.TypeToAttributeTable[type];
|
---|
540 |
|
---|
541 | return attribute.StackType == StackTypes.Exec
|
---|
542 | || attribute.AdditionalStackDependencies.HasFlag(StackTypes.Exec)
|
---|
543 | || attribute.StackType == StackTypes.Code
|
---|
544 | || attribute.AdditionalStackDependencies.HasFlag(StackTypes.Code)
|
---|
545 | || attribute.StackType == StackTypes.Float
|
---|
546 | || attribute.AdditionalStackDependencies.HasFlag(StackTypes.Float);
|
---|
547 | });
|
---|
548 |
|
---|
549 | var pool = new PushInterpreterPool(config);
|
---|
550 |
|
---|
551 | sw.Start();
|
---|
552 | Parallel.For(0, parallelism, i => {
|
---|
553 | var random = new FastRandom(1337);
|
---|
554 |
|
---|
555 | using (var interpreter = pool.Create(random)) {
|
---|
556 | for (var j = 0; j < partitionSize; j++) {
|
---|
557 | var program = LinearCodeGenerator.RandomProgram(maxProgramSizeLimit, random, config);
|
---|
558 | interpreter.Run(program);
|
---|
559 |
|
---|
560 | execCounters[i] += interpreter.ExecCounter;
|
---|
561 | interpreter.Reset();
|
---|
562 | }
|
---|
563 | }
|
---|
564 | });
|
---|
565 | sw.Stop();
|
---|
566 |
|
---|
567 | Console.WriteLine("ExecCount: {0}", execCounters.Sum());
|
---|
568 | Console.WriteLine("Duration: {0}", sw.Elapsed);
|
---|
569 | }
|
---|
570 |
|
---|
571 | static void TestPool() {
|
---|
572 | var pool = new PushInterpreterPool();
|
---|
573 | var normal = new PushInterpreter();
|
---|
574 | int id;
|
---|
575 |
|
---|
576 | using (var interpreter = pool.Create()) {
|
---|
577 | interpreter.Run("( 1 2 INTEGER.+ )");
|
---|
578 |
|
---|
579 | id = interpreter.GetHashCode();
|
---|
580 | if (id == normal.GetHashCode()) Console.WriteLine("equal 1");
|
---|
581 | }
|
---|
582 |
|
---|
583 | using (var interpreter = pool.Create())
|
---|
584 | using (var interpreter2 = pool.Create()) {
|
---|
585 | interpreter.Run("( 1 2 INTEGER.+ )");
|
---|
586 | if (id == interpreter.GetHashCode()) Console.WriteLine("equal 2");
|
---|
587 | if (id == interpreter2.GetHashCode()) Console.WriteLine("equal 3");
|
---|
588 | }
|
---|
589 | }
|
---|
590 |
|
---|
591 | static void TestPoolPerformance() {
|
---|
592 | var sw = new Stopwatch();
|
---|
593 | var iterations = 100000000;
|
---|
594 |
|
---|
595 | sw.Start();
|
---|
596 | for (var i = 0; i < iterations; i++) {
|
---|
597 | var interpreter = new PushInterpreter();
|
---|
598 | interpreter.ClearStacks();
|
---|
599 | }
|
---|
600 | sw.Stop();
|
---|
601 |
|
---|
602 | Console.WriteLine(sw.Elapsed);
|
---|
603 |
|
---|
604 | var pool = new PushInterpreterPool();
|
---|
605 | sw.Restart();
|
---|
606 | for (var i = 0; i < iterations; i++) {
|
---|
607 | using (var interpreter = pool.Create()) {
|
---|
608 | interpreter.ClearStacks();
|
---|
609 | }
|
---|
610 | }
|
---|
611 | sw.Stop();
|
---|
612 |
|
---|
613 | Console.WriteLine(sw.Elapsed);
|
---|
614 | }
|
---|
615 |
|
---|
616 | static void TestSimplifier() {
|
---|
617 | var program = PushParser.ParseProgram("( 5 ( INTEGER.DUP FLOAT.+ FLOAT.- ) ( EXEC.DO ( EXEC.IF ) EXEC.Y ) INTEGER.+ )");
|
---|
618 | var pool = new PushInterpreterPool();
|
---|
619 | var random = new FastRandom(1337);
|
---|
620 |
|
---|
621 | var randomProg = LinearCodeGenerator.RandomProgram(4096 * 4, random); // 53
|
---|
622 |
|
---|
623 | Func<PushProgram, double> evaluator = prog => {
|
---|
624 | using (var interpreter = pool.Create(random)) {
|
---|
625 | interpreter.Run(prog);
|
---|
626 | return interpreter.IntegerStack.IsEmpty
|
---|
627 | ? double.MaxValue
|
---|
628 | : Math.Abs(interpreter.IntegerStack.Top - 10);
|
---|
629 | }
|
---|
630 | };
|
---|
631 |
|
---|
632 | var simplerProgram = Simplifier.Simplify(program, pool.PushConfiguration, evaluator);
|
---|
633 |
|
---|
634 | Console.WriteLine(simplerProgram);
|
---|
635 | }
|
---|
636 | }
|
---|
637 |
|
---|
638 | [Serializable]
|
---|
639 | class Person : IPooledObject {
|
---|
640 | public string Name { get; set; }
|
---|
641 | public int Age { get; set; }
|
---|
642 |
|
---|
643 | public void Init() { }
|
---|
644 |
|
---|
645 | public void Reset() {
|
---|
646 | Age = default(int);
|
---|
647 | Name = null;
|
---|
648 | }
|
---|
649 | }
|
---|
650 | }
|
---|