/// <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>
/// <param name="preallocationSize">Initial number of buffers to allocate.</param>
/// <param name="name">Name of the buffer pool.</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);
}
public void Counter_Increment()
{
StatisticName name = new StatisticName(CounterName);
CounterStatistic ctr = CounterStatistic.FindOrCreate(name);
Assert.Equal(0, ctr.GetCurrentValue());
ctr.Increment();
Assert.Equal(1, ctr.GetCurrentValue());
}
public void Counter_DecrementBy()
{
StatisticName name = new StatisticName(CounterName);
int startValue = 10;
int newValue = startValue - 1;
CounterStatistic ctr = CounterStatistic.FindOrCreate(name);
ctr.IncrementBy(startValue);
Assert.Equal(startValue, ctr.GetCurrentValue());
ctr.DecrementBy(1);
Assert.Equal(newValue, ctr.GetCurrentValue());
}
public void Counter_IncrementFromMinInt()
{
StatisticName name = new StatisticName(CounterName);
int val = int.MinValue;
CounterStatistic ctr = CounterStatistic.FindOrCreate(name);
ctr.IncrementBy(val);
Assert.Equal(val, ctr.GetCurrentValue());
ctr.Increment();
Assert.Equal(val + 1, ctr.GetCurrentValue());
ctr.Increment();
Assert.Equal(val + 2, ctr.GetCurrentValue());
}
public void Counter_IncrementBy()
{
StatisticName name = new StatisticName(CounterName);
int val = random.Next(1000000);
CounterStatistic ctr = CounterStatistic.FindOrCreate(name);
ctr.IncrementBy(val);
Assert.Equal(val, ctr.GetCurrentValue());
ctr.Increment();
Assert.Equal(val + 1, ctr.GetCurrentValue());
ctr.Increment();
Assert.Equal(val + 2, ctr.GetCurrentValue());
}
// Used for holding enough info to handle receive completion
internal IncomingMessageAcceptor(MessageCenter msgCtr, IPEndPoint here, SocketDirection socketDirection, MessageFactory messageFactory, SerializationManager serializationManager,
ExecutorService executorService, ILoggerFactory loggerFactory)
: base(executorService, loggerFactory)
{
this.loggerFactory = loggerFactory;
Log = new LoggerWrapper <IncomingMessageAcceptor>(loggerFactory);
MessageCenter = msgCtr;
listenAddress = here;
this.MessageFactory = messageFactory;
this.receiveEventArgsPool = new ConcurrentObjectPool <SaeaPoolWrapper>(() => this.CreateSocketReceiveAsyncEventArgsPoolWrapper());
this.serializationManager = serializationManager;
if (here == null)
{
listenAddress = MessageCenter.MyAddress.Endpoint;
}
AcceptingSocket = MessageCenter.SocketManager.GetAcceptingSocketForEndpoint(listenAddress);
Log.Info(ErrorCode.Messaging_IMA_OpenedListeningSocket, "Opened a listening socket at address " + AcceptingSocket.LocalEndPoint);
OpenReceiveSockets = new HashSet <Socket>();
OnFault = FaultBehavior.CrashOnFault;
SocketDirection = socketDirection;
checkedOutSocketEventArgsCounter = CounterStatistic.FindOrCreate(StatisticNames.MESSAGE_ACCEPTOR_CHECKED_OUT_SOCKET_EVENT_ARGS, false);
checkedInSocketEventArgsCounter = CounterStatistic.FindOrCreate(StatisticNames.MESSAGE_ACCEPTOR_CHECKED_IN_SOCKET_EVENT_ARGS, false);
IntValueStatistic.FindOrCreate(StatisticNames.MESSAGE_ACCEPTOR_IN_USE_SOCKET_EVENT_ARGS,
() => checkedOutSocketEventArgsCounter.GetCurrentValue() - checkedInSocketEventArgsCounter.GetCurrentValue());
}
public void Counter_IncrementFromMaxInt()
{
StatisticName name = new StatisticName("Counter6");
int val = int.MaxValue;
long longVal = int.MaxValue;
Assert.AreEqual(longVal, val);
CounterStatistic ctr = CounterStatistic.FindOrCreate(name);
ctr.IncrementBy(val);
Assert.AreEqual(val, ctr.GetCurrentValue());
ctr.Increment();
Assert.AreEqual(longVal + 1, ctr.GetCurrentValue());
ctr.Increment();
Assert.AreEqual(longVal + 2, ctr.GetCurrentValue());
}
public SerializationStatisticsGroup(IOptions <StatisticsOptions> statisticsOptions)
{
this.CollectSerializationStats = statisticsOptions.Value.CollectionLevel >= StatisticsLevel.Verbose;
if (this.CollectSerializationStats)
{
const CounterStorage store = CounterStorage.LogOnly;
Copies = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_DEEPCOPIES, store);
Serializations = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_SERIALIZATION, store);
Deserializations = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_DESERIALIZATION, store);
HeaderSers = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_HEADER_SERIALIZATION, store);
HeaderDesers = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_HEADER_DESERIALIZATION, store);
HeaderSersNumHeaders = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_HEADER_SERIALIZATION_NUMHEADERS, store);
HeaderDesersNumHeaders = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_HEADER_DESERIALIZATION_NUMHEADERS, store);
CopyTimeStatistic = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_DEEPCOPY_MILLIS, store).AddValueConverter(Utils.TicksToMilliSeconds);
SerTimeStatistic = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_SERIALIZATION_MILLIS, store).AddValueConverter(Utils.TicksToMilliSeconds);
DeserTimeStatistic = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_DESERIALIZATION_MILLIS, store).AddValueConverter(Utils.TicksToMilliSeconds);
HeaderSerTime = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_HEADER_SERIALIZATION_MILLIS, store).AddValueConverter(Utils.TicksToMilliSeconds);
HeaderDeserTime = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_HEADER_DESERIALIZATION_MILLIS, store).AddValueConverter(Utils.TicksToMilliSeconds);
TotalTimeInSerializer = IntValueStatistic.FindOrCreate(
StatisticNames.SERIALIZATION_TOTAL_TIME_IN_SERIALIZER_MILLIS,
() =>
{
long ticks = CopyTimeStatistic.GetCurrentValue() +
SerTimeStatistic.GetCurrentValue() +
DeserTimeStatistic.GetCurrentValue() +
HeaderSerTime.GetCurrentValue() +
HeaderDeserTime.GetCurrentValue();
return(Utils.TicksToMilliSeconds(ticks));
},
CounterStorage.LogAndTable);
const CounterStorage storeFallback = CounterStorage.LogOnly;
FallbackSerializations = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_FALLBACK_SERIALIZATION, storeFallback);
FallbackDeserializations = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_FALLBACK_DESERIALIZATION, storeFallback);
FallbackCopies = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_FALLBACK_DEEPCOPIES, storeFallback);
FallbackSerTimeStatistic = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_FALLBACK_SERIALIZATION_MILLIS, storeFallback)
.AddValueConverter(Utils.TicksToMilliSeconds);
FallbackDeserTimeStatistic = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_FALLBACK_DESERIALIZATION_MILLIS, storeFallback)
.AddValueConverter(Utils.TicksToMilliSeconds);
FallbackCopiesTimeStatistic = CounterStatistic.FindOrCreate(StatisticNames.SERIALIZATION_BODY_FALLBACK_DEEPCOPY_MILLIS, storeFallback)
.AddValueConverter(Utils.TicksToMilliSeconds);
}
}
// Used for holding enough info to handle receive completion
internal IncomingMessageAcceptor(MessageCenter msgCtr, IPEndPoint here, SocketDirection socketDirection)
{
MessageCenter = msgCtr;
listenAddress = here;
if (here == null)
{
listenAddress = MessageCenter.MyAddress.Endpoint;
}
AcceptingSocket = SocketManager.GetAcceptingSocketForEndpoint(listenAddress);
Log.Info(ErrorCode.Messaging_IMA_OpenedListeningSocket, "Opened a listening socket at address " + AcceptingSocket.LocalEndPoint);
OpenReceiveSockets = new HashSet <Socket>();
OnFault = FaultBehavior.CrashOnFault;
SocketDirection = socketDirection;
checkedOutSocketEventArgsCounter = CounterStatistic.FindOrCreate(StatisticNames.MESSAGE_ACCEPTOR_CHECKED_OUT_SOCKET_EVENT_ARGS, false);
checkedInSocketEventArgsCounter = CounterStatistic.FindOrCreate(StatisticNames.MESSAGE_ACCEPTOR_CHECKED_IN_SOCKET_EVENT_ARGS, false);
IntValueStatistic.FindOrCreate(StatisticNames.MESSAGE_ACCEPTOR_IN_USE_SOCKET_EVENT_ARGS,
() => checkedOutSocketEventArgsCounter.GetCurrentValue() - checkedInSocketEventArgsCounter.GetCurrentValue());
}
public QueueTrackingStatistic(string queueName)
{
if (StatisticsCollector.CollectQueueStats)
{
const CounterStorage storage = CounterStorage.LogAndTable;
averageQueueSizeCounter = AverageValueStatistic.FindOrCreate(
new StatisticName(StatisticNames.QUEUES_QUEUE_SIZE_AVERAGE_PER_QUEUE, queueName), storage);
numEnqueuedRequestsCounter = CounterStatistic.FindOrCreate(
new StatisticName(StatisticNames.QUEUES_ENQUEUED_PER_QUEUE, queueName), false, storage);
if (TrackExtraStats)
{
totalExecutionTime = TimeIntervalFactory.CreateTimeInterval(true);
averageArrivalRate = FloatValueStatistic.FindOrCreate(
new StatisticName(StatisticNames.QUEUES_AVERAGE_ARRIVAL_RATE_PER_QUEUE, queueName),
() =>
{
TimeSpan totalTime = totalExecutionTime.Elapsed;
if (totalTime.Ticks == 0) return 0;
long numReqs = numEnqueuedRequestsCounter.GetCurrentValue();
return (float)((((double)numReqs * (double)TimeSpan.TicksPerSecond)) / (double)totalTime.Ticks);
}, storage);
}
averageTimeInQueue = AverageValueStatistic.FindOrCreate(new StatisticName(StatisticNames.QUEUES_TIME_IN_QUEUE_AVERAGE_MILLIS_PER_QUEUE, queueName), storage);
averageTimeInQueue.AddValueConverter(Utils.AverageTicksToMilliSeconds);
if (averageTimeInAllQueues == null)
{
averageTimeInAllQueues = AverageValueStatistic.FindOrCreate(new StatisticName(StatisticNames.QUEUES_TIME_IN_QUEUE_AVERAGE_MILLIS_PER_QUEUE, "AllQueues"), storage);
averageTimeInAllQueues.AddValueConverter(Utils.AverageTicksToMilliSeconds);
}
if (totalTimeInAllQueues == null)
{
totalTimeInAllQueues = CounterStatistic.FindOrCreate(
new StatisticName(StatisticNames.QUEUES_TIME_IN_QUEUE_TOTAL_MILLIS_PER_QUEUE, "AllQueues"), false, storage);
totalTimeInAllQueues.AddValueConverter(Utils.TicksToMilliSeconds);
}
}
}
internal static void Init(TimeSpan responseTimeout)
{
if (!StatisticsCollector.CollectApplicationRequestsStats) return;
const CounterStorage storage = CounterStorage.LogAndTable;
appRequestsLatencyHistogram = ExponentialHistogramValueStatistic.Create_ExponentialHistogram_ForTiming(
StatisticNames.APP_REQUESTS_LATENCY_HISTOGRAM, NUM_APP_REQUESTS_EXP_LATENCY_HISTOGRAM_CATEGORIES);
timedOutRequests = CounterStatistic.FindOrCreate(StatisticNames.APP_REQUESTS_TIMED_OUT, storage);
totalAppRequests = CounterStatistic.FindOrCreate(StatisticNames.APP_REQUESTS_TOTAL_NUMBER_OF_REQUESTS, storage);
appRequestsTotalLatency = CounterStatistic.FindOrCreate(StatisticNames.APP_REQUESTS_LATENCY_TOTAL, false, storage, true);
appRequestsAverageLatency = FloatValueStatistic.FindOrCreate(
StatisticNames.APP_REQUESTS_LATENCY_AVERAGE,
() =>
{
long totalLatencyInTicks = appRequestsTotalLatency.GetCurrentValue();
if (totalLatencyInTicks == 0) return 0;
long numReqs = totalAppRequests.GetCurrentValue();
long averageLatencyInTicks = (long)((double)totalLatencyInTicks / (double)numReqs);
return (float)Utils.TicksToMilliSeconds(averageLatencyInTicks);
}, storage);
}