示例#1
0
        /// <summary>
        /// Monitor average response time using a counter having the specified instance name
        /// </summary>
        /// <param name="counterInstanceName">Performance counter instance name</param>
        /// <param name="starttime">the start of the interval for a single sample or response time being averaged</param>
        /// <param name="lockType">some type used internally for locking</param>
        /// <param name="isMonitoringActive">caller can forward external monitoring control</param>
        /// <returns>Current time used as end time for previous sample. Can be used as starttime for next sample</returns>
        public static DateTime MonitorAverageResponse(string counterInstanceName, DateTime starttime, System.Type lockType, bool isMonitoringActive)
        {
            try
            {
                // access counter in hashlist if it is there, else null
                CounterBase counter = (CounterBase)PerformanceCounterFacade.Counters[counterInstanceName];
                // allocate counter if needed
                AverageCounter rtCounter = (AverageCounter)PerformanceCounterFacade.SetCounter(lockType, ref counter, "Average", counterInstanceName, isMonitoringActive);

                if (rtCounter != null)
                {
                    // calculate milliseconds
                    TimeSpan ts = DateTime.Now - starttime;
                    long     ms = (long)ts.TotalMilliseconds;
                    // adjust counters
                    rtCounter.AddSampleValue(ms);
                    rtCounter.IncrementSampleCount();;
                }
                // persist static, threadsafe counter (null if perf monitoring off) for reuse by validator instances
                PerformanceCounterFacade.Counters[counterInstanceName] = rtCounter;
            }
            catch (InvalidOperationException ex)
            {
            }
            return(DateTime.Now);
        }
示例#2
0
        public CounterBase[] FindAll(GetAllCountersCriterion criterion)
        {
            IMongoCollection <CounterBase> counterCollection = Database.GetCollection <CounterBase>("Counter");

            var filter = new BsonDocument();

            if (counterCollection.Find <CounterBase>(filter).Count() == 0)
            {
                CounterBase[] counters = new CounterBase[] {
                    new SingleCounter()
                    {
                        Id = 0, Name = "GDC Points", Value = 0, Type = 0
                    },
                    new GenericCounter()
                    {
                        Id = 1, Name = "Профессионализм", Type = 1, Value = 0, SubValue = 10, InflationIncreaseSteps = 1000
                    },
                    new GenericCounter()
                    {
                        Id = 2, Name = "Зарплата", Type = 1, Value = 0, UseInAutoSteps = true, InflationIncreaseSteps = 2000
                    },
                    new DelayedCounter()
                    {
                        Id = 3, Name = "Квартальный план", Type = 2, Value = 5000000, MiningTimeSeconds = 240
                    },
                };
                counterCollection.InsertMany(counters);
            }

            return(counterCollection.Find(filter).SortBy(_ => _.Id).ToList().ToArray());
        }
示例#3
0
        /// <summary>
        /// Monitor an average value with a counter having the specified instance name
        /// </summary>
        /// <param name="counterInstanceName">Performance counter instance name</param>
        /// <param name="count">the value for a single sample being averaged</param>
        /// <param name="lockType">some type used internally for locking</param>
        /// <param name="isMonitoringActive">caller can forward external monitoring control</param>
        public static void MonitorAverageCount(string counterInstanceName, long count, System.Type lockType, bool isMonitoringActive)
        {
            try
            {
                // access counter in hashlist if it is there, else null
                CounterBase counter = (CounterBase)PerformanceCounterFacade.Counters[counterInstanceName];
                // allocate counter if needed
                AverageCounter avgCounter = (AverageCounter)PerformanceCounterFacade.SetCounter(lockType, ref counter, "Average", counterInstanceName, isMonitoringActive);

                if (avgCounter != null)
                {
                    // adjust counters
                    avgCounter.AddSampleValue(count);
                    avgCounter.IncrementSampleCount();;
                }
                // persist static, threadsafe counter (null if perf monitoring off) for reuse by validator instances
                PerformanceCounterFacade.Counters[counterInstanceName] = avgCounter;
            }
            catch (Exception ex)
            {
                NameValueCollection nvc = new NameValueCollection(2);
                nvc.Add("Method", "MonitorAverageCount");
                nvc.Add("Probable cause", "PerfCounters not registered or wrong category in config file");
                new LoggableException(ex, nvc);
            }
        }
示例#4
0
 static void TestCounter(CounterBase c)
 {
     for (int i = 0; i < 100000; i++)
     {
         c.Increment();
         c.Decrement();
     }
 }
