public Catalog(
ILocalSiloDetails localSiloDetails,
GrainLocator grainLocator,
GrainDirectoryResolver grainDirectoryResolver,
ILocalGrainDirectory grainDirectory,
ActivationDirectory activationDirectory,
ActivationCollector activationCollector,
IServiceProvider serviceProvider,
ILoggerFactory loggerFactory,
IOptions <GrainCollectionOptions> collectionOptions,
RuntimeMessagingTrace messagingTrace,
GrainContextActivator grainActivator,
GrainPropertiesResolver grainPropertiesResolver)
: base(Constants.CatalogType, localSiloDetails.SiloAddress, loggerFactory)
{
this.LocalSilo = localSiloDetails.SiloAddress;
this.localSiloName = localSiloDetails.Name;
this.grainLocator = grainLocator;
this.grainDirectoryResolver = grainDirectoryResolver;
this.directory = grainDirectory;
this.activations = activationDirectory;
this.serviceProvider = serviceProvider;
this.collectionOptions = collectionOptions;
this.grainActivator = grainActivator;
this.grainPropertiesResolver = grainPropertiesResolver;
this.logger = loggerFactory.CreateLogger <Catalog>();
this.activationCollector = activationCollector;
this.RuntimeClient = serviceProvider.GetRequiredService <InsideRuntimeClient>();
GC.GetTotalMemory(true); // need to call once w/true to ensure false returns OK value
IntValueStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COUNT, () => activations.Count);
activationsCreated = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_CREATED);
activationsDestroyed = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_DESTROYED);
IntValueStatistic.FindOrCreate(StatisticNames.MESSAGING_PROCESSING_ACTIVATION_DATA_ALL, () =>
{
long counter = 0;
lock (activations)
{
foreach (var activation in activations)
{
if (activation.Value is ActivationData data)
{
counter += data.GetRequestCount();
}
}
}
return(counter);
});
grainDirectory.SetSiloRemovedCatalogCallback(this.OnSiloStatusChange);
RegisterSystemTarget(this);
}
public static IntValueStatistic FindOrCreate(StatisticName name, Func <long> f, CounterStorage storage = CounterStorage.LogOnly)
{
lock (dict)
{
if (dict.TryGetValue(name.Name, out var stat))
{
return(stat);
}
var ctr = new IntValueStatistic(name.Name, f)
{
Storage = storage
};
dict[name.Name] = ctr;
return(ctr);
}
}
static public IntValueStatistic FindOrCreate(StatisticName name, Func <long> f, CounterStorage storage = CounterStorage.LogOnly)
{
lock (lockable)
{
IntValueStatistic stat;
if (registeredStatistics.TryGetValue(name.Name, out stat))
{
return(stat);
}
var ctr = new IntValueStatistic(name.Name, f)
{
Storage = storage
};
registeredStatistics[name.Name] = ctr;
return(ctr);
}
}
internal ClientTableStatistics(
IMessageCenter mc,
IClientMetricsDataPublisher metricsDataPublisher,
IHostEnvironmentStatistics hostEnvironmentStatistics,
IAppEnvironmentStatistics appEnvironmentStatistics,
ILoggerFactory loggerFactory)
{
this.mc = mc;
this.metricsDataPublisher = metricsDataPublisher;
this.logger = loggerFactory.CreateLogger <ClientTableStatistics>();
//async timer created through current class all share this logger for perf reasons
this.timerLogger = loggerFactory.CreateLogger <AsyncTaskSafeTimer>();
this.hostEnvironmentStatistics = hostEnvironmentStatistics;
this.appEnvironmentStatistics = appEnvironmentStatistics;
reportFrequency = TimeSpan.Zero;
connectedGatewayCount = IntValueStatistic.Find(StatisticNames.CLIENT_CONNECTED_GATEWAY_COUNT);
}
internal async Task DumpCounters()
{
List <ICounter> allCounters = new List <ICounter>();
CounterStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
IntValueStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
StringValueStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
FloatValueStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
AverageTimeSpanStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
foreach (var stat in allCounters.Where(cs => cs.Storage != CounterStorage.DontStore).OrderBy(cs => cs.Name))
{
WriteStatsLogEntry(stat.GetDisplayString());
}
List <ICounter> additionalCounters = GenerateAdditionalCounters();
// NOTE: For now, we don't want to bother logging these counters -- AG 11/20/2012
foreach (var stat in additionalCounters.OrderBy(cs => cs.Name))
{
WriteStatsLogEntry(stat.GetDisplayString());
}
WriteStatsLogEntry(null); // Write any remaining log data
try
{
if (StatsTablePublisher != null && allCounters.Count > 0)
{
await StatsTablePublisher.ReportStats(allCounters);
}
}
catch (Exception exc)
{
var e = exc.GetBaseException();
logger.Error(ErrorCode.AzureTable_35, "Exception occurred during Stats reporter.", e);
}
// Reset current value for counter that have delta.
// Do it ONLY after all counters have been logged.
foreach (ICounter stat in allCounters.Where(cs => cs.Storage != CounterStorage.DontStore).Union(additionalCounters).Where(cs => cs.IsValueDelta))
{
stat.ResetCurrent();
}
}
internal void DumpCounters()
{
List <ICounter> allCounters = new List <ICounter>();
CounterStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
IntValueStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
StringValueStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
FloatValueStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
AverageTimeSpanStatistic.AddCounters(allCounters, cs => cs.Storage != CounterStorage.DontStore);
foreach (var stat in allCounters.Where(cs => cs.Storage != CounterStorage.DontStore).OrderBy(cs => cs.Name))
{
WriteStatsLogEntry(stat.GetDisplayString());
}
WriteStatsLogEntry(null); // Write any remaining log data
// Reset current value for counter that have delta.
// Do it ONLY after all counters have been logged.
foreach (ICounter stat in allCounters.Where(cs => cs.Storage != CounterStorage.DontStore).Where(cs => cs.IsValueDelta))
{
stat.ResetCurrent();
}
}
/// <summary>
/// Creates a buffer pool.
/// </summary>
/// <param name="bufferSize">The size, in bytes, of each buffer.</param>
/// <param name="maxBuffers">The maximum number of buffers to keep around, unused; by default, the number of unused buffers is unbounded.</param>
private BufferPool(int bufferSize, int maxBuffers, int preallocationSize, string name)
{
Name = name;
byteBufferSize = bufferSize;
maxBuffersCount = maxBuffers;
limitBuffersCount = maxBuffers > 0;
buffers = new ConcurrentBag <byte[]>();
var globalPoolSizeStat = IntValueStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BUFFERPOOL_BUFFERS_INPOOL,
() => Count);
allocatedBufferCounter = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BUFFERPOOL_ALLOCATED_BUFFERS);
checkedOutBufferCounter = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BUFFERPOOL_CHECKED_OUT_BUFFERS);
checkedInBufferCounter = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BUFFERPOOL_CHECKED_IN_BUFFERS);
droppedBufferCounter = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BUFFERPOOL_DROPPED_BUFFERS);
droppedTooLargeBufferCounter = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BUFFERPOOL_DROPPED_TOO_LARGE_BUFFERS);
// Those 2 counters should be equal. If not, it means we don't release all buffers.
IntValueStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BUFFERPOOL_INUSE_CHECKED_OUT_NOT_CHECKED_IN_BUFFERS,
() => checkedOutBufferCounter.GetCurrentValue()
- checkedInBufferCounter.GetCurrentValue()
- droppedBufferCounter.GetCurrentValue());
IntValueStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BUFFERPOOL_INUSE_ALLOCATED_NOT_INPOOL_BUFFERS,
() => allocatedBufferCounter.GetCurrentValue()
- globalPoolSizeStat.GetCurrentValue()
- droppedBufferCounter.GetCurrentValue());
if (preallocationSize <= 0)
{
return;
}
var dummy = GetMultiBuffer(preallocationSize * Size);
Release(dummy);
}
internal void Start()
{
if (!countersAvailable)
{
logger.Warn(ErrorCode.PerfCounterNotRegistered,
"CPU & Memory perf counters did not initialize correctly - try repairing Windows perf counter config on this machine with 'lodctr /r' command");
return;
}
cpuUsageTimer = new SafeTimer(CheckCpuUsage, null, CPU_CHECK_PERIOD, CPU_CHECK_PERIOD);
try
{
// Read initial value of CPU Usage counter
CpuUsage = cpuCounter.NextValue();
}
catch (InvalidOperationException)
{
// Can sometimes get exception accessing CPU Usage counter for first time in some runtime environments
CpuUsage = 0;
}
FloatValueStatistic.FindOrCreate(StatisticNames.RUNTIME_CPUUSAGE, () => CpuUsage);
IntValueStatistic.FindOrCreate(StatisticNames.RUNTIME_GC_TOTALMEMORYKB, () => (MemoryUsage + 1023) / 1024); // Round up
#if LOG_MEMORY_PERF_COUNTERS // print GC stats in the silo log file.
StringValueStatistic.FindOrCreate(StatisticNames.RUNTIME_GC_GENCOLLECTIONCOUNT, () => GCGenCollectionCount);
StringValueStatistic.FindOrCreate(StatisticNames.RUNTIME_GC_GENSIZESKB, () => GCGenSizes);
FloatValueStatistic.FindOrCreate(StatisticNames.RUNTIME_GC_PERCENTOFTIMEINGC, () => timeInGC.NextValue());
FloatValueStatistic.FindOrCreate(StatisticNames.RUNTIME_GC_ALLOCATEDBYTESINKBPERSEC, () => allocatedBytesPerSec.NextValue() / 1024f);
FloatValueStatistic.FindOrCreate(StatisticNames.RUNTIME_GC_PROMOTEDMEMORYFROMGEN1KB, () => promotedMemoryFromGen1.NextValue() / 1024f);
FloatValueStatistic.FindOrCreate(StatisticNames.RUNTIME_GC_LARGEOBJECTHEAPSIZEKB, () => largeObjectHeapSize.NextValue() / 11024f);
FloatValueStatistic.FindOrCreate(StatisticNames.RUNTIME_GC_PROMOTEDMEMORYFROMGEN0KB, () => promotedFinalizationMemoryFromGen0.NextValue() / 1024f);
FloatValueStatistic.FindOrCreate(StatisticNames.RUNTIME_GC_NUMBEROFINDUCEDGCS, () => numberOfInducedGCs.NextValue());
IntValueStatistic.FindOrCreate(StatisticNames.RUNTIME_MEMORY_TOTALPHYSICALMEMORYMB, () => (TotalPhysicalMemory / 1024) / 1024);
if (availableMemoryCounter != null)
{
IntValueStatistic.FindOrCreate(StatisticNames.RUNTIME_MEMORY_AVAILABLEMEMORYMB, () => (AvailableMemory / 1024) / 1024); // Round up
}
#endif
IntValueStatistic.FindOrCreate(StatisticNames.RUNTIME_DOT_NET_THREADPOOL_INUSE_WORKERTHREADS, () =>
{
int maXworkerThreads;
int maXcompletionPortThreads;
ThreadPool.GetMaxThreads(out maXworkerThreads, out maXcompletionPortThreads);
int workerThreads;
int completionPortThreads;
// GetAvailableThreads Retrieves the difference between the maximum number of thread pool threads
// and the number currently active.
// So max-Available is the actual number in use. If it goes beyond min, it means we are stressing the thread pool.
ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
return(maXworkerThreads - workerThreads);
});
IntValueStatistic.FindOrCreate(StatisticNames.RUNTIME_DOT_NET_THREADPOOL_INUSE_COMPLETIONPORTTHREADS, () =>
{
int maXworkerThreads;
int maXcompletionPortThreads;
ThreadPool.GetMaxThreads(out maXworkerThreads, out maXcompletionPortThreads);
int workerThreads;
int completionPortThreads;
ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
return(maXcompletionPortThreads - completionPortThreads);
});
}
