Metering Java Reader and Writer Objects

Last few days I was working on measuring the bandwidth consumed by different java objects passed to our remote interfaces. It was simple task to do it with 'String' objects, byte arrays as we can directly get the sizes of them using String.length and byte[].size() methods.

But there were objects of type Reader and Writer, which is supposed to transfer big chunk of data. There also we could load all the data to memory and measure the sizes.

// measuring reader size - memory inefficient method

// read all data to buffer and measure the length
StringReader stringReader = new StringReader(reader);
int size = stringReader.toString().length;

doRealWork(stringReader);

But that will consume lot of memory (even possible to exceed available heap size). So it is wrong to use the above method to measure the size of reader or writer.

Anyway there is an easy solution for the problem. We can use the design of Reader API itself to measure it size. The Reader interface has a method that read the data by small chunks. We just need to intercept that call and measure the size of each small chunk and add them all. For that we need to implement the Reader interface in to a custom class (say 'MonitoredReader'). Here is how it is implemented.

import java.io.IOException;
import java.io.Reader;

/**
 * The class to intercept the read method and calculate
 * the number of reads
 */
public class MonitoredReader extends Reader {

    Reader reader;
    int totalReadSize;

    /**
     * constructor that wraps the original reader object
     */
    public MonitoredReader(Reader reader) {
        this.reader = reader;
        totalReadSize = 0;
    }

    /**
     * The method to call by the user to read the data. We will just calculate the amount
     * of data read here.
     *
     * @param cBuf destination buffer
     * @param off  offset at which to start storing characters
     * @param len  maximum number of characters to read
     *
     * @return the number of characters read, or -1 if the end of the stream has been reached
     * @throws IOException if an I/O error occurs
     */
    public int read(char cbuf[], int off, int len) throws IOException {

        int read = reader.read(cbuf, off, len);
        totalReadSize += read;
        return read;
    }

    /**
     * Method to call after finishing reading the data. We will just pass the call to the
     * original reader
     */

    public void close() throws IOException {
        reader.close();
    }

    /**
     * Custom method that will return the total size of read data
     *
     * @return the size of the data read
     */
    public int getTotalReadSize() {
        return totalReadSize;
    }
}

So our code to measure the size will simple reduce to the following piece of code.

// measuring reader size - memory efficient method

// just wrap the original reader with our custom reader
MonitoredReader monitoredReader = new MonitoredReader(reader);

// pass our custom reader to the real work
doRealWork(monitoredReader);

// get the size read in the real work
int size = monitoredReader.getTotalReadSize();

Similarly we can use this method to get the data size of the writer. (amount of data written to the writer).

import java.io.IOException;
import java.io.Writer;

/**
 * The class to intercept the write method and calculate
 * the number of writes
 */
public class MonitoredWriter extends Writer {

    Writer writer;
    int totalWrittenSize;

    /**
     * constructor that wraps the original writer object
     */
    public MonitoredWriter(Writer writer) {
        this.writer = writer;
        totalWrittenSize = 0;
    }

    /**
     * The method to call by the user to write the data. We will just calculate the amount
     * of data written here.
     *
     * @param  cBuf  Array of characters
     * @param  off   Offset from which to start writing characters
     * @param  len   Number of characters to write
     *
     * @throws java.io.IOException  If an I/O error occurs
     */
    public void write(char cbuf[], int off, int len) throws IOException {
        totalWrittenSize += (len - off);
        writer.write(cbuf, off, len);
    }

    /**
     * Method to call after finishing writing the data. We will just pass the call to the
     * original writer
     */
    public void close() throws IOException {
        writer.close();
    }

    /**
     * flush already written data. Here also we just pass the call to the original writer
     */
    public void flush() throws IOException {
        writer.flush();
    }

    /**
     * Custom method that will return the total size of written data
     *
     * @return the size of the data written
     */
    public int getTotalWrittenSize() {
        return totalWrittenSize;
    }
}

Here is how it is used in measuring the writer size.

// measuring writer size - memory efficient method

// just wrap the original writer with our custom writer
MonitoredWriter monitoredWriter = new MonitoredWriter(writer);

// pass our custom wrter to the real work

doRealWork(monitoredWriter);

// get the size written in the real work
int size = monitoredWriter.getTotalWrittenSize();

Anyway like every good methods, there are drawbacks of using these methods to measure the data size on Reader and Writer objects.

If we take measuring the bandwidth consumed by a reader in a remote interface, this gives a slightly low value because this particular code only provide the size of the data read by the end user application and not by the network hardware layers. But actually these low layers read more data and keep it in a buffer which is not measured here. But if we assume that most of the time the end user application read all the data from the reader (and very rarely read portion of data and give up), this give nearly accurate value.

The other drawback could be the performance degradation  by wrapping the reader/writer with our custom implementation. But mostly reader and writers are used in IO bound operations (like to read through network or files), so going through an another layer does really little effect to the overall performance. And after all the 'Observer effect theory' says we can't measure anything without causing any effect to the actual cause...