Geekly Articles each Day
📜 ⬆️ ⬇️

.Net: Multithreading Costs

Recently I received a simple task: write a windows service to process user requests. The question of what these requests are and according to what protocol the service works is beyond the scope of this article. Another factor seemed to me more interesting. Is it multi-threaded to do request processing? On the one hand, sequential execution slows down information processing. On the other hand, the costs of creating and launching a stream may not be justified.
So, the initial data: 20 simplest requests per second (1200 requests per minute) at peak time. Test "server": Celeron, 3G, 1GB (70% free).

Single threaded system


First, we write a class base for single-threaded query execution.
using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  1. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  2. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  3. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  5. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  6. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  8. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  9. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  10. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  11. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  13. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  14. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  15. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  16. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  17. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  19. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  20. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  21. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  22. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  23. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  25. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  26. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  27. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  28. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  30. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  32. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  33. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  35. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  36. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  37. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  39. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  40. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  41. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  43. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  44. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  45. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  46. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  47. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  48. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  50. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  51. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  52. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  53. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  54. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  55. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  56. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
  57. using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .
using System; using System.Diagnostics; using System.Threading; namespace TestConsoleApplication { class mockClass { private readonly Int32 incriment_speed; private Int32 inc; public mockClass( int incriment_speed) { this .incriment_speed = incriment_speed; inc = 0; } public Int32 incriment() { Thread.Sleep(incriment_speed); return inc++; } public Int32 getIncriment() { return inc; } } class TestConsoleApplication { static void Main( string [] args) { if (args.Length<1) return ; Int32 mockSpeed = 0; if (! Int32 .TryParse(args[0], out mockSpeed)) return ; var mock = new mockClass(mockSpeed); int beginTick = Environment.TickCount; for ( int j = 0; j < 1200; j++) { mock.incriment(); } int endTick = Environment.TickCount; var performance = new PerformanceCounter( "Process" , "Private Bytes" , Process.GetCurrentProcess().ProcessName); Console .WriteLine(mock.getIncriment()); Console .WriteLine( "tick: {0}" , endTick - beginTick); Console .WriteLine( "memory: {0:N0}K" , (performance.RawValue/1024)); Console .ReadLine(); } } } * This source code was highlighted with Source Code Highlighter .

Run the program with several parameters for delaying the request: 2, 5, 10
2fiveten
tickmemorytickmemorytickmemory
368810 792K728110 780K1312510 792K

As you can see, the memory practically does not suffer, and the time is approximately equal to (mockSpeed ​​+ 1) * 1200. An extra millisecond will be written off for overhead.

Multithreaded system


Let's rewrite the program for working with multithreading, optimize it and check the results:
  1. using System;
  2. using System.Diagnostics;
  3. using System.Threading;
  5. namespace TestConsoleApplication
  6. {
  8. class mockClass
  9. {
  10. private readonly Int32 incriment_speed;
  11. private Int32 inc;
  13. public mockClass ( int incriment_speed)
  14. {
  15. this .incriment_speed = incriment_speed;
  16. inc = 0;
  17. }
  19. public Int32 incriment ()
  20. {
  21. Thread.Sleep (incriment_speed);
  22. return inc ++;
  23. }
  25. public Int32 getIncriment ()
  26. {
  27. return inc;
  28. }
  30. }
  32. class TestConsoleApplication
  33. {
  34. private static mockClass mock = null ;
  36. static void threadmethod ()
  37. {
  38. lock (mock)
  39. {
  40. mock.incriment ();
  41. }
  42. }
  44. static void Main ( string [] args)
  45. {
  46. if (args.Length <1) return ;
  48. Int32 mockSpeed ​​= 0;
  49. if (! Int32 .TryParse (args [0], out mockSpeed)) return ;
  50. mock = new mockClass (mockSpeed);
  52. var performance = new PerformanceCounter ( "Process" , "Private Bytes" , Process.GetCurrentProcess (). ProcessName);
  53. long performance_RawValue = 0;
  54. int beginTick = Environment.TickCount;
  55. lock (mock)
  56. {
  57. for ( int j = 0; j <1200; j ++)
  58. {
  59. var trd = new thread (threadmethod, 65536); // select 1 page per stack
  60. trd.Start ();
  61. }
  62. performance_RawValue = performance.RawValue;
  63. }
  64. int end1Tick = Environment.TickCount;
  65. while (mock.getIncriment () <1200)
  66. {
  67. Thread.Sleep (2);
  68. }
  69. int end2Tick = Environment.TickCount;
  71. Console .WriteLine ( "starttick: {0}" , end1Tick - beginTick);
  72. Console .WriteLine ( "alltick: {0}" , end2Tick - beginTick);
  73. Console .WriteLine ( "memory: {0: N0} K" , (performance_RawValue / 1024));
  74. Console .ReadLine ();
  75. }
  76. }
  77. }
* This source code was highlighted with Source Code Highlighter .


-2fiveten
-start tickall tickmemorystart tickall tickmemorystart tickall tickmemory
Single threaded-368810 792K-728110 780K-1312510 792K
Multithreaded6564234323 508K6257719323 508K75013735323 508K

When testing the performance of multithreading, a new value of the start time of processes appeared. It is this value that the total duration of the program runs. The approximate process start is 0.5 millisecond. We also see a significantly increased amount of used memory that is spent on the stack of the threads being run.
')

Results


Select all compared values ​​in the table.
-Single threadedMultithreaded
Total timeThe total time of the main thread depends on the execution time of all requests.The time of the main thread depends only on the number of requests.
Total CPU TimeLow parasitic loadsParasitic loads 2 times higher
MemoryLow memory queries, independent of the number of requestsEach request consumes at least 256KB of memory per thread stack.


Such a “student laboratory work” came out in the study of this issue. Please do not throw stones :)

Source: https://habr.com/ru/post/58931/

More articles:


All Articles