src/tools/TestMapSpeed.java

import java.io.*;

import org.codehaus.jackson.*;
import org.codehaus.jackson.map.*;

public final class TestMapSpeed
{
    /**
     * Number of repetitions to run per test. Dynamically variable,
     * based on observed runtime, to try to keep it high enough.
     */
    private int REPS;

    /**
     * Let's keep per-run times above 50 milliseconds
     */
    //final static int MIN_RUN_TIME = 50;
    final static int MIN_RUN_TIME = 5;

    /**
     * Let's keep per-run times below 300 milliseconds
     */
    //final static int MAX_RUN_TIME = 300;
    final static int MAX_RUN_TIME = 1000;

    private final static int TEST_PER_GC = 17;

    final JsonFactory _factory;
    final ObjectMapper _mapper;

    final Object _objectToMap;

    private TestMapSpeed(byte[] data)
        throws Exception
    {
        _factory = new JsonFactory();
        _mapper = new ObjectMapper();
        JsonParser jp = _factory.createJsonParser(data, 0, data.length);
        _objectToMap = _mapper.readValue(jp, Object.class);
        jp.close();

        // Ok how should we guestimate speed... perhaps from data size?
        REPS = 100 + ((8 * 1000 * 1000) / data.length);
        System.out.println("Based on size, will use "+REPS+" repetitions");
    }

    protected int test()
        throws Exception
    {
        int i = 0;
        int total = 0;

        final int TEST_CASES = 2;
        final ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);

        while (true) {
            try {  Thread.sleep(150L); } catch (InterruptedException ie) { }
            int round = (i++ % TEST_CASES);

            long now = System.currentTimeMillis();
            String msg;
            int sum = 0;
//round = 1; // testing just old or new?

            switch (round) {
            case 0:
                msg = "Map using OLD";
                sum = testOld(REPS, bos);
                break;
            case 1:
                msg = "Map using NEW";
                sum = testNew(REPS, bos);
                break;

            default:
                throw new Error("Internal error");
            }

            now = System.currentTimeMillis() - now;
            if (round == 0) {
                System.out.println();
            }
            System.out.println("Test '"+msg+"' -> "+now+" msecs ("
                               +sum+" -> "+(total & 0xFF)+").");

            total += sum;

            if ((i % TEST_PER_GC) == 0) {
                System.out.println("[GC]");
                try {  Thread.sleep(100L); } catch (InterruptedException ie) { }
                System.gc();
                try {  Thread.sleep(200L); } catch (InterruptedException ie) { }

                /* One more tweak: let's add load if things start
                 * running too fast or slow, to try to get sweet range
                 * of 50 to 250 millisseconds
                 */
                if (now < MIN_RUN_TIME) {
                    REPS += (REPS / 5); // 20% up
                    System.out.println("[NOTE: increasing reps, now: "+REPS+"]");
                    try {  Thread.sleep(200L); } catch (InterruptedException ie) { }
                } else if (now > MAX_RUN_TIME && i > 20) {
                    /* Let's reduce load slower than increase; also,
                     * due to initial warmup, let's not adjust until
                     * we've gone through a few cycles
                     */
                    REPS -= (REPS / 10); // 10% down
                    System.out.println("[NOTE: decreasing reps, now: "+REPS+"]");
                    try {  Thread.sleep(200L); } catch (InterruptedException ie) { }
                }
            }
        }
    }

    /*
    /////////////////////////////////////////////////////////
    // Actual value type access, ones via Stax 1.0
    /////////////////////////////////////////////////////////
     */

    protected int testOld(int reps, ByteArrayOutputStream out)
        throws Exception
    {
        int total = 0;
        for (int i = 0; i < reps; ++i) {
            out.reset();
            JsonGenerator jg = _factory.createJsonGenerator(out, JsonEncoding.UTF8);
            _mapper.writeValue(jg, _objectToMap);
            jg.close();
            total = out.size();
        }
        return total;
    }

    protected int testNew(int reps, ByteArrayOutputStream out)
        throws Exception
    {
        int total = 0;
        for (int i = 0; i < reps; ++i) {
            out.reset();
            JsonGenerator jg = _factory.createJsonGenerator(out, JsonEncoding.UTF8);
            _mapper.writeValue(jg, _objectToMap);
            jg.close();
            total = out.size();
        }
        return total;
    }

    /*
    /////////////////////////////////////////////////////////
    // Helper methods
    /////////////////////////////////////////////////////////
     */

    static byte[] readData(File file) throws IOException
    {
        InputStream fin = new FileInputStream(file);
        byte[] buf = new byte[4000];
        ByteArrayOutputStream bos = new ByteArrayOutputStream(4000);
        int count;
        
        while ((count = fin.read(buf)) > 0) {
            bos.write(buf, 0, count);
        }
        fin.close();
        return bos.toByteArray();
    }

    public static void main(String[] args)
        throws Exception
    {
        if (args.length != 1) {
            System.err.println("Usage: java ... <file>");
            System.exit(1);
        }
        byte[] data = readData(new File(args[0]));
        System.out.println(" -> "+data.length+" bytes read.");
        new TestMapSpeed(data).test();
    }
}