Initial update to OpenSim 0.8.2.1 source code.

4 files changed, 403 insertions, 7 deletions

diff --git a/OpenSim/Framework/Monitoring/Stats/CounterStat.cs b/OpenSim/Framework/Monitoring/Stats/CounterStat.cs
new file mode 100755
index 0000000..318cf1c
--- /dev/null
+++ b/OpenSim/Framework/Monitoring/Stats/CounterStat.cs
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * 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
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenMetaverse.StructuredData;
+
+namespace OpenSim.Framework.Monitoring
+{
+// A statistic that wraps a counter.
+// Built this way mostly so histograms and history can be created.
+public class CounterStat : Stat
+{
+    private SortedDictionary<string, EventHistogram> m_histograms;
+    private object counterLock = new object();
+
+    public CounterStat(
+                        string shortName,
+                        string name,
+                        string description,
+                        string unitName,
+                        string category,
+                        string container,
+                        StatVerbosity verbosity)
+        : base(shortName, name, description, unitName, category, container, StatType.Push, null, verbosity)
+    {
+        m_histograms = new SortedDictionary<string, EventHistogram>();
+    }
+
+    // Histograms are presumably added at intialization time and the list does not change thereafter.
+    // Thus no locking of the histogram list.
+    public void AddHistogram(string histoName, EventHistogram histo)
+    {
+        m_histograms.Add(histoName, histo);
+    }
+
+    public delegate void ProcessHistogram(string name, EventHistogram histo);
+    public void ForEachHistogram(ProcessHistogram process)
+    {
+        foreach (KeyValuePair<string, EventHistogram> kvp in m_histograms)
+        {
+            process(kvp.Key, kvp.Value);
+        }
+    }
+
+    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);
+            }
+        }
+    }
+
+    // CounterStat is a basic stat plus histograms
+    public override OSDMap ToOSDMap()
+    {
+        // Get the foundational instance
+        OSDMap map = base.ToOSDMap();
+
+        map["StatType"] = "CounterStat";
+
+        // If there are any histograms, add a new field that is an array of histograms as OSDMaps
+        if (m_histograms.Count > 0)
+        {
+            lock (counterLock)
+            {
+                if (m_histograms.Count > 0)
+                {
+                    OSDArray histos = new OSDArray();
+                    foreach (EventHistogram histo in m_histograms.Values)
+                    {
+                        histos.Add(histo.GetHistogramAsOSDMap());
+                    }
+                    map.Add("Histograms", histos);
+                }
+            }
+        }
+        return map;
+    }
+}
+}
diff --git a/OpenSim/Framework/Monitoring/Stats/EventHistogram.cs b/OpenSim/Framework/Monitoring/Stats/EventHistogram.cs
new file mode 100755
index 0000000..f51f322
--- /dev/null
+++ b/OpenSim/Framework/Monitoring/Stats/EventHistogram.cs
@@ -0,0 +1,173 @@
+/*

+ * Copyright (c) Contributors, http://opensimulator.org/

+ * See CONTRIBUTORS.TXT for a full list of copyright holders.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions are met:

+ *     * Redistributions of source code must retain the above copyright

+ *       notice, this list of conditions and the following disclaimer.

+ *     * Redistributions in binary form must reproduce the above copyright

+ *       notice, this list of conditions and the following disclaimer in the

+ *       documentation and/or other materials provided with the distribution.

+ *     * Neither the name of the OpenSimulator Project nor the

+ *       names of its contributors may be used to endorse or promote products

+ *       derived from this software without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY

+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY

+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+ * 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

+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+

+using System;

+using System.Collections.Generic;

+using System.Linq;

+using System.Text;

+

+using OpenMetaverse.StructuredData;

+

+namespace OpenSim.Framework.Monitoring

+{

+// Create a time histogram of events. The histogram is built in a wrap-around

+//   array of equally distributed buckets.

+// For instance, a minute long histogram of second sized buckets would be:

+//          new EventHistogram(60, 1000)

+public class EventHistogram

+{

+    private int m_timeBase;

+    private int m_numBuckets;

+    private int m_bucketMilliseconds;

+    private int m_lastBucket;

+    private int m_totalHistogramMilliseconds;

+    private long[] m_histogram;

+    private object histoLock = new object();

+

+    public EventHistogram(int numberOfBuckets, int millisecondsPerBucket)

+    {

+        m_numBuckets = numberOfBuckets;

+        m_bucketMilliseconds = millisecondsPerBucket;

+        m_totalHistogramMilliseconds = m_numBuckets * m_bucketMilliseconds;

+

+        m_histogram = new long[m_numBuckets];

+        Zero();

+        m_lastBucket = 0;

+        m_timeBase = Util.EnvironmentTickCount();

+    }

+

+    public void Event()

+    {

+        this.Event(1);

+    }

+

+    // Record an event at time 'now' in the histogram.

+    public void Event(int cnt)

+    {

+        lock (histoLock)

+        {

+            // The time as displaced from the base of the histogram

+            int bucketTime = Util.EnvironmentTickCountSubtract(m_timeBase);

+

+            // If more than the total time of the histogram, we just start over

+            if (bucketTime > m_totalHistogramMilliseconds)

+            {

+                Zero();

+                m_lastBucket = 0;

+                m_timeBase = Util.EnvironmentTickCount();

+            }

+            else

+            {

+                // To which bucket should we add this event?

+                int bucket = bucketTime / m_bucketMilliseconds;

+

+                // Advance m_lastBucket to the new bucket. Zero any buckets skipped over.

+                while (bucket != m_lastBucket)

+                {

+                    // 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++)

+                    {

+                        m_histogram[jj] = 0;

+                    }

+                    m_lastBucket = bucket;

+                    // If the new bucket is off the end, wrap around to the beginning

+                    if (bucket > m_numBuckets)

+                    {

+                        bucket -= m_numBuckets;

+                        m_lastBucket = 0;

+                        m_histogram[m_lastBucket] = 0;

+                        m_timeBase += m_totalHistogramMilliseconds;

+                    }

+                }

+            }

+            m_histogram[m_lastBucket] += cnt;

+        }

+    }

+

+    // Get a copy of the current histogram

+    public long[] GetHistogram()

+    {

+        long[] ret = new long[m_numBuckets];

+        lock (histoLock)

+        {

+            int indx = m_lastBucket + 1;

+            for (int ii = 0; ii < m_numBuckets; ii++, indx++)

+            {

+                if (indx >= m_numBuckets)

+                    indx = 0;

+                ret[ii] = m_histogram[indx];

+            }

+        }

+        return ret;

+    }

+

+    public OSDMap GetHistogramAsOSDMap()

+    {

+        OSDMap ret = new OSDMap();

+

+        ret.Add("Buckets", OSD.FromInteger(m_numBuckets));

+        ret.Add("BucketMilliseconds", OSD.FromInteger(m_bucketMilliseconds));

+        ret.Add("TotalMilliseconds", OSD.FromInteger(m_totalHistogramMilliseconds));

+

+        // Compute a number for the first bucket in the histogram.

+        // This will allow readers to know how this histogram relates to any previously read histogram.

+        int baseBucketNum = (m_timeBase / m_bucketMilliseconds) + m_lastBucket + 1;

+        ret.Add("BaseNumber", OSD.FromInteger(baseBucketNum));

+

+        ret.Add("Values", GetHistogramAsOSDArray());

+

+        return ret;

+    }

+    // Get a copy of the current histogram

+    public OSDArray GetHistogramAsOSDArray()

+    {

+        OSDArray ret = new OSDArray(m_numBuckets);

+        lock (histoLock)

+        {

+            int indx = m_lastBucket + 1;

+            for (int ii = 0; ii < m_numBuckets; ii++, indx++)

+            {

+                if (indx >= m_numBuckets)

+                    indx = 0;

+                ret[ii] = OSD.FromLong(m_histogram[indx]);

+            }

+        }

+        return ret;

+    }

+

+    // Zero out the histogram

+    public void Zero()

+    {

+        lock (histoLock)

+        {

+            for (int ii = 0; ii < m_numBuckets; ii++)

+                m_histogram[ii] = 0;

+        }

+    }

+}

+

+}

diff --git a/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs b/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs
index 60bed55..55ddf06 100644
--- a/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs
+++ b/OpenSim/Framework/Monitoring/Stats/PercentageStat.cs
@@ -29,6 +29,8 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 
+using OpenMetaverse.StructuredData;
+
 namespace OpenSim.Framework.Monitoring
 {
     public class PercentageStat : Stat
@@ -84,5 +86,19 @@ namespace OpenSim.Framework.Monitoring
 
             return sb.ToString();
         }
+
+        // PercentageStat is a basic stat plus percent calc
+        public override OSDMap ToOSDMap()
+        {
+            // Get the foundational instance
+            OSDMap map = base.ToOSDMap();
+
+            map["StatType"] = "PercentageStat";
+
+            map.Add("Antecedent", OSD.FromLong(Antecedent));
+            map.Add("Consequent", OSD.FromLong(Consequent));
+
+            return map;
+        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Framework/Monitoring/Stats/Stat.cs b/OpenSim/Framework/Monitoring/Stats/Stat.cs
index f91251b..a7cb2a6 100644
--- a/OpenSim/Framework/Monitoring/Stats/Stat.cs
+++ b/OpenSim/Framework/Monitoring/Stats/Stat.cs
@@ -27,15 +27,23 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 using System.Text;
+using log4net;
+using OpenMetaverse.StructuredData;
 
 namespace OpenSim.Framework.Monitoring
 {
     /// <summary>
     /// Holds individual statistic details
     /// </summary>
-    public class Stat
+    public class Stat : IDisposable
     {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public static readonly char[] DisallowedShortNameCharacters = { '.' };
+
         /// <summary>
         /// Category of this stat (e.g. cache, scene, etc).
         /// </summary>
@@ -93,7 +101,7 @@ namespace OpenSim.Framework.Monitoring
         /// <remarks>
         /// Will be null if no measures of interest require samples.
         /// </remarks>
-        private static Queue<double> m_samples;
+        private Queue<double> m_samples;
 
         /// <summary>
         /// Maximum number of statistical samples.
@@ -160,6 +168,13 @@ namespace OpenSim.Framework.Monitoring
                 throw new Exception(
                     string.Format("Stat cannot be in category '{0}' since this is reserved for a subcommand", category));
 
+            foreach (char c in DisallowedShortNameCharacters)
+            {
+                if (shortName.IndexOf(c) != -1)
+                    shortName = shortName.Replace(c, '#');
+//                    throw new Exception(string.Format("Stat name {0} cannot contain character {1}", shortName, c));
+            }
+
             ShortName = shortName;
             Name = name;
             Description = description;
@@ -181,6 +196,12 @@ namespace OpenSim.Framework.Monitoring
             Verbosity = verbosity;
         }
 
+        // IDisposable.Dispose()
+        public virtual void Dispose()
+        {
+            return;
+        }
+
         /// <summary>
         /// Record a value in the sample set.
         /// </summary>
@@ -196,6 +217,8 @@ namespace OpenSim.Framework.Monitoring
                 if (m_samples.Count >= m_maxSamples)
                     m_samples.Dequeue();
 
+//                m_log.DebugFormat("[STAT]: Recording value {0} for {1}", newValue, Name);
+
                 m_samples.Enqueue(newValue);
             }
         }
@@ -203,35 +226,100 @@ namespace OpenSim.Framework.Monitoring
         public virtual string ToConsoleString()
         {
             StringBuilder sb = new StringBuilder();
-            sb.AppendFormat("{0}.{1}.{2} : {3}{4}", Category, Container, ShortName, Value, UnitName);
+            sb.AppendFormat(
+                "{0}.{1}.{2} : {3}{4}", 
+                Category, 
+                Container, 
+                ShortName, 
+                Value, 
+                string.IsNullOrEmpty(UnitName) ? "" : string.Format(" {0}", UnitName));
 
             AppendMeasuresOfInterest(sb);
 
             return sb.ToString();
         }
 
-        protected void AppendMeasuresOfInterest(StringBuilder sb)
+        public virtual OSDMap ToOSDMap()
         {
-            if ((MeasuresOfInterest & MeasuresOfInterest.AverageChangeOverTime) 
-                == MeasuresOfInterest.AverageChangeOverTime)
+            OSDMap ret = new OSDMap();
+            ret.Add("StatType", "Stat");    // used by overloading classes to denote type of stat
+
+            ret.Add("Category", OSD.FromString(Category));
+            ret.Add("Container", OSD.FromString(Container));
+            ret.Add("ShortName", OSD.FromString(ShortName));
+            ret.Add("Name", OSD.FromString(Name));
+            ret.Add("Description", OSD.FromString(Description));
+            ret.Add("UnitName", OSD.FromString(UnitName));
+            ret.Add("Value", OSD.FromReal(Value));
+
+            double lastChangeOverTime, averageChangeOverTime;
+            if (ComputeMeasuresOfInterest(out lastChangeOverTime, out averageChangeOverTime))
+            {
+                ret.Add("LastChangeOverTime", OSD.FromReal(lastChangeOverTime));
+                ret.Add("AverageChangeOverTime", OSD.FromReal(averageChangeOverTime));
+            }
+
+            return ret;
+        }
+
+        // Compute the averages over time and return same.
+        // Return 'true' if averages were actually computed. 'false' if no average info.
+        public bool ComputeMeasuresOfInterest(out double lastChangeOverTime, out double averageChangeOverTime)
+        {
+            bool ret = false;
+            lastChangeOverTime = 0;
+            averageChangeOverTime = 0;
+
+            if ((MeasuresOfInterest & MeasuresOfInterest.AverageChangeOverTime) == MeasuresOfInterest.AverageChangeOverTime)
             {
                 double totalChange = 0;
+                double? penultimateSample = null;
                 double? lastSample = null;
 
                 lock (m_samples)
                 {
+                    //                    m_log.DebugFormat(
+                    //                        "[STAT]: Samples for {0} are {1}", 
+                    //                        Name, string.Join(",", m_samples.Select(s => s.ToString()).ToArray()));
+
                     foreach (double s in m_samples)
                     {
                         if (lastSample != null)
                             totalChange += s - (double)lastSample;
 
+                        penultimateSample = lastSample;
                         lastSample = s;
                     }
                 }
 
+                if (lastSample != null && penultimateSample != null)
+                {
+                    lastChangeOverTime
+                        = ((double)lastSample - (double)penultimateSample) / (Watchdog.WATCHDOG_INTERVAL_MS / 1000);
+                }
+
                 int divisor = m_samples.Count <= 1 ? 1 : m_samples.Count - 1;
 
-                sb.AppendFormat(", {0:0.##}{1}/s", totalChange / divisor / (Watchdog.WATCHDOG_INTERVAL_MS / 1000), UnitName);
+                averageChangeOverTime = totalChange / divisor / (Watchdog.WATCHDOG_INTERVAL_MS / 1000);
+                ret = true;
+            }
+
+            return ret;
+        }
+
+        protected void AppendMeasuresOfInterest(StringBuilder sb)
+        {
+            double lastChangeOverTime = 0;
+            double averageChangeOverTime = 0;
+
+            if (ComputeMeasuresOfInterest(out lastChangeOverTime, out averageChangeOverTime))
+            {
+                sb.AppendFormat(
+                    ", {0:0.##}{1}/s, {2:0.##}{3}/s", 
+                    lastChangeOverTime, 
+                    string.IsNullOrEmpty(UnitName) ? "" : string.Format(" {0}", UnitName), 
+                    averageChangeOverTime,
+                    string.IsNullOrEmpty(UnitName) ? "" : string.Format(" {0}", UnitName));
             }
         }
     }