/*
OpenNxSerialization Framework
Copyright (C) 2006 - 2007 "NeXtreme Innovations"
[The Next Xtreme Innovations]
This program is free software, distributed under the terms of
the GNU General Public License Version 2. See the "License.txt" file
at the top of the source tree.
*/
using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
namespace NeXtreme.Benchmark
{
internal class NativeSerializationHelper
{
static BinaryFormatter formatter = new BinaryFormatter();
/// <summary>
/// serialize an objevt into a stream.
/// </summary>
/// <param name="stream"></param>
/// <param name="objectToSend"></param>
public static void Serialize(Stream stream, object objectToSend)
{
formatter.Serialize(stream, objectToSend);
}
/// <summary>
/// deserialize an object from the stream.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static object Deserialize(Stream stream)
{
return formatter.Deserialize(stream);
}
/// <summary>
/// Creates an object from a byte buffer
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
public static object FromByteBuffer(byte[] buffer)
{
if(buffer == null) return null;
using(MemoryStream ms = new MemoryStream(buffer))
{
return Deserialize(ms);
}
}
/// <summary>
/// Serializes an object into a byte buffer.
/// The object has to implement interface Serializable or Externalizable
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static byte[] ToByteBuffer(object obj)
{
if(obj == null) return null;
using(MemoryStream ms = new MemoryStream())
{
Serialize(ms, obj);
return ms.ToArray();
}
}
}
/// <summary>
/// .
/// </summary>
/// <returns></returns>
[Serializable]
public class TimeStat
{
/// <summary> Total number of samples collected for the statistics. </summary>
private long _runCount;
/// <summary> Total time spent in sampling, i.e., acrued sample time. </summary>
private long _totalTime;
/// <summary> Best time interval mesaured during sampling. </summary>
private long _bestTime;
/// <summary> Worst time interval mesaured during sampling. </summary>
private long _worstTime;
/// <summary> Avg. time interval mesaured during sampling. </summary>
private float _avgTime;
/// <summary> Best time interval mesaured during sampling. </summary>
private long _expBestTime, _expWorstTime;
/// <summary> Best time interval mesaured during sampling. </summary>
private long _cntBestTime, _cntAvgTime, _cntWorstTime;
/// <summary> Timestamp for the sampling. </summary>
private long _lastStart, _lastStop;
/// <summary>
/// Constructor
/// </summary>
public TimeStat():this(0,0)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="expBestTime">The expected best time.</param>
/// <param name="expWorstTime">The expected worst time.</param>
public TimeStat(long expBestTime, long expWorstTime)
{
_expBestTime = expBestTime;
_expWorstTime = expWorstTime;
Reset();
}
/// <summary> Returns the total numbre of samples. </summary>
public long Runs { get { lock(this){ return _runCount; } } }
/// <summary> Returns the total time iterval spent in sampling </summary>
public long Total{ get { lock(this){ return _totalTime; } } }
/// <summary> Returns the time interval for the last sample </summary>
public long Current{ get { lock(this){ return _lastStop - _lastStart; } } }
/// <summary> Returns the best/avg/worst time interval mesaured during sampling </summary>
public long ExpectedBest{ get { lock(this){ return _expBestTime; } } }
public long ExpectedWorst{ get { lock(this){ return _expWorstTime ; } } }
/// <summary> Returns the best/avg/worst time interval mesaured during sampling </summary>
public long Best{ get { lock(this){ return _bestTime; } } }
public float Avg{ get { lock(this){ return _avgTime ; } } }
public long Worst { get { lock(this){ return _worstTime; } } }
/// <summary> Returns the performance bucket for the current sample </summary>
public bool IsBestCaseSample{ get{lock(this){ return Current <= _expBestTime; }}}
public bool IsAvgCaseSample{ get{lock(this){ return (Current > _expBestTime) && (Current < _expWorstTime); }}}
public bool IsWorstCaseSample{ get{lock(this){ return Current >= _expWorstTime; }}}
/// <summary> Returns the number of operations per perf. bucket </summary>
public long BestCases{ get{lock(this){ return _cntBestTime; }}}
public long AvgCases{ get{lock(this){ return _cntAvgTime; }}}
public long WorstCases{ get{lock(this){ return _cntWorstTime; }}}
/// <summary> Returns the percentage of operations per perf. bucket </summary>
public float PctBestCases{ get{lock(this){ return ((float)BestCases / (float)Runs) * 100; }}}
public float PctAvgCases{ get{lock(this){ return ((float)AvgCases / (float)Runs) * 100; }}}
public float PctWorstCases{ get{lock(this){ return ((float)WorstCases / (float)Runs) * 100; }}}
/// <summary>
/// Resets the statistics collected so far.
/// </summary>
public void Reset()
{
_runCount = 0;
_cntBestTime = _cntAvgTime = _cntWorstTime = 0;
_totalTime = _bestTime = _worstTime = 0;
_avgTime = 0;
}
/// <summary>
/// Timestamps the start of a sampling interval.
/// </summary>
public void BeginSample()
{
_lastStart = (DateTime.Now.Ticks - 621355968000000000) / 10000;
}
/// <summary>
/// Timestamps the end of interval and calculates the sample time
/// </summary>
public void EndSample()
{
lock(this)
{
_lastStop = (DateTime.Now.Ticks - 621355968000000000) / 10000;
AddSampleTime(Current);
if(IsBestCaseSample) ++_cntBestTime;
else if(IsAvgCaseSample) ++_cntAvgTime;
else ++_cntWorstTime;
}
}
/// <summary>
/// Adds a specified sample time to the statistics and updates the run count
/// </summary>
/// <param name="time">sample time in milliseconds.</param>
public void AddSampleTime(long time)
{
lock(this)
{
_runCount ++;
if(_runCount == 1)
{
_avgTime = _totalTime = _bestTime = _worstTime = time;
}
else
{
_totalTime += time;
if(time < _bestTime) _bestTime = time;
if(time > _worstTime) _worstTime = time;
_avgTime = (float)_totalTime / _runCount;
}
}
}
static public void Print(TimeStat stats)
{
Console.WriteLine("----------------------------------------------------");
Console.WriteLine("Iterations = {0}", stats.Runs);
Console.WriteLine("Toal Time(ms) = {0}", stats.Total);
Console.WriteLine("-------------------------------------------");
Console.WriteLine("# Runs Best(ms) Avg(ms) Worst(ms)");
Console.WriteLine("------ -------- ------- ---------");
Console.WriteLine("{0,-6} {1,-8} {2,-8:F2} {3,-8}", stats.Runs, stats.Best, stats.Avg, stats.Worst);
Console.WriteLine();
}
static public void PrintExtended(TimeStat stats)
{
Console.WriteLine("----------------------------------------------------");
Console.WriteLine("Iterations = {0}", stats.Runs);
Console.WriteLine("Toal Time(ms) = {0}", stats.Total);
Console.WriteLine("----------------------------------------------------");
Console.WriteLine("TIME Best(ms) Avg(ms) Worst(ms)");
Console.WriteLine("Expected -- {0,7}< {1,8:F2}> {2,11}>", stats.ExpectedBest, stats.ExpectedBest, stats.ExpectedWorst);
Console.WriteLine("Measured -- {0,8} {1,9:F2} {2,12}", stats.Best, stats.Avg, stats.Worst);
Console.WriteLine("----------------------------------------------------");
Console.WriteLine("PERF Best(ms) Avg(ms) Worst(ms)");
Console.WriteLine("Run dist. -- {0,8} {1,9} {2,12}", stats.BestCases, stats.AvgCases, stats.WorstCases);
Console.WriteLine("Perf dist. -- {0,8:F1}% {1,9:F1}% {2,12:F1}%", stats.PctBestCases, stats.PctAvgCases, stats.PctWorstCases);
Console.WriteLine("----------------------------------------------------");
Console.WriteLine();
Console.WriteLine();
}
}
}
Submit an article or tip