public void MeasureIncreasingDoublingLoop() { UT_INIT(); Log.SetVerbosity( new ConsoleLogger(), Verbosity.Verbose, "/" ); Log.MapThreadName( "UnitTest" ); Log.SetDomain( "TickWatch", Scope.Method ); Log.Info( "This test shows quite nicely, how the just in time compiler steps in when we are looping heavily!" ); String testString= "-------------------------------------------------------------------------------------------#"; AString testAString= new AString( testString ); TickWatch ttString= new TickWatch(); TickWatch ttAString= new TickWatch(); for (int run= 4; run < 20; run++ ) { int qtyLoops= (run == 0) ? 0 : (1 << (run -1)); // use String.IndexOf() ttString.Reset(); int nonOptimizableUsedResultValue= 0; for (int i= 0; i < qtyLoops; i++ ) nonOptimizableUsedResultValue+= testString.IndexOf( '#' ); Ticks sSample= ttString.Sample(); // use AString.IndexOf() ttAString.Reset(); for (int i= 0; i < qtyLoops; i++ ) nonOptimizableUsedResultValue+= testAString.IndexOf( '#' ); Ticks aSample= ttAString.Sample(); if ( nonOptimizableUsedResultValue > -1 ) // this is always true, just for the sake that the compiler does not optimize the whole code! Log.Info( Log.Buf()._( "Search loops " ) .Field()._( qtyLoops.ToString() ) .Field( 6 ) ._( ": time needed: " ) .Field()._( (int) sSample.InNanos() ).Field( 8 ) ._( " / " ) .Field()._( (int) aSample.InNanos() ).Field( 8 ) ._( " Ratio String/AString: " ) ._( ((double) sSample.Raw()) / ((double) aSample.Raw()) ) ); } }
/** **************************************************************************************** * Creates a TickWatch as a copy of another TickWatch. * * @param copy The instance to copy value from. ******************************************************************************************/ public TickWatch(TickWatch copy) { ticks.Set(copy.ticks); sum.Set(copy.sum); cntSamples = copy.cntSamples; }
public void Ages() { UT_INIT(); Log.SetVerbosity( new ConsoleLogger(), Verbosity.Verbose, "/" ); Log.MapThreadName( "UnitTest" ); Log.SetDomain( "TickWatch", Scope.Method ); TickWatch tt=new TickWatch(); // minimum time measuring { tt.Start(); tt.Sample(); tt.Reset(); // we need to do this once before, otherwise C# might be // very slow. Obviously the optimizer... tt.Start(); tt.Sample(); long ttAverageInNanos=tt.GetAverage().InNanos(); long ttAverageInMicros=tt.GetAverage().InMicros(); long ttAverageInMillis=tt.GetAverage().InMillis(); Log.Info( "TickWatch minimum measurement nanos: " + ttAverageInNanos ); Log.Info( "TickWatch minimum measurement micros: " + ttAverageInMicros ); Log.Info( "TickWatch minimum measurement millis: " + ttAverageInMillis ); UT_TRUE( ttAverageInNanos < 5000 ); UT_TRUE( ttAverageInMicros <= 5 ); UT_TRUE( ttAverageInMillis == 0 ); } // minimum sleep time measuring { tt.Reset(); for (int i= 0 ; i< 100 ; i++) { ALIB.SleepNanos( 1 ); tt.Sample(); } Ticks avg= tt.GetAverage(); Log.Info( "100 probes of 1 ns of sleep leads to average sleep time of " + avg.InNanos() + " ns"); } // sleep two times 20 ms and probe it to an average { tt.Reset(); tt.Start(); ALIB.SleepMillis( 20 ); tt.Sample(); ALIB.SleepMillis( 80 ); tt.Start(); ALIB.SleepMillis( 20 ); tt.Sample(); long cnt=tt.GetSampleCnt(); long avg=tt.GetAverage().InMillis(); double hertz=tt.GetAverage().InHertz( 1 ); Log.Info( "TickWatch sum is " + tt.GetCumulated().InMillis() + " after " + cnt + " times 20 ms sleep" ); Log.Info( " average is: " + avg + " ms" ); Log.Info( " in Hertz: " + hertz ); UT_TRUE( hertz < 53 ); UT_TRUE( hertz > 30 ); // should work even on heavily loaded machines UT_EQ( 2, cnt ); UT_TRUE( avg >= 18 ); UT_TRUE( avg < 45 ); // should work even on heavily loaded machines } // Ticks Since { Ticks tt1= new Ticks(); tt1.FromSeconds( 1000 ); Ticks tt2= new Ticks(); tt2.FromSeconds( 1001 ); UT_TRUE ( tt2.Since( tt1 ).InMillis() == 1000L ); UT_TRUE ( tt2.Since( tt1 ).InMicros() == 1000L * 1000L ); UT_TRUE ( tt2.Since( tt1 ).InNanos () == 1000L * 1000L * 1000L ); } }
/** **************************************************************************************** * Creates a TickWatch as a copy of another TickWatch. * * @param copy The instance to copy value from. ******************************************************************************************/ public TickWatch ( TickWatch copy ) { ticks .Set( copy.ticks ); sum .Set( copy.sum ); cntSamples= copy.cntSamples; }