OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add EventHistogram.GetHistogramAsOSDMap that returns that parameters 

about the histogram as well as the values.
0.7.4-extended
Robert Adams 2013-02-23 17:50:24 -08:00 committed by Justin Clark-Casey (justincc)
parent caceca87e4
commit 452f6894ef
1 changed files with 228 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

439
OpenSim/Framework/Monitoring/Stats/CounterStat.cs
View File

@ -1,211 +1,228 @@
/* /*
* Copyright (c) Contributors, http://opensimulator.org/ * Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright * * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright * * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the * * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products * names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission. * derived from this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text; using System.Text;
using OpenMetaverse.StructuredData; using OpenMetaverse.StructuredData;
namespace OpenSim.Framework.Monitoring namespace OpenSim.Framework.Monitoring
{ {
// Create a time histogram of events. The histogram is built in a wrap-around // Create a time histogram of events. The histogram is built in a wrap-around
// array of equally distributed buckets. // array of equally distributed buckets.
// For instance, a minute long histogram of second sized buckets would be: // For instance, a minute long histogram of second sized buckets would be:
// new EventHistogram(60, 1000) // new EventHistogram(60, 1000)
public class EventHistogram public class EventHistogram
{ {
private int m_timeBase; private int m_timeBase;
private int m_numBuckets; private int m_numBuckets;
private int m_bucketMilliseconds; private int m_bucketMilliseconds;
private int m_lastBucket; private int m_lastBucket;
private int m_totalHistogramMilliseconds; private int m_totalHistogramMilliseconds;
private long[] m_histogram; private long[] m_histogram;
private object histoLock = new object(); private object histoLock = new object();
public EventHistogram(int numberOfBuckets, int millisecondsPerBucket) public EventHistogram(int numberOfBuckets, int millisecondsPerBucket)
{ {
m_numBuckets = numberOfBuckets; m_numBuckets = numberOfBuckets;
m_bucketMilliseconds = millisecondsPerBucket; m_bucketMilliseconds = millisecondsPerBucket;
m_totalHistogramMilliseconds = m_numBuckets * m_bucketMilliseconds; m_totalHistogramMilliseconds = m_numBuckets * m_bucketMilliseconds;
m_histogram = new long[m_numBuckets]; m_histogram = new long[m_numBuckets];
Zero(); Zero();
m_lastBucket = 0; m_lastBucket = 0;
m_timeBase = Util.EnvironmentTickCount(); m_timeBase = Util.EnvironmentTickCount();
} }
public void Event() public void Event()
{ {
this.Event(1); this.Event(1);
} }
// Record an event at time 'now' in the histogram. // Record an event at time 'now' in the histogram.
public void Event(int cnt) public void Event(int cnt)
{ {
lock (histoLock) lock (histoLock)
{ {
// The time as displaced from the base of the histogram // The time as displaced from the base of the histogram
int bucketTime = Util.EnvironmentTickCountSubtract(m_timeBase); int bucketTime = Util.EnvironmentTickCountSubtract(m_timeBase);
// If more than the total time of the histogram, we just start over // If more than the total time of the histogram, we just start over
if (bucketTime > m_totalHistogramMilliseconds) if (bucketTime > m_totalHistogramMilliseconds)
{ {
Zero(); Zero();
m_lastBucket = 0; m_lastBucket = 0;
m_timeBase = Util.EnvironmentTickCount(); m_timeBase = Util.EnvironmentTickCount();
} }
else else
{ {
// To which bucket should we add this event? // To which bucket should we add this event?
int bucket = bucketTime / m_bucketMilliseconds; int bucket = bucketTime / m_bucketMilliseconds;
// Advance m_lastBucket to the new bucket. Zero any buckets skipped over. // Advance m_lastBucket to the new bucket. Zero any buckets skipped over.
while (bucket != m_lastBucket) while (bucket != m_lastBucket)
{ {
// Zero from just after the last bucket to the new bucket or the end // Zero from just after the last bucket to the new bucket or the end
for (int jj = m_lastBucket + 1; jj <= Math.Min(bucket, m_numBuckets - 1); jj++) for (int jj = m_lastBucket + 1; jj <= Math.Min(bucket, m_numBuckets - 1); jj++)
{ {
m_histogram[jj] = 0; m_histogram[jj] = 0;
} }
m_lastBucket = bucket; m_lastBucket = bucket;
// If the new bucket is off the end, wrap around to the beginning // If the new bucket is off the end, wrap around to the beginning
if (bucket > m_numBuckets) if (bucket > m_numBuckets)
{ {
bucket -= m_numBuckets; bucket -= m_numBuckets;
m_lastBucket = 0; m_lastBucket = 0;
m_histogram[m_lastBucket] = 0; m_histogram[m_lastBucket] = 0;
m_timeBase += m_totalHistogramMilliseconds; m_timeBase += m_totalHistogramMilliseconds;
} }
} }
} }
m_histogram[m_lastBucket] += cnt; m_histogram[m_lastBucket] += cnt;
} }
} }
// Get a copy of the current histogram // Get a copy of the current histogram
public long[] GetHistogram() public long[] GetHistogram()
{ {
long[] ret = new long[m_numBuckets]; long[] ret = new long[m_numBuckets];
lock (histoLock) lock (histoLock)
{ {
int indx = m_lastBucket + 1; int indx = m_lastBucket + 1;
for (int ii = 0; ii < m_numBuckets; ii++, indx++) for (int ii = 0; ii < m_numBuckets; ii++, indx++)
{ {
if (indx >= m_numBuckets) if (indx >= m_numBuckets)
indx = 0; indx = 0;
ret[ii] = m_histogram[indx]; ret[ii] = m_histogram[indx];
} }
} }
return ret; return ret;
} }
// Get a copy of the current histogram public OSDMap GetHistogramAsOSDMap()
public OSDArray GetHistogramAsOSDArray() {
{ OSDMap ret = new OSDMap();
OSDArray ret = new OSDArray(m_numBuckets);
lock (histoLock) ret.Add("Buckets", OSD.FromInteger(m_numBuckets));
{ ret.Add("BucketMilliseconds", OSD.FromInteger(m_bucketMilliseconds));
int indx = m_lastBucket + 1; ret.Add("TotalMilliseconds", OSD.FromInteger(m_totalHistogramMilliseconds));
for (int ii = 0; ii < m_numBuckets; ii++, indx++)
{ // Compute a number for the first bucket in the histogram.
if (indx >= m_numBuckets) // This will allow readers to know how this histogram relates to any previously read histogram.
indx = 0; int baseBucketNum = (m_timeBase / m_bucketMilliseconds) + m_lastBucket + 1;
ret[ii] = OSD.FromLong(m_histogram[indx]); ret.Add("BaseNumber", OSD.FromInteger(baseBucketNum));
}
} ret.Add("Values", GetHistogramAsOSDArray());
return ret;
} return ret;
}
// Zero out the histogram // Get a copy of the current histogram
public void Zero() public OSDArray GetHistogramAsOSDArray()
{ {
lock (histoLock) OSDArray ret = new OSDArray(m_numBuckets);
{ lock (histoLock)
for (int ii = 0; ii < m_numBuckets; ii++) {
m_histogram[ii] = 0; int indx = m_lastBucket + 1;
} for (int ii = 0; ii < m_numBuckets; ii++, indx++)
} {
} if (indx >= m_numBuckets)
indx = 0;
// A statistic that wraps a counter. ret[ii] = OSD.FromLong(m_histogram[indx]);
// Built this way mostly so histograms and history can be created. }
public class CounterStat : Stat }
{ return ret;
private SortedDictionary<string, EventHistogram> m_histograms; }
private object counterLock = new object();
// Zero out the histogram
public CounterStat( public void Zero()
string shortName, {
string name, lock (histoLock)
string description, {
string unitName, for (int ii = 0; ii < m_numBuckets; ii++)
string category, m_histogram[ii] = 0;
string container, }
StatVerbosity verbosity) }
: base(shortName, name, description, unitName, category, container, StatType.Push, null, verbosity) }
{
m_histograms = new SortedDictionary<string, EventHistogram>(); // A statistic that wraps a counter.
} // Built this way mostly so histograms and history can be created.
public class CounterStat : Stat
// Histograms are presumably added at intialization time and the list does not change thereafter. {
// Thus no locking of the histogram list. private SortedDictionary<string, EventHistogram> m_histograms;
public void AddHistogram(string histoName, EventHistogram histo) private object counterLock = new object();
{
m_histograms.Add(histoName, histo); public CounterStat(
} string shortName,
string name,
public delegate void ProcessHistogram(string name, EventHistogram histo); string description,
public void ForEachHistogram(ProcessHistogram process) string unitName,
{ string category,
foreach (KeyValuePair<string, EventHistogram> kvp in m_histograms) string container,
{ StatVerbosity verbosity)
process(kvp.Key, kvp.Value); : base(shortName, name, description, unitName, category, container, StatType.Push, null, verbosity)
} {
} m_histograms = new SortedDictionary<string, EventHistogram>();
}
public void Event()
{ // Histograms are presumably added at intialization time and the list does not change thereafter.
this.Event(1); // Thus no locking of the histogram list.
} public void AddHistogram(string histoName, EventHistogram histo)
{
// Count the underlying counter. m_histograms.Add(histoName, histo);
public void Event(int cnt) }
{
lock (counterLock) public delegate void ProcessHistogram(string name, EventHistogram histo);
{ public void ForEachHistogram(ProcessHistogram process)
base.Value += cnt; {
foreach (KeyValuePair<string, EventHistogram> kvp in m_histograms)
foreach (EventHistogram histo in m_histograms.Values) {
{ process(kvp.Key, kvp.Value);
histo.Event(cnt); }
} }
}
} public void Event()
} {
} this.Event(1);
}
// Count the underlying counter.
public void Event(int cnt)
{
lock (counterLock)
{
base.Value += cnt;
foreach (EventHistogram histo in m_histograms.Values)
{
histo.Event(cnt);
}
}
}
}
}