示例#5
0
 static void TestCounter(CounterBase c)
 {
     for (int i = 0; i < 100000; i++)
     {
         c.Increment();
         c.Decrement();
     }
 }
示例#6
0
        private CounterBase[] PrepareCountersToPersist(IGame game)
        {
            var counters = new CounterBase[game.GameCash.Counters.Length];

            foreach (var sourceCounter in game.GameCash.Counters)
            {
                CounterBase destinationCouner     = null;
                var         sourcenGenericCounter = sourceCounter as GenericCounter;
                if (sourcenGenericCounter != null)
                {
                    var destinationGenericCounter = new Common.Contract.Counters.GenericCounter
                    {
                        BonusPercentage = sourcenGenericCounter.BonusPercentage,
                        Bonus           = sourcenGenericCounter.Bonus,
                        Inflation       = sourcenGenericCounter.Inflation,
                        CurrentSteps    = sourcenGenericCounter.CurrentSteps,
                        SubValue        = sourcenGenericCounter.SubValue
                    };
                    destinationCouner      = destinationGenericCounter;
                    destinationCouner.Type = 1;
                }
                var sourceSingleCounter = sourceCounter as SingleCounter;
                if (sourceSingleCounter != null)
                {
                    destinationCouner      = new Common.Contract.Counters.SingleCounter();
                    destinationCouner.Type = 0;
                }
                var sourceDelayedCounter = sourceCounter as DelayedCounter;
                if (sourceDelayedCounter != null)
                {
                    var destinationDelayedCounter = new Common.Contract.Counters.DelayedCounter
                    {
                        SecondsRemaining  = sourceDelayedCounter.SecondsRemaining,
                        MiningTimeSeconds = sourceDelayedCounter.SecondsToAchieve,
                        UnlockValue       = sourceDelayedCounter.UnlockValue
                    };
                    destinationCouner      = destinationDelayedCounter;
                    destinationCouner.Type = 2;
                }
                if (destinationCouner != null)
                {
                    destinationCouner.Name  = sourceCounter.Name;
                    destinationCouner.Id    = sourceCounter.Id;
                    destinationCouner.Value = sourceCounter.Value;
                }
                if (destinationCouner != null)
                {
                    counters[destinationCouner.Id] = destinationCouner;
                }
            }
            return(counters);
        }
示例#7
0
        protected override GameCash GetFundsCounters()
        {
            var counters = new CounterBase[]
            {
                new SingleCounter
                {
                    Id   = (int)UssrCounterEnum.Communism,
                    Name = "Communism"
                }

                ,
                new GenericCounter
                {
                    Id       = (int)UssrCounterEnum.Production,
                    Name     = "Production",
                    SubValue = 10,
                    StepsToIncreaseInflation = 1000
                }

                ,
                new GenericCounter
                {
                    Id                       = (int)UssrCounterEnum.Tax,
                    Name                     = "Tax",
                    IsUsedInAutoStep         = true,
                    StepsToIncreaseInflation = 2000
                },

                new DelayedCounter
                {
                    Id               = (int)UssrCounterEnum.FiveYearPlan,
                    Name             = "Five Year Plan",
                    UnlockValue      = 10000,
                    SecondsToAchieve = 14400,
                    SecondsRemaining = 0,
                    IsMining         = false,
                    SubValue         = 5000000
                }
            };

            return(new GameCash
            {
                Counters = counters,
                RootCounter = counters[(int)UssrCounterEnum.Communism]
            });
        }
示例#8
0
    public int Work(IEnumerable <string> assemblyNames)
    {
        int      maxResult       = 0;
        int      goodTypeCount   = 0;
        int      badTypeCount    = 0;
        int      goodMethodCount = 0;
        int      badMethodCount  = 0;
        DateTime startTime       = DateTime.Now;

        visitor.Start();

        foreach (string assemblyName in assemblyNames)
        {
            int thisResult = Work(assemblyName);

            if ((thisResult == 0) && visitor is CounterBase)
            {
                CounterBase counterVisitor = visitor as CounterBase;
                goodTypeCount   += counterVisitor.TypeCount;
                goodMethodCount += counterVisitor.MethodCount;
                badTypeCount    += counterVisitor.UninstantiableTypeCount;
                badMethodCount  += counterVisitor.UninstantiableMethodCount;
            }

            maxResult = Math.Max(thisResult, maxResult);
        }

        visitor.Finish();

        // Produce summary if visitor's final output is not sufficient.
        if ((badAssemblyCount > 0) || (nonAssemblyCount > 0) || (goodAssemblyCount > 1))
        {
            DateTime stopTime  = DateTime.Now;
            TimeSpan totalTime = stopTime - startTime;
            Console.WriteLine();
            Console.WriteLine($"Overall: {goodAssemblyCount} assemblies {goodTypeCount} types {goodMethodCount} methods in {totalTime.TotalMilliseconds:F2}ms");
            Console.WriteLine($"         {nonAssemblyCount} non-assemblies {badAssemblyCount} skipped assemblies {badTypeCount} skipped types {badMethodCount} skipped methods");
        }

        return(maxResult);
    }
