/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
package org.apache.mina.core.service;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Provides usage statistics for an {@link AbstractIoService} instance.
*
* @author <a href="http://mina.apache.org">Apache MINA Project</a>
* @since 2.0.0-M3
*/
public class IoServiceStatistics {
private AbstractIoService service;
/** The number of bytes read per second */
private double readBytesThroughput;
/** The number of bytes written per second */
private double writtenBytesThroughput;
/** The number of messages read per second */
private double readMessagesThroughput;
/** The number of messages written per second */
private double writtenMessagesThroughput;
/** The biggest number of bytes read per second */
private double largestReadBytesThroughput;
/** The biggest number of bytes written per second */
private double largestWrittenBytesThroughput;
/** The biggest number of messages read per second */
private double largestReadMessagesThroughput;
/** The biggest number of messages written per second */
private double largestWrittenMessagesThroughput;
/** The number of read bytes since the service has been started */
private long readBytes;
/** The number of written bytes since the service has been started */
private long writtenBytes;
/** The number of read messages since the service has been started */
private long readMessages;
/** The number of written messages since the service has been started */
private long writtenMessages;
/** The time the last read operation occurred */
private long lastReadTime;
/** The time the last write operation occurred */
private long lastWriteTime;
private long lastReadBytes;
private long lastWrittenBytes;
private long lastReadMessages;
private long lastWrittenMessages;
private long lastThroughputCalculationTime;
private int scheduledWriteBytes;
private int scheduledWriteMessages;
/** The time (in second) between the computation of the service's statistics */
private final AtomicInteger throughputCalculationInterval = new AtomicInteger(3);
private final Lock throughputCalculationLock = new ReentrantLock();
public IoServiceStatistics(AbstractIoService service) {
this.service = service;
}
/**
* @return The maximum number of sessions which were being managed at the
* same time.
*/
public final int getLargestManagedSessionCount() {
return service.getListeners().getLargestManagedSessionCount();
}
/**
* @return The cumulative number of sessions which were managed (or are
* being managed) by this service, which means 'currently managed
* session count + closed session count'.
*/
public final long getCumulativeManagedSessionCount() {
return service.getListeners().getCumulativeManagedSessionCount();
}
/**
* @return the time in millis when the last I/O operation (read or write)
* occurred.
*/
public final long getLastIoTime() {
throughputCalculationLock.lock();
try {
return Math.max(lastReadTime, lastWriteTime);
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The time in millis when the last read operation occurred.
*/
public final long getLastReadTime() {
throughputCalculationLock.lock();
try {
return lastReadTime;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The time in millis when the last write operation occurred.
*/
public final long getLastWriteTime() {
throughputCalculationLock.lock();
try {
return lastWriteTime;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The number of bytes this service has read so far
*/
public final long getReadBytes() {
throughputCalculationLock.lock();
try {
return readBytes;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The number of bytes this service has written so far
*/
public final long getWrittenBytes() {
throughputCalculationLock.lock();
try {
return writtenBytes;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The number of messages this services has read so far
*/
public final long getReadMessages() {
throughputCalculationLock.lock();
try {
return readMessages;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The number of messages this service has written so far
*/
public final long getWrittenMessages() {
throughputCalculationLock.lock();
try {
return writtenMessages;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The number of read bytes per second.
*/
public final double getReadBytesThroughput() {
throughputCalculationLock.lock();
try {
resetThroughput();
return readBytesThroughput;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The number of written bytes per second.
*/
public final double getWrittenBytesThroughput() {
throughputCalculationLock.lock();
try {
resetThroughput();
return writtenBytesThroughput;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The number of read messages per second.
*/
public final double getReadMessagesThroughput() {
throughputCalculationLock.lock();
try {
resetThroughput();
return readMessagesThroughput;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The number of written messages per second.
*/
public final double getWrittenMessagesThroughput() {
throughputCalculationLock.lock();
try {
resetThroughput();
return writtenMessagesThroughput;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The maximum number of bytes read per second since the service has
* been started.
*/
public final double getLargestReadBytesThroughput() {
throughputCalculationLock.lock();
try {
return largestReadBytesThroughput;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The maximum number of bytes written per second since the service
* has been started.
*/
public final double getLargestWrittenBytesThroughput() {
throughputCalculationLock.lock();
try {
return largestWrittenBytesThroughput;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The maximum number of messages read per second since the service
* has been started.
*/
public final double getLargestReadMessagesThroughput() {
throughputCalculationLock.lock();
try {
return largestReadMessagesThroughput;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The maximum number of messages written per second since the
* service has been started.
*/
public final double getLargestWrittenMessagesThroughput() {
throughputCalculationLock.lock();
try {
return largestWrittenMessagesThroughput;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return the interval (seconds) between each throughput calculation. The
* default value is <tt>3</tt> seconds.
*/
public final int getThroughputCalculationInterval() {
return throughputCalculationInterval.get();
}
/**
* Returns the interval (milliseconds) between each throughput calculation.
* The default value is <tt>3</tt> seconds.
*/
public final long getThroughputCalculationIntervalInMillis() {
return throughputCalculationInterval.get() * 1000L;
}
/**
* Sets the interval (seconds) between each throughput calculation. The
* default value is <tt>3</tt> seconds.
*/
public final void setThroughputCalculationInterval(int throughputCalculationInterval) {
if (throughputCalculationInterval < 0) {
throw new IllegalArgumentException("throughputCalculationInterval: " + throughputCalculationInterval);
}
this.throughputCalculationInterval.set(throughputCalculationInterval);
}
/**
* Sets last time at which a read occurred on the service.
*
* @param lastReadTime
* The last time a read has occurred
*/
protected final void setLastReadTime(long lastReadTime) {
throughputCalculationLock.lock();
try {
this.lastReadTime = lastReadTime;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Sets last time at which a write occurred on the service.
*
* @param lastWriteTime
* The last time a write has occurred
*/
protected final void setLastWriteTime(long lastWriteTime) {
throughputCalculationLock.lock();
try {
this.lastWriteTime = lastWriteTime;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Resets the throughput counters of the service if no session is currently
* managed.
*/
private void resetThroughput() {
if (service.getManagedSessionCount() == 0) {
readBytesThroughput = 0;
writtenBytesThroughput = 0;
readMessagesThroughput = 0;
writtenMessagesThroughput = 0;
}
}
/**
* Updates the throughput counters.
*/
public void updateThroughput(long currentTime) {
throughputCalculationLock.lock();
try {
int interval = (int) (currentTime - lastThroughputCalculationTime);
long minInterval = getThroughputCalculationIntervalInMillis();
if ((minInterval == 0) || (interval < minInterval)) {
return;
}
long readBytes = this.readBytes;
long writtenBytes = this.writtenBytes;
long readMessages = this.readMessages;
long writtenMessages = this.writtenMessages;
readBytesThroughput = (readBytes - lastReadBytes) * 1000.0 / interval;
writtenBytesThroughput = (writtenBytes - lastWrittenBytes) * 1000.0 / interval;
readMessagesThroughput = (readMessages - lastReadMessages) * 1000.0 / interval;
writtenMessagesThroughput = (writtenMessages - lastWrittenMessages) * 1000.0 / interval;
if (readBytesThroughput > largestReadBytesThroughput) {
largestReadBytesThroughput = readBytesThroughput;
}
if (writtenBytesThroughput > largestWrittenBytesThroughput) {
largestWrittenBytesThroughput = writtenBytesThroughput;
}
if (readMessagesThroughput > largestReadMessagesThroughput) {
largestReadMessagesThroughput = readMessagesThroughput;
}
if (writtenMessagesThroughput > largestWrittenMessagesThroughput) {
largestWrittenMessagesThroughput = writtenMessagesThroughput;
}
lastReadBytes = readBytes;
lastWrittenBytes = writtenBytes;
lastReadMessages = readMessages;
lastWrittenMessages = writtenMessages;
lastThroughputCalculationTime = currentTime;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Increases the count of read bytes by <code>nbBytesRead</code> and sets
* the last read time to <code>currentTime</code>.
*
* @param nbBytesRead
* The number of bytes read
* @param currentTime
* The date those bytes were read
*/
public final void increaseReadBytes(long nbBytesRead, long currentTime) {
throughputCalculationLock.lock();
try {
readBytes += nbBytesRead;
lastReadTime = currentTime;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Increases the count of read messages by 1 and sets the last read time to
* <code>currentTime</code>.
*
* @param currentTime
* The time the message has been read
*/
public final void increaseReadMessages(long currentTime) {
throughputCalculationLock.lock();
try {
readMessages++;
lastReadTime = currentTime;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Increases the count of written bytes by <code>nbBytesWritten</code> and
* sets the last write time to <code>currentTime</code>.
*
* @param nbBytesWritten
* The number of bytes written
* @param currentTime
* The date those bytes were written
*/
public final void increaseWrittenBytes(int nbBytesWritten, long currentTime) {
throughputCalculationLock.lock();
try {
writtenBytes += nbBytesWritten;
lastWriteTime = currentTime;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Increases the count of written messages by 1 and sets the last write time
* to <code>currentTime</code>.
*
* @param currentTime
* The date the message were written
*/
public final void increaseWrittenMessages(long currentTime) {
throughputCalculationLock.lock();
try {
writtenMessages++;
lastWriteTime = currentTime;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return The count of bytes scheduled for write.
*/
public final int getScheduledWriteBytes() {
throughputCalculationLock.lock();
try {
return scheduledWriteBytes;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Increments by <code>increment</code> the count of bytes scheduled for write.
*/
public final void increaseScheduledWriteBytes(int increment) {
throughputCalculationLock.lock();
try {
scheduledWriteBytes += increment;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* @return the count of messages scheduled for write.
*/
public final int getScheduledWriteMessages() {
throughputCalculationLock.lock();
try {
return scheduledWriteMessages;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Increments the count of messages scheduled for write.
*/
public final void increaseScheduledWriteMessages() {
throughputCalculationLock.lock();
try {
scheduledWriteMessages++;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Decrements the count of messages scheduled for write.
*/
public final void decreaseScheduledWriteMessages() {
throughputCalculationLock.lock();
try {
scheduledWriteMessages--;
} finally {
throughputCalculationLock.unlock();
}
}
/**
* Sets the time at which throughput counters where updated.
*/
protected void setLastThroughputCalculationTime(long lastThroughputCalculationTime) {
throughputCalculationLock.lock();
try {
this.lastThroughputCalculationTime = lastThroughputCalculationTime;
} finally {
throughputCalculationLock.unlock();
}
}
}