xronos /System.Xronos/Statistics.cs

Language C# Lines 115
MD5 Hash 6560ee0b864d5f64e9d594aa1f1f05f3 Estimated Cost $1,980 (why?)
Repository https://bitbucket.org/stefanrusek/xronos View Raw File
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
/* ****************************************************************************
 * 
 * Copyright (c) 2008 Stefan Rusek and Benjamin Pollack
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 * 
 * ***************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Xronos.Language;
using System.Threading;

namespace System.Xronos
{
    static class Statistics
    {
        class ThreadStatistics
        {
            public Stopwatch StartupTime = new Stopwatch();
            public Stopwatch ReaderTime = new Stopwatch();
            public Stopwatch CompilerTime = new Stopwatch();
            public Stopwatch TypeGenerationTime = new Stopwatch();
            public Stopwatch MacroExpandTime = new Stopwatch();
            public Stopwatch ExecutionTime = new Stopwatch();
            public Stopwatch MethodResolutionTime = new Stopwatch();
            public Stopwatch StringInternTime = new Stopwatch();
            public int BindMisses = 0;
        }

        [ThreadStatic]
        static ThreadStatistics _localStats;
        static List<ThreadStatistics> _allStats = new List<ThreadStatistics>();

        private static ThreadStatistics LocalStats
        {
            get
            {
                if (_localStats == null)
                {
                    _localStats = new ThreadStatistics();
                    lock (_allStats)
                        _allStats.Add(_localStats);
                }
                return _localStats;
            }
        }

        public static Stopwatch StartupTime { get { return LocalStats.StartupTime; } }
        public static Stopwatch ReaderTime { get { return LocalStats.ReaderTime; } }
        public static Stopwatch CompilerTime { get { return LocalStats.CompilerTime; } }
        public static Stopwatch TypeGenerationTime { get { return LocalStats.TypeGenerationTime; } }
        public static Stopwatch MacroExpandTime { get { return LocalStats.MacroExpandTime; } }
        public static Stopwatch ExecutionTime { get { return LocalStats.ExecutionTime; } }
        public static Stopwatch MethodResolutionTime { get { return LocalStats.MethodResolutionTime; } }
        public static Stopwatch StringInternTime { get { return LocalStats.StringInternTime; } }
        public static int BindMisses { get { return LocalStats.BindMisses; } }

        public static void IncrementBindMisses()
        {
            Interlocked.Increment(ref LocalStats.BindMisses);
        }

        public static IPersistentMap GetStatistics()
        {
            TimeSpan startup = TimeSpan.Zero, reader = TimeSpan.Zero, compiler = TimeSpan.Zero, typegen = TimeSpan.Zero, execution = TimeSpan.Zero, macros = TimeSpan.Zero, methodres = TimeSpan.Zero, interns = TimeSpan.Zero;
            int misses = 0;

            lock (_allStats)
                foreach (var item in _allStats)
                {
                    startup += item.StartupTime.Elapsed;
                    reader += item.ReaderTime.Elapsed;
                    compiler += item.CompilerTime.Elapsed;
                    typegen += item.TypeGenerationTime.Elapsed;
                    macros += item.MacroExpandTime.Elapsed;
                    execution += item.ExecutionTime.Elapsed;
                    methodres += item.MethodResolutionTime.Elapsed;
                    interns += item.StringInternTime.Elapsed;
                    misses += item.BindMisses;
                }

            return PersistentHashMap.Create(new object[] {
                "Startup",  startup,
                "Reader",  reader,
                "Compiler",  compiler,
                "Type Gen",  typegen,
                "Macroexpand",  macros,
                "Execution",  execution,
                "Method Resolution",  methodres,
                "String Interns", interns,
                "Bind Misses", misses,
            });
        }
    }
}
Back to Top