示例#9
0
        /// <summary>
        /// Return a SimpleCounter for use by the caller
        /// </summary>
        /// <param name="counterInstanceName">Performance counter instance name</param>
        /// <param name="count">the value for a single sample being averaged</param>
        /// <param name="lockType">some type used internally for locking</param>
        /// <param name="isMonitoringActive">caller can forward external monitoring control</param>
        public static SimpleCounter GetSimpleCounter(string counterInstanceName, System.Type lockType, bool isMonitoringActive)
        {
            SimpleCounter simpleCounter = null;

            try
            {
                // access counter in hashlist if it is there, else null
                CounterBase counter = (CounterBase)PerformanceCounterFacade.Counters[counterInstanceName];
                // allocate counter if needed
                simpleCounter = (SimpleCounter)PerformanceCounterFacade.SetCounter(lockType, ref counter, "SimpleCounter", counterInstanceName, isMonitoringActive);
                // persist static, threadsafe counter (null if perf monitoring off) for reuse by validator instances
                PerformanceCounterFacade.Counters[counterInstanceName] = simpleCounter;
            }
            catch (Exception ex)
            {
                NameValueCollection nvc = new NameValueCollection(2);
                nvc.Add("Method", "MonitorAverageCount");
                nvc.Add("Probable cause", "PerfCounters not registered or wrong category in config file");
                new LoggableException(ex, nvc);
            }
            return(simpleCounter);
        }
 private bool IsFundsDriverAvailableForBuy(CounterBase rootCounter, Item item)
 {
     return(item.UnlockValue <= rootCounter.Value);
 }
示例#11
0
        /// <summary>
        /// Synchonize creation and destruction of performance counter references
        /// </summary>
        /// <param name="pc">reference to perfcounter variable from caller</param>
        /// <param name="counterType">underlying perf counter type for which new instance might be created</param>
        /// <param name="instancename">instance name to be assigned for new counter instance</param>
        /// <param name="si">sampling interval for new instance</param>
        /// <param name="estsamplesize">estimated initial sample size</param>
        /// <returns>true if perf counter ref is non null and monitoring should be done</returns>
        /// <remarks>This was done in order to have monitoring respond to config setting and dynamically allocate
        /// and deallocate performance counters according to the setting. It also keeps a lot of
        /// potentially messy code in one place</remarks>
        public static CounterBase SetCounter(Type senderType, ref CounterBase pc, string counterType, string instancename, bool isMonitoringOn)
        {
            // if they should continue not monitoring then exit
            if (!isMonitoringOn && pc == null)
            {
                return(null);
            }
            // if they should continue monitoring then exit
            if (isMonitoringOn && pc != null)
            {
                return(pc);
            }

            // either they are monitoring and should stop or they aren't and they should start

            CounterBase newpc = null;


            if (isMonitoringOn)
            {
                if (pc == null)
                {
                    switch (counterType)
                    {
                    case "SimpleCounter":
                        newpc = new SimpleCounter(instancename);
                        break;

                    case "Average":
                        newpc = new AverageCounter(instancename);
                        break;

                    case "Percent":
                        newpc = new PercentCounter(instancename);
                        break;

                    case "AverageResponse":
                        newpc = new AverageResponseTimeCounter(instancename);
                        break;

                    case "Rate":
                        newpc = new RateCounter(instancename);
                        break;

                    default:
                        break;
                    }
                }
            }

            // since perf counters are static shared objects we must lock
            lock (senderType)
            {
                // change their monitoring state from on to off or from off to on
                if (newpc == null)
                {
                    pc.theCounter.RemoveInstance();
                }
                pc = newpc;
            }

            return(newpc);
        }