/// <summary>
/// Initializes the Instrumentation component
/// </summary>
/// <param name="performanceMonitorConfig">Component that contains the list of performance counters and default performance counter</param>
public Instrumentation(IDictionary<string, ICounter> performanceMonitorConfig, ICounter defaultCounter)
{
this.counterCollection = performanceMonitorConfig;
this.defaultCounter = defaultCounter;
this.Register(this.counterCollection.Values);
this.Register(this.defaultCounter);
}
protected NodeBase(ICluster owner, IPEndPoint endpoint, IFailurePolicy failurePolicy, ISocket socket)
{
this.owner = owner;
this.endpoint = endpoint;
this.socket = socket;
this.failurePolicy = failurePolicy;
this.name = endpoint.ToString();
failLock = new Object();
writeQueue = new ConcurrentQueue<Data>();
readQueue = new Queue<Data>();
mustReconnect = true;
IsAlive = true;
counterEnqueuePerSec = Metrics.Meter("node write enqueue/sec", endpoint.ToString(), Interval.Seconds);
counterDequeuePerSec = Metrics.Meter("node write dequeue/sec", endpoint.ToString(), Interval.Seconds);
counterOpReadPerSec = Metrics.Meter("node op read/sec", endpoint.ToString(), Interval.Seconds);
counterWriteQueue = Metrics.Counter("write queue length", endpoint.ToString());
counterReadQueue = Metrics.Counter("read queue length", endpoint.ToString());
counterWritePerSec = Metrics.Meter("node write/sec", endpoint.ToString(), Interval.Seconds);
counterErrorPerSec = Metrics.Meter("node in error/sec", endpoint.ToString(), Interval.Seconds);
counterItemCount = Metrics.Counter("commands", endpoint.ToString());
gaugeSendSpeed = Metrics.Gauge("send speed", endpoint.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="RollbackMessageDecorator" /> class.
/// </summary>
/// <param name="metrics">The metrics factory.</param>
/// <param name="handler">The handler.</param>
/// <param name="connectionInformation">The connection information.</param>
public RollbackMessageDecorator(IMetrics metrics,
IRollbackMessage handler,
IConnectionInformation connectionInformation)
{
var name = handler.GetType().Name;
_rollbackCounter = metrics.Counter($"{connectionInformation.QueueName}.{name}.RollbackCounter", Units.Items);
_handler = handler;
}
public PerformanceCounterInfo(string name, PerformanceCounter performanceCounters, ICounter counter)
{
_name = name;
_performanceCounters = performanceCounters;
_alias = counter.Alias;
_fieldName = counter.FieldName;
_tags = (counter.Tags ?? new List<ITag>()).ToList();
_max = counter.Max;
}
public PerformanceCounterInfo(PerformanceCounter performanceCounter, ICounter counter)
: this(null, performanceCounter, counter)
{
_name = counter.Name;
if (_name == "*" && performanceCounter != null)
{
_name = performanceCounter.InstanceName;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IClearExpiredMessages" /> class.
/// </summary>
/// <param name="metrics">The metrics factory.</param>
/// <param name="handler">The handler.</param>
/// <param name="connectionInformation">The connection information.</param>
public ClearExpiredMessagesDecorator(IMetrics metrics,
IClearExpiredMessages handler,
IConnectionInformation connectionInformation)
{
var name = "ClearExpiredMessages";
_timer = metrics.Timer($"{connectionInformation.QueueName}.{name}.ClearMessages.ResetTimer", Units.Calls);
_counter = metrics.Counter($"{connectionInformation.QueueName}.{name}.ClearMessages.ResetCounter", Units.Items);
_handler = handler;
}
public QuestTarget(ICounter counter, int questid, QuestPeriod period, int max, int sharedwith = 0, string description = "")
{
Counter = counter;
counter.Increased += Increase;
QuestId = questid;
Period = period;
Progress = new LimitedValue(0, max);
Description = description;
sharedwithid = sharedwith;
}
public CounterDataCount(ICounter counter)
{
var category = PerformanceCounterCategory.GetCategories().First(cat => cat.CategoryName == counter.CategoryName);
Counter = category.GetCounters().FirstOrDefault(c => c.CounterName == counter.Name);
if (Counter != null)
{
Counter.ReadOnly = false;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueCreationDecorator" /> class.
/// </summary>
/// <param name="metrics">The metrics factory.</param>
/// <param name="handler">The handler.</param>
/// <param name="connectionInformation">The connection information.</param>
public ResetHeartBeatDecorator(IMetrics metrics,
IResetHeartBeat handler,
IConnectionInformation connectionInformation)
{
var name = "ResetHeartBeat";
_timer = metrics.Timer($"{connectionInformation.QueueName}.{name}.ResetTimer", Units.Calls);
_counter = metrics.Counter($"{connectionInformation.QueueName}.{name}.ResetCounter", Units.Items);
_handler = handler;
}
public virtual double WeightFeatureProduct(ICounter <string> features)
{
double product = 0;
foreach (KeyValuePair <string, double> feature in features.EntrySet())
{
product += feature.Value * weights.GetCount(feature.Key);
}
return(product);
}
public QuestTarget(ICounter counter, int questid, QuestPeriod period, int max, int sharedwith = 0, string description = "")
{
Counter = counter;
counter.Increased += Increase;
QuestId = questid;
Period = period;
Progress = new LimitedValue(0, max);
Description = description;
sharedwithid = sharedwith;
}
public async Task <IActionResult> About()
{
ICounter counter = ServiceProxy.Create <ICounter>(new Uri("fabric:/Application1/StatefulSvc"), new ServicePartitionKey(0));
long count = await counter.GetCountAsync();
ViewData["Message"] = count.ToString();
return(View());
}
private static ICounter <string> GetConjunction(ICounter <string> original, string suffix)
{
ICounter <string> conjuction = new ClassicCounter <string>();
foreach (KeyValuePair <string, double> e in original.EntrySet())
{
conjuction.IncrementCount(e.Key + suffix, e.Value);
}
return(conjuction);
}
public virtual void AddAll(ITwoDimensionalCounterInterface <K1, K2> c)
{
foreach (K1 key in c.FirstKeySet())
{
ICounter <K2> inner = c.GetCounter(key);
ClassicCounter <K2> myInner = GetCounter(key);
Counters.AddInPlace(myInner, inner);
total += inner.TotalCount();
}
}
/// <summary>
/// Initializes a counter publisher.
/// </summary>
/// <param name="counterSamplePublisher">The counter publisher.</param>
/// <param name="counterSet">An object providing counter instance members.</param>
/// <param name="memberList">The member list.</param>
/// <param name="counterSetName">Name of the counter set.</param>
private static void InitializeCounterPublisher(CounterSamplePublisher counterSamplePublisher, object counterSet, IEnumerable<MemberInfo> memberList, string counterSetName)
{
foreach (var member in memberList)
{
PublishCounterAttribute attribute = GetCounterAttribute(member);
if (attribute != null)
{
if (!IsCounterType(member))
{
if (log.IsWarnEnabled)
{
log.WarnFormat("PublishCounterAttribute applied to member '{0}' which is not a ICounter type.", member.Name);
}
}
else
{
ICounter counter = (ICounter)GetMemberValue(counterSet, member);
if (counter == null)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Counter for member {0} has not been initialized.", member.Name);
}
}
else if (counter.CounterType != CounterType.Undefined)
{
string name = GetCounterName(member, attribute, counterSetName);
counterSamplePublisher.AddCounter(counter, name);
if (log.IsDebugEnabled)
{
log.DebugFormat("Added counter '{0}' to counter publisher.", name);
}
}
}
}
else
{
CounterSetAttribute attribute2 = GetCounterSetAttribute(member);
if (attribute2 != null)
{
if (GetMemberValue(counterSet, member) == null)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("CounterSet for member {0} has not been initialized.", member.Name);
}
}
else
{
InitializeCounterPublisher(counterSamplePublisher, counterSet, GetCounterSetName(member, attribute2, counterSetName));
}
}
}
}
}
// static class
/// <exception cref="System.IO.IOException"/>
public static void Main(string[] args)
{
bool outputLowercase = true;
foreach (string arg in args)
{
if (Sharpen.Runtime.EqualsIgnoreCase(arg, "-noLowercase"))
{
outputLowercase = false;
continue;
}
// everything else is considered a filename
BufferedReader @in = new BufferedReader(new FileReader(arg));
for (string line; (line = @in.ReadLine()) != null;)
{
string[] toks = line.Split(" ");
foreach (string tok in toks)
{
string lctok = tok.ToLower();
ICounter <string> counter = map[lctok];
if (counter == null)
{
counter = new ClassicCounter <string>();
map[lctok] = counter;
}
counter.IncrementCount(tok);
}
}
}
foreach (string k in map.Keys)
{
ICounter <string> counter = map[k];
string maxstr = string.Empty;
int maxcount = -1;
foreach (string str in counter.KeySet())
{
int count = (int)counter.GetCount(str);
if (count > maxcount)
{
maxstr = str;
maxcount = count;
}
}
highest[k] = maxstr;
}
foreach (string k_1 in highest.Keys)
{
string cased = highest[k_1];
if (!outputLowercase && k_1.Equals(cased))
{
continue;
}
System.Console.Out.Printf("%s\t%s\n", k_1, cased);
}
}
public CounterExtensionsShould()
{
_value = 100d;
_counterLabel = new CounterLabel("abc");
_counterLabel.IncrementTo(_value);
_counter = new Counter <CounterExtensionsShould>(Fixture.Create <string>(), null, new[]
{
_counterLabel
});
}
public AssetFetcher(OMV.GridClient grid)
{
m_client = grid;
// m_client.Assets.OnAssetReceived += new OMV.AssetManager.AssetReceivedCallback(Assets_OnAssetReceived);
m_requests = new Dictionary <string, TRequest>();
m_outstandingRequests = new List <TRequest>();
m_stats = new StatisticManager("AssetFetcher");
m_totalRequests = m_stats.GetCounter("TotalRequests");
m_duplicateRequests = m_stats.GetCounter("DuplicateRequests");
m_requestsForExisting = m_stats.GetCounter("RequestsForExistingAsset");
}
public Parser(ICounter counter, IParser parser, ILogger logger)
{
// save the logger
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
// save the files/folders parser
_parser = parser ?? throw new ArgumentNullException(nameof(parser));
// our performance counter.
_counter = counter ?? throw new ArgumentNullException(nameof(counter));
}
public AssetFetcher(OMV.GridClient grid)
{
m_client = grid;
// m_client.Assets.OnAssetReceived += new OMV.AssetManager.AssetReceivedCallback(Assets_OnAssetReceived);
m_requests = new Dictionary<string, TRequest>();
m_outstandingRequests = new List<TRequest>();
m_stats = new StatisticManager("AssetFetcher");
m_totalRequests = m_stats.GetCounter("TotalRequests");
m_duplicateRequests = m_stats.GetCounter("DuplicateRequests");
m_requestsForExisting = m_stats.GetCounter("RequestsForExistingAsset");
}
public void AddOrReplace(ICounter counter)
{
var counters = GetAllCounters().ToList();
if (counters.Contains(counter))
{
counters.Remove(counter);
}
counters.Add(counter);
WriteToFile(counters);
}
/// <seealso cref="Classify(Edu.Stanford.Nlp.Util.ICoreMap)"/>
public virtual SentimentClass Classify(string text)
{
Annotation ann = new Annotation(text);
pipeline.Get().Annotate(ann);
ICoreMap sentence = ann.Get(typeof(CoreAnnotations.SentencesAnnotation))[0];
ICounter <string> features = Featurize(sentence);
RVFDatum <SentimentClass, string> datum = new RVFDatum <SentimentClass, string>(features);
return(impl.ClassOf(datum));
}
/// <inheritdoc />
public ICounter CreateCounter(string name, string help, bool delayPublish, string[] labels)
{
var counters = new ICounter[_providers.Count];
for (var index = 0; index < counters.Length; index++)
{
counters[index] = _providers.ElementAt(index).Value.CreateCounter(name, help, delayPublish, labels);
}
return(counters.Length == 1 ? counters[0] : new Counter(counters, name, help, labels));
}
private CandidatePhrase(string phrase, string lemma, ICounter <string> features)
{
if (phrase.IsEmpty())
{
Sharpen.Runtime.PrintStackTrace(new Exception("Creating empty candidatePhrase"), System.Console.Out);
}
this.phrase = phrase;
this.phraseLemma = lemma;
this.features = features;
this.hashCode = phrase.GetHashCode();
}
public virtual double ProbabilityOfTrue(ICounter <string> features)
{
DecisionTreeNode cur = root;
while (!cur.IsLeaf())
{
double value = features.GetCount(featureIndex.Get(cur.idx));
cur = (value < cur.split) ? cur.children[0] : cur.children[1];
}
return(cur.split);
}
public CounterPageViewModel(ICounter counter)
{
_counter = counter;
_counter.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == "Value")
{
Value = _counter.Value;
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkGroupWithItem"/> class.
/// </summary>
/// <param name="sourceGroup">The source group.</param>
/// <param name="threadGroup">The thread group.</param>
/// <param name="metricCounter">A counter for tracking how many items are being processed</param>
public WorkGroupWithItem(IWorkGroup sourceGroup, BulkheadPolicy threadGroup, ICounter metricCounter)
{
Guard.NotNull(() => sourceGroup, sourceGroup);
Guard.NotNull(() => threadGroup, threadGroup);
Guard.NotNull(() => metricCounter, metricCounter);
GroupInfo = sourceGroup;
Group = threadGroup;
MaxWorkItems = GroupInfo.ConcurrencyLevel + GroupInfo.MaxQueueSize;
MetricCounter = metricCounter;
}
public State(ClustererDataLoader.ClustererDoc doc)
{
currentDocId = doc.id;
this.doc = doc;
this.hashedScores = new Dictionary <Clusterer.MergeKey, bool>();
this.hashedCosts = new Dictionary <long, double>();
this.clusters = new List <Clusterer.Cluster>();
this.hash = 0;
mentionToCluster = new Dictionary <int, Clusterer.Cluster>();
foreach (int m in doc.mentions)
{
Clusterer.Cluster c = new Clusterer.Cluster(m);
clusters.Add(c);
mentionToCluster[m] = c;
hash ^= c.hash * 7;
}
IList <Pair <int, int> > allPairs = new List <Pair <int, int> >(doc.classificationScores.KeySet());
ICounter <Pair <int, int> > scores = UseRanking ? doc.rankingScores : doc.classificationScores;
allPairs.Sort(null);
int i = 0;
for (i = 0; i < allPairs.Count; i++)
{
double score = scores.GetCount(allPairs[i]);
if (score < MinPairwiseScore && i > MinPairs)
{
break;
}
if (i >= EarlyStopThreshold && i / score > EarlyStopVal)
{
break;
}
}
mentionPairs = allPairs.SubList(0, i);
ICounter <int> seenAnaphors = new ClassicCounter <int>();
ICounter <int> seenAntecedents = new ClassicCounter <int>();
globalFeatures = new List <Clusterer.GlobalFeatures>();
for (int j = 0; j < allPairs.Count; j++)
{
Pair <int, int> mentionPair = allPairs[j];
Clusterer.GlobalFeatures gf = new Clusterer.GlobalFeatures();
gf.currentIndex = j;
gf.anaphorSeen = seenAnaphors.ContainsKey(mentionPair.second);
gf.size = mentionPairs.Count;
gf.docSize = doc.mentions.Count / 300.0;
globalFeatures.Add(gf);
seenAnaphors.IncrementCount(mentionPair.second);
seenAntecedents.IncrementCount(mentionPair.first);
}
currentIndex = 0;
SetClusters();
}
public void AssertCanRegisterInstanceGlobal()
{
string serviceName = "Counter";
Container.RegisterGlobalInstance <ICounter>(new Counter(serviceName));
ICounter counter = Container.ResolveGlobalInstance <ICounter>();
Assert.AreEqual($"{serviceName}: 0", counter.GetStatus());
Container.RemoveGlobalInstanceMapping <ICounter>();
}
public DummyMetrics(IMetrics metrics)
{
_runs = metrics.Counter()
.Name("myservice_dummy_runs")
.Help("Number of times the dummy worker ran")
.Register();
_runDurations = metrics.Histogram()
.Name("myservice_dummy_duration_seconds")
.Help("Average duration of a dummy worker run")
.Register();
}
public void CounterValueIsIncreased()
{
var tags = new Dictionary <string, string> {
{ "foo", "bar" }
};
NoopMetricsFactory metricsFactory = NoopMetricsFactory.Instance;
ICounter counter = metricsFactory.CreateCounter("thecounter", tags);
counter.Inc(1);
}
public ContactMetrics(IMetrics metrics)
{
_writeDurations = metrics.Histogram()
.Name("myservice_contact_write_duration_seconds")
.Help("Average duration of persistence write operations for contacts")
.Register();
_pokes = metrics.Counter()
.Name("myservice_contact_pokes_total")
.Help("Number of times contacts were poked")
.Register();
}
/// <summary>打开客户端</summary>
public virtual Boolean Open()
{
if (Active)
{
return(true);
}
lock (Root)
{
if (Active)
{
return(true);
}
var ss = Servers;
if (ss == null || ss.Length == 0)
{
throw new ArgumentNullException(nameof(Servers), "未指定服务端地址");
}
if (Encoder == null)
{
Encoder = new JsonEncoder();
}
//if (Encoder == null) Encoder = new BinaryEncoder();
//if (Handler == null) Handler = new ApiHandler { Host = this };
// 集群
Cluster = InitCluster();
WriteLog("集群：{0}", Cluster);
Encoder.Log = EncoderLog;
// 控制性能统计信息
var ms = StatPeriod * 1000;
if (ms > 0)
{
if (StatSend == null)
{
StatSend = new PerfCounter();
}
if (StatReceive == null)
{
StatReceive = new PerfCounter();
}
_Timer = new TimerX(DoWork, null, ms, ms)
{
Async = true
};
}
return(Active = true);
}
}
/// <summary>
/// Initializes a new instance of the type
/// </summary>
/// <param name="containerName">The name of the container to use in logging operations</param>
/// <param name="diagnosticsConfiguration">A diagnostics instance to use when instantiating the container</param>
/// <param name="probeConfiguration">The availability and liveness probe configuration</param>
/// <param name="startPosition">The event position to start processing if no checkpoint is found for the partition</param>
protected LegacyProcessorBase(string containerName, DiagnosticsConfiguration diagnosticsConfiguration, IProbeConfiguration probeConfiguration, EventPosition startPosition) : base(containerName, probeConfiguration, diagnosticsConfiguration)
{
_loggerFactory = diagnosticsConfiguration.LoggerFactory;
_startPosition = startPosition;
_iterationCounter = diagnosticsConfiguration.MetricFactory.CreateCounter("pro_iteration_counter", "Counts the number of iterations the demo container has performed.", false, new string[0]);
_scaleEventCounter = diagnosticsConfiguration.MetricFactory.CreateCounter("pro_scale_event_counter", "Counts the number of times a scale event has occurred.", false, new string[0]);
_healthProbeCounter = diagnosticsConfiguration.MetricFactory.CreateCounter("pro_health_counter", "Counts the number of times the liveness probe endpoint has been accessed since the start of the container.", false, new string[0]);
_healthProbeFailureCounter = diagnosticsConfiguration.MetricFactory.CreateCounter("pro_health_failure_counter", "Counts the number of times the liveness probe endpoint has been accessed and failed since the start of the container.", false, new string[0]);
_availabilityProbeCounter = diagnosticsConfiguration.MetricFactory.CreateCounter("pro_availability_counter", "Counts the number of times the readiness probe endpoint has been accessed since the start of the container.", false, new string[0]);
_availabilityProbeFailureCounter = diagnosticsConfiguration.MetricFactory.CreateCounter("pro_availability_failure_counter", "Counts the number of times the readiness probe endpoint has been accessed and failed since the start of the container.", false, new string[0]);
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkGroupWithItem"/> class.
/// </summary>
/// <param name="sourceGroup">The source group.</param>
/// <param name="threadGroup">The thread group.</param>
/// <param name="metricCounter">A counter for tracking how many items are being processed</param>
public WorkGroupWithItem(IWorkGroup sourceGroup, IWorkItemsGroup threadGroup, ICounter metricCounter)
{
Guard.NotNull(() => sourceGroup, sourceGroup);
Guard.NotNull(() => threadGroup, threadGroup);
Guard.NotNull(() => metricCounter, metricCounter);
GroupInfo = sourceGroup;
Group = threadGroup;
MaxWorkItems = GroupInfo.ConcurrencyLevel + GroupInfo.MaxQueueSize;
MetricCounter = metricCounter;
}
public TicketBoughtEventHandler(ILogger <TicketBoughtEventHandler> logger,
ICounter <IReceivedEvents> receivedEventsCounter,
ICounter <IUniqueReceivedEvents> uniqueReceivedEventsCounter,
EventIdsRepository eventIdsRepository)
{
_logger = logger;
_receivedEventsCounter = receivedEventsCounter;
_uniqueReceivedEventsCounter = uniqueReceivedEventsCounter;
_eventIdsRepository = eventIdsRepository;
}
/// <summary>结束计时</summary>
/// <param name="counter"></param>
/// <param name="startTicks"></param>
public static void StopCount(this ICounter counter, Int64?startTicks)
{
if (counter == null || startTicks == null)
{
return;
}
var ticks = Stopwatch.GetTimestamp() - startTicks.Value;
counter.Increment(1, (Int64)(ticks * tickFrequency / 10));
}
public ExtractedPhrase(int startIndex, int endIndex, SemgrexPattern pattern, string value, double weight, string articleId, int sentId, ICounter <string> features)
{
this.startIndex = startIndex;
this.endIndex = endIndex;
this.pattern = pattern;
this.value = value;
this.confidence = weight;
this.articleId = articleId;
this.sentId = sentId;
this.features = features;
}
/// <summary>
/// Initializes a new instance of the <see cref="DelayedProcessingActionDecorator" /> class.
/// </summary>
/// <param name="metrics">The metrics factory.</param>
/// <param name="handler">The handler.</param>
/// <param name="connectionInformation">The connection information.</param>
public DelayedProcessingActionDecorator(IMetrics metrics,
IDelayedProcessingAction handler,
IConnectionInformation connectionInformation)
{
Guard.NotNull(() => metrics, metrics);
Guard.NotNull(() => handler, handler);
var name = handler.GetType().Name;
_timer = metrics.Timer($"{connectionInformation.QueueName}.{name}.RunTimer", Units.Calls);
_counter = metrics.Counter($"{connectionInformation.QueueName}.{name}.RunCounter", Units.Items);
_handler = handler;
}
public bool Add(ICounter counter)
{
if (counter == null)
throw new ArgumentNullException("counter");
lock (countLock) {
if (counters.ContainsKey(counter.Name))
return false;
counters[counter.Name] = counter;
return true;
}
}
public ICounter Merge(ICounter counter)
{
if (counter == null)
{
throw new ArgumentNullException(nameof(counter));
}
for (var i = 0; i < _nodes; i++)
{
_payload.AddOrUpdate(i, key => counter[i], (key, value) => Math.Max(value, counter[i]));
}
return this;
}
public ICounter Merge(ICounter counter)
{
if (counter == null)
{
throw new ArgumentNullException(nameof(counter));
}
for (var i = 0; i < _nodes; i++)
{
_payload[i] = Math.Max(_payload[i], counter[i]);
}
return this;
}
/// <summary>
/// Initializes a new instance of the <see cref="SmartThreadPoolTaskScheduler"/> class.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <param name="waitForFreeThread">The wait for free thread.</param>
/// <param name="metrics">the metrics factory</param>
public SmartThreadPoolTaskScheduler(ITaskSchedulerConfiguration configuration,
IWaitForEventOrCancelThreadPool waitForFreeThread,
IMetrics metrics)
{
Guard.NotNull(() => configuration, configuration);
Guard.NotNull(() => waitForFreeThread, waitForFreeThread);
Guard.NotNull(() => metrics, metrics);
_configuration = configuration;
_waitForFreeThread = waitForFreeThread;
_metrics = metrics;
_groups = new ConcurrentDictionary<IWorkGroup, WorkGroupWithItem>();
_clients = new ConcurrentDictionary<int, int>();
var name = GetType().Name;
_taskCounter = metrics.Counter($"{name}.TaskCounter", Units.Items);
_clientCounter = metrics.Counter($"{name}.ClientCounter", Units.Items);
}
/// <summary>
/// Initializes a new instance of the <see cref="LinqCompileCacheDecorator" /> class.
/// </summary>
/// <param name="handler">The handler.</param>
/// <param name="cache">The cache.</param>
/// <param name="cachePolicy">The cache policy.</param>
/// <param name="metrics">The metrics.</param>
/// <param name="connectionInformation">The connection information.</param>
public LinqCompileCacheDecorator(
ILinqCompiler handler,
ObjectCache cache,
ICachePolicy<ILinqCompiler> cachePolicy,
IMetrics metrics,
IConnectionInformation connectionInformation)
{
_handler = handler;
_cache = cache;
_itemPolicy = new CacheItemPolicy {SlidingExpiration = cachePolicy.SlidingExpiration};
var name = handler.GetType().Name;
_counterActionCacheHit = metrics.Counter($"{connectionInformation.QueueName}.{name}.LinqActionCacheHitCounter", Units.Items);
_counterActionCacheMiss = metrics.Counter($"{connectionInformation.QueueName}.{name}.LinqActionCacheMissCounter", Units.Items);
_counterActionCacheUnique = metrics.Counter($"{connectionInformation.QueueName}.{name}.LinqActionUniqueFlaggedCounter", Units.Items);
_counterFunctionCacheHit = metrics.Counter($"{connectionInformation.QueueName}.{name}.LinqFunctionCacheHiCountert", Units.Items);
_counterFunctionCacheMiss = metrics.Counter($"{connectionInformation.QueueName}.{name}.LinqFunctionCacheMissCounter", Units.Items);
_counterFunctionCacheUnique = metrics.Counter($"{connectionInformation.QueueName}.{name}.LinqFunctionUniqueFlaggedCounter", Units.Items);
}
public PollingSender(ISender sender, ICounter counter)
{
Init(sender, counter);
}
private void Init(ISender sender, ICounter counter)
{
_log = String.Empty;
_buffer = new byte[8];
_sender = sender;
_counter = counter;
_TW = new TimerWrapper();
_TW.__Tick += new EventHandler(_TT___Tick);
_TW.__Stopped += new NoParams(_TT___Stopped);
if (_sender == null)
{
throw new Exception("Attempt to init a pollimg-sender thread with null sender device.");
}
if (_counter == null)
{
throw new Exception("Attempt to init a pollimg-sender thread with null polling device.");
}
}
public static SurrogateForICounter Convert(ICounter value)
{
if (value == null) return null;
return new SurrogateForICounter { Target = ((CounterRef)value).Target };
}
private StatsTableData PopulateStatsTableDataEntry(ICounter statsCounter)
{
string statValue = statsCounter.IsValueDelta ? statsCounter.GetDeltaString() : statsCounter.GetValueString();
if ("0".Equals(statValue))
{
// Skip writing empty records
return null;
}
counter++;
var entry = new StatsTableData { StatValue = statValue };
// We store the statistics grouped by an hour in the same partition and sorted by reverse ticks within the partition.
// Since by default Azure table stores Entities in ascending order based on the Row Key - if we just used the current ticks
// it would return the oldest entry first.
// If we store the rows in the reverse order (some max value - current ticks), it will return the latest most recent entry first.
// More details here:
// http://gauravmantri.com/2012/02/17/effective-way-of-fetching-diagnostics-data-from-windows-azure-diagnostics-table-hint-use-partitionkey/
// https://alexandrebrisebois.wordpress.com/2014/06/16/using-time-based-partition-keys-in-azure-table-storage/
// https://stackoverflow.com/questions/1004698/how-to-truncate-milliseconds-off-of-a-net-datetime
// Our format:
// PartitionKey: DeploymentId$ReverseTimestampToTheNearestHour
// RowKey: ReverseTimestampToTheNearestSecond$Name$counter
var now = DateTime.UtcNow;
// number of ticks remaining until the year 9683
var ticks = DateTime.MaxValue.Ticks - now.Ticks;
// partition the table according to the deployment id and hour
entry.PartitionKey = string.Join("$", deploymentId, string.Format("{0:d19}", ticks - ticks % TimeSpan.TicksPerHour));
var counterStr = String.Format("{0:000000}", counter);
// order the rows latest-first in the table
entry.RowKey = string.Join("$", string.Format("{0:d19}", ticks), name, counterStr);
entry.DeploymentId = deploymentId;
entry.Time = now.ToString(DATE_TIME_FORMAT, CultureInfo.InvariantCulture); ;
entry.Address = address;
entry.Name = name;
entry.HostName = myHostName;
entry.Statistic = statsCounter.Name;
entry.IsDelta = statsCounter.IsValueDelta;
return entry;
}
public void ReportCounter(string name, ICounter value, Unit unit)
{
}
/**
* Setter for the counter.
*/
virtual public void SetCounter(ICounter counter) {
this.counter = counter;
}
private IEnumerable<PerformanceCounterInfo> GetPerformanceCounterInfos(ICounter counter)
{
return this.GetPerformanceCounters(counter.CategoryName, counter.CounterName, counter.InstanceName, counter.MachineName)
.Select(p => new PerformanceCounterInfo(p, counter))
.ToList();
}
private static void SetupDummyCounters()
{
useDummyCounters = true;
ConnectedClients = new DummyCounter(connectedClients);
FlushEventRoundTripTime = new DummyCounter(flusheventRoundtripTime);
FlushEventsReceived = new DummyCounter(flusheventsReceivedSec);
FlushOperationsSent = new DummyCounter("Flush Operations Sent / sec");
ReceivedOperationResponse = new DummyCounter(receivedOperationResponsesSec);
ReliableEventsReceived = new DummyCounter(reliableEventsReceivedSec);
ReliableEventRoundTripTime = new DummyCounter(reliableEventRoundtripTime);
ReliableOperationsSent = new DummyCounter(reliableOperationsSentSec);
RoundTripTime = new DummyCounter(roundtripTime);
RoundTripTimeVariance = new DummyCounter(roundtripTimeVariance);
UnreliableEventRoundTripTime = new DummyCounter(unreliableEventRoundtripTime);
UnreliableEventsReceived = new DummyCounter(unreliableEventsReceivedSec);
UnreliableOperationsSent = new DummyCounter(unreliableOperationsSentSec);
// Base counters:
FlusheventRoundtripTimeBase = new DummyCounter(flushEventRoundtripTimeBase);
ReliableEventRoundtripTimeBase = new DummyCounter(reliableEventRoundtripTimeBase);
RoundtripTimeBase = new DummyCounter(roundtripTimeBase);
RoundtripTimeVarianceBase = new DummyCounter(roundtripTimeVarianceBase);
UnreliableEventRoundtripTimeBase = new DummyCounter(unreliableEventRoundtripTimeBase);
}
private static void SetupPerformanceCounters()
{
if (!PerformanceCounterCategory.Exists(CategoryName))
{
Category = PerformanceCounterCategory.Create(
CategoryName,
string.Empty,
PerformanceCounterCategoryType.MultiInstance,
new CounterCreationDataCollection(
new[]
{
new CounterCreationData(connectedClients, string.Empty, PerformanceCounterType.NumberOfItems64),
new CounterCreationData(flusheventRoundtripTime, string.Empty, PerformanceCounterType.AverageCount64),
new CounterCreationData(flushEventRoundtripTimeBase, string.Empty, PerformanceCounterType.AverageBase),
new CounterCreationData(flusheventsReceivedSec, string.Empty, PerformanceCounterType.RateOfCountsPerSecond64),
new CounterCreationData(flushoperationsSentSec, string.Empty, PerformanceCounterType.RateOfCountsPerSecond64),
new CounterCreationData(receivedOperationResponsesSec, string.Empty, PerformanceCounterType.RateOfCountsPerSecond64),
new CounterCreationData(reliableEventRoundtripTime, string.Empty, PerformanceCounterType.AverageCount64),
new CounterCreationData(reliableEventRoundtripTimeBase, string.Empty, PerformanceCounterType.AverageBase),
new CounterCreationData(reliableEventsReceivedSec, string.Empty, PerformanceCounterType.RateOfCountsPerSecond64),
new CounterCreationData(reliableOperationsSentSec, string.Empty, PerformanceCounterType.RateOfCountsPerSecond64),
new CounterCreationData(roundtripTime, string.Empty, PerformanceCounterType.AverageCount64),
new CounterCreationData(roundtripTimeBase, string.Empty, PerformanceCounterType.AverageBase),
new CounterCreationData(roundtripTimeVariance, string.Empty, PerformanceCounterType.AverageCount64),
new CounterCreationData(roundtripTimeVarianceBase, string.Empty, PerformanceCounterType.AverageBase),
new CounterCreationData(unreliableEventRoundtripTime, string.Empty, PerformanceCounterType.AverageCount64),
new CounterCreationData(unreliableEventRoundtripTimeBase, string.Empty, PerformanceCounterType.AverageBase),
new CounterCreationData(unreliableEventsReceivedSec, string.Empty, PerformanceCounterType.RateOfCountsPerSecond64),
new CounterCreationData(unreliableOperationsSentSec, string.Empty, PerformanceCounterType.RateOfCountsPerSecond64)
}));
}
else
{
var list = PerformanceCounterCategory.GetCategories();
foreach (var c in list) if (c.CategoryName == CategoryName) Category = c;
}
var procId = Process.GetCurrentProcess().Id.ToString();
ConnectedClientsTotal = GetPerformanceCounter(connectedClients, "_Total", false);
ConnectedClients = new WindowsPerformanceCounter(GetPerformanceCounter(connectedClients, procId, true));
FlushEventRoundTripTime = new WindowsPerformanceCounter(GetPerformanceCounter(flusheventRoundtripTime, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, flusheventRoundtripTime, AppDomain.CurrentDomain.FriendlyName, false));
FlushEventsReceived = new WindowsPerformanceCounter(GetPerformanceCounter(flusheventsReceivedSec, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, flusheventsReceivedSec, AppDomain.CurrentDomain.FriendlyName, false));
FlushOperationsSent = new WindowsPerformanceCounter(GetPerformanceCounter(flushoperationsSentSec, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, flushoperationsSentSec, AppDomain.CurrentDomain.FriendlyName, false));
ReceivedOperationResponse = new WindowsPerformanceCounter(GetPerformanceCounter(receivedOperationResponsesSec, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, receivedOperationResponsesSec, AppDomain.CurrentDomain.FriendlyName, false));
ReliableEventsReceived = new WindowsPerformanceCounter(GetPerformanceCounter(reliableEventsReceivedSec, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, reliableEventsReceivedSec, AppDomain.CurrentDomain.FriendlyName, false));
ReliableEventRoundTripTime = new WindowsPerformanceCounter(GetPerformanceCounter(reliableEventRoundtripTime, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, reliableEventRoundtripTime, AppDomain.CurrentDomain.FriendlyName, false));
ReliableOperationsSent = new WindowsPerformanceCounter(GetPerformanceCounter(reliableOperationsSentSec, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, reliableOperationsSentSec, AppDomain.CurrentDomain.FriendlyName, false));
RoundTripTime = new WindowsPerformanceCounter(GetPerformanceCounter(roundtripTime, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, roundtripTime, AppDomain.CurrentDomain.FriendlyName, false));
RoundTripTimeVariance = new WindowsPerformanceCounter(GetPerformanceCounter(roundtripTimeVariance, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, roundtripTimeVariance, AppDomain.CurrentDomain.FriendlyName, false));
UnreliableEventRoundTripTime = new WindowsPerformanceCounter(GetPerformanceCounter(unreliableEventRoundtripTime, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, unreliableEventRoundtripTime, AppDomain.CurrentDomain.FriendlyName, false));
UnreliableEventsReceived = new WindowsPerformanceCounter(GetPerformanceCounter(unreliableEventsReceivedSec, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, unreliableEventsReceivedSec, AppDomain.CurrentDomain.FriendlyName, false));
UnreliableOperationsSent = new WindowsPerformanceCounter(GetPerformanceCounter(unreliableOperationsSentSec, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, unreliableOperationsSentSec, AppDomain.CurrentDomain.FriendlyName, false));
// base counters:
FlusheventRoundtripTimeBase = new WindowsPerformanceCounter(GetPerformanceCounter(flushEventRoundtripTimeBase, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, flushEventRoundtripTimeBase, AppDomain.CurrentDomain.FriendlyName, false));
ReliableEventRoundtripTimeBase = new WindowsPerformanceCounter(GetPerformanceCounter(reliableEventRoundtripTimeBase, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, reliableEventRoundtripTimeBase, AppDomain.CurrentDomain.FriendlyName, false));
RoundtripTimeBase = new WindowsPerformanceCounter(GetPerformanceCounter(roundtripTimeBase, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, roundtripTimeBase, AppDomain.CurrentDomain.FriendlyName, false));
RoundtripTimeVarianceBase = new WindowsPerformanceCounter(GetPerformanceCounter(roundtripTimeVarianceBase, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, roundtripTimeVarianceBase, AppDomain.CurrentDomain.FriendlyName, false));
UnreliableEventRoundtripTimeBase = new WindowsPerformanceCounter(GetPerformanceCounter(unreliableEventRoundtripTimeBase, "_Total", false));
// new WindowsPerformanceCounter(
// new PerformanceCounter(CategoryName, unreliableEventRoundtripTimeBase, AppDomain.CurrentDomain.FriendlyName, false));
TotalTimer = new Timer(new TimerCallback(UpdateTotalCounters), null, 1000, 0);
}
public void SetSelf(ICounter self)
{
this.self = self;
}
private SqlCommand ConvertToStatisticsRow(ICounter counter, SqlCommand command)
{
string statValue = counter.IsValueDelta ? counter.GetDeltaString() : counter.GetValueString();
if ("0".Equals(statValue)) return null; // Skip writing empty records
var name = (isSilo) ? siloName : clientId;
var id = (isSilo) ? siloAddress.ToLongString() : string.Format("{0}:{1}", name, generation);
++idCounter;
command.Parameters.Add(new SqlParameter { ParameterName = "@deploymentid", DbType = DbType.String, Value = deploymentId });
command.Parameters.Add(new SqlParameter { ParameterName = "@date", DbType = DbType.Date, Value = DateTime.UtcNow });
command.Parameters.Add(new SqlParameter { ParameterName = "@timestamp", DbType = DbType.DateTime, Value = DateTime.UtcNow });
command.Parameters.Add(new SqlParameter { ParameterName = "@id", DbType = DbType.String, Value = id });
command.Parameters.Add(new SqlParameter { ParameterName = "@counter", DbType = DbType.Int64, Value = idCounter });
command.Parameters.Add(new SqlParameter { ParameterName = "@hostname", DbType = DbType.String, Value = myHostName });
command.Parameters.Add(new SqlParameter { ParameterName = "@name", DbType = DbType.String, Value = name });
command.Parameters.Add(new SqlParameter { ParameterName = "@isdelta", DbType = DbType.Boolean, Value = counter.IsValueDelta });
command.Parameters.Add(new SqlParameter { ParameterName = "@statvalue", DbType = DbType.String, Value = statValue });
command.Parameters.Add(new SqlParameter { ParameterName = "@statistic", DbType = DbType.String, Value = counter.Name });
return command;
}
public override void OnLoad(string name, LookingGlassBase lgbase)
{
base.OnLoad(name, lgbase);
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.InputSystem.Name",
"OgreUI",
"Module to handle user IO on the rendering screen");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Name", "LookingGlass",
"Name of the Ogre resources to load");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.SkyboxName", "LookingGlass/CloudyNoonSkyBox",
"Name of the skybox resource to use");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.ShadowTechnique", "none",
"Shadow technique: none, texture-additive, texture-modulative, stencil-modulative, stencil-additive");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.ShadowFarDistance", "400",
"Integer units of distance within which to do shadows (mul by magnification)");
// cp.AddParameter(m_moduleName + ".Ogre.Renderer", "Direct3D9 Rendering Subsystem",
// "Name of the rendering subsystem to use");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Renderer", "OpenGL Rendering Subsystem",
"Name of the rendering subsystem to use");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.VideoMode", "800 x 600@ 32-bit colour",
"Initial window size");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.FramePerSecMax", "30",
"Maximum number of frames to display per second");
ModuleParams.AddDefaultParameter(m_moduleName + ".ShouldRenderOnMainThread", "false",
"True if ogre rendering otherwise someone has to call RenderOneFrame");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.PluginFilename", "plugins.cfg",
"File that lists Ogre plugins to load");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.ResourcesFilename", "resources.cfg",
"File that lists the Ogre resources to load");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.DefaultNumMipmaps", "2",
"Default number of mip maps created for a texture (usually 6)");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.CacheDir", Utilities.GetDefaultApplicationStorageDir(null),
"Directory to store cached meshs, textures, etc");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.PreLoadedDir",
System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "./LookingGlassResources/Preloaded/"),
"Directory to for preloaded textures, etc");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.DefaultTerrainMaterial",
"LookingGlass/DefaultTerrainMaterial",
"Material applied to terrain");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Ocean.Processor",
"none",
"The processing routine to create the ocean. Either 'none' or 'hydrax'");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.OceanMaterialName",
"LookingGlass/Ocean",
"The ogre name of the ocean texture");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.DefaultMeshFilename",
System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "./LookingGlassResources/LoadingShape.mesh"),
"Filename of the default shape found in the cache dir");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.DefaultTextureFilename",
System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "./LookingGlassResources/LoadingTexture.png"),
"Filename of the default texture found in the cache dir");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.DefaultTextureResourceName",
"LoadingTexture.png",
"Resource name of the default texture");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.WhiteTextureResourceName",
"Preload/" + OMV.Primitive.TextureEntry.WHITE_TEXTURE.ToString().Substring(0,1)
+ "/" + OMV.Primitive.TextureEntry.WHITE_TEXTURE.ToString(),
"Resource name of a white texture used as default base color");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.LL.SceneMagnification", "1",
"Magnification of LL coordinates into Ogre space");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.LL.RenderInfoMaterialCreate", "true",
"Create materials while gathering mesh generation info (earlier than mesh creation)");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.LL.EarlyMaterialCreate", "false",
"Create materials while creating mesh rather than waiting");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.LL.DefaultAvatarMesh",
// "Preload/00000000-0000-2222-3333-112200000003",
"", // read definition from LAD file
"Entity name of mesh to use for avatars");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.BetweenFrame.WorkMilliSecondsMax", "300",
"Cost of queued C++ work items to do between each frame");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.BetweenFrame.Costs.Total", "200",
"The total cost of C# operations to do between each frame");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.SerializeMaterials", "false",
"Write out materials to files (replace with DB someday)");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.SerializeMeshes", "true",
"Write out meshes to files");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.ForceMeshRebuild", "false",
"True if to force the generation a mesh when first rendered (don't rely on cache)");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.PrebuildMesh", "true",
"True if to make sure the mesh exists before creating the scene node");
ModuleParams.AddDefaultParameter(m_moduleName + ".ShouldShareMeshes", "false",
"True if to share meshes with similar characteristics");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.UseShaders", "true",
"Whether to use the new technique of using GPU shaders");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.CollectOgreStats", "true",
"Whether to collect detailed Ogre stats and make available to web");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.ShouldQueueMeshOperations", "true",
"True if to try and use threads and delayed mesh load and unload operations");
ModuleParams.AddDefaultParameter(m_moduleName + ".Avatar.Mesh.InfoDir", "./LookingGlassResources/openmetaverse_data",
"Directory containing avatar description information");
ModuleParams.AddDefaultParameter(m_moduleName + ".Avatar.Mesh.Description", "avatar_lad.xml",
"File containing detailed avatar mesh description");
ModuleParams.AddDefaultParameter(m_moduleName + ".Avatar.Mesh.DescriptionDir", "./LookingGlassResources/character",
"Directory with detailed avatar mesh description info");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Sky", "Default",
"Name of the key system to use");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.SkyX.LightingHDR", "true",
"Use high resolution lighting shaders");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Camera.NearClip", "2.0",
"Initial camera near clip distance");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Camera.FarClip", "30000.0",
"Initial camera far clip distance");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Ambient.Scene", "<0.4,0.4,0.4>",
"color value for scene initial ambient lighting");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Ambient.Material", "<0.4,0.4,0.4>",
"color value for material ambient lighting");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Sun.Color", "<1.0,1.0,1.0>",
"Color of light from the sun at noon");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Moon.Color", "<0.6,0.6,0.8>",
"Color of light from the moon");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.Processor", "FrustrumDistance",
"Name of the culling plugin to use ('FrustrumDistance', 'VariableFrustDist', 'none')");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.Cull.Frustrum", "false",
"whether to cull (unload) objects if not visible in camera frustrum");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.Cull.Distance", "false",
"whether to cull (unload) objects depending on distance from camera");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.Cull.Meshes", "true",
"unload culled object meshes");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.Cull.Textures", "true",
"unload culled textures");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.MaxDistance", "200",
"the maximum distance to see any entites (far clip)");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.MinDistance", "30",
"below this distance, everything is visible");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.OnlyLargeAfter", "120",
"After this distance, only large things are visible");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.Large", "8",
"How big is considered 'large' for 'OnlyLargeAfter' calculation");
ModuleParams.AddDefaultParameter(m_moduleName + ".Ogre.Visibility.MeshesReloadedPerFrame", "80",
"When reloading newly visible meshes, how many to load per frame");
// some counters and intervals to see how long things take
m_stats = new StatisticManager(m_moduleName);
m_statMaterialsRequested = m_stats.GetCounter("MaterialsRequested");
m_statMeshesRequested = m_stats.GetCounter("MeshesRequested");
m_statTexturesRequested = m_stats.GetCounter("TexturesRequested");
m_statSharableTotal = m_stats.GetCounterValue("TotalMeshes", delegate() { return (long)prebuiltMeshes.Count; });
m_statRequestedMeshes = m_stats.GetCounterValue("RequestedMeshes", delegate() { return (long)m_requestedMeshes.Count; });
m_statRequestedMeshes = m_stats.GetCounterValue("PrebuiltMeshes", delegate() {
return (long)RenderPrim.prebuiltMeshes.Count;
});
m_statShareInstances = m_stats.GetCounter("TotalSharedInstances");
// renderer keeps rendering specific data in an entity's addition/subsystem slots
AddSceneNodeName = EntityBase.AddAdditionSubsystem(RendererOgre.AddSceneNodeNameName);
AddRegionSceneNode = EntityBase.AddAdditionSubsystem(RendererOgre.AddRegionSceneNodeName);
}
public Spiral(VectorInt center, ICounter diameter, ICounter angle)
{
this.center = center;
this.diameter = diameter;
this.angle = angle;
}
public Spiral(VectorInt Center)
{
center = Center;
diameter = new Counter(0, 50, 0.3f);
angle = new Counter(0, 360, 5);
}
public Game(ICounter counter)
{
_counter = counter;
this.Scores = new List<Score> ();
}
public Processor(ICounter counter, IRepository repository)
{
_counter = counter;
_repository = repository;
}
