directconnecttiming_t.java

SRI international 发布的OAA框架软件

                (IclList) IclTerm.fromString(true, params), 1, 50);
    }

    public void time5kMakeString() throws Exception {
        times = new LinkedHashMap();
        tests.put("5k makeString", times);

        // Time subsequent tests
        for (int i = 0; i < numRuns; i++) {
            if (timeFac) time5kMakeString("[]");
            time5kMakeString(dcParams);
        }
    }

    public void time5kMakeString(String params) throws Exception {
        timeMakeString("makeString(5kString) iterated 50 times with " + params,
                (IclList) IclTerm.fromString(true, params), 5, 50);
    }

    public void time10kMakeString() throws Exception {
        times = new LinkedHashMap();
        tests.put("10k makeString", times);

        // Time subsequent tests
        for (int i = 0; i < numRuns; i++) {
            if (timeFac) time10kMakeString("[]");
            time10kMakeString(dcParams);
        }
    }

    public void time10kMakeString(String params) throws Exception {
        timeMakeString("makeString(10kString) iterated 50 times with " + params,
                (IclList) IclTerm.fromString(true, params), 10, 50);
    }

    public void time20kMakeString() throws Exception {
        times = new LinkedHashMap();
        tests.put("20k makeString", times);

        // Time subsequent tests
        for (int i = 0; i < numRuns; i++) {
            if (timeFac) time20kMakeString("[]");
            time20kMakeString(dcParams);
        }
    }

    public void time20kMakeString(String params) throws Exception {
        timeMakeString("makeString(20kString) iterated 50 times with " + params,
                (IclList) IclTerm.fromString(true, params), 20, 50);
    }

    public void timeMakeString(String name,
                               IclList solveArgs,
                               int nKilobytes,
                               int numIt) throws Exception {
        long startTime = System.currentTimeMillis();
        int size = 1024 * nKilobytes;

        for (int i = 0; i < numIt; i++) {
            IclTerm solveTerm = new IclStruct("oaa_Solve",
                    new IclStruct("makeString", new IclInt(size),
                            new IclVar("Ret")), solveArgs);

            IclList res = oaaAgent.interpret(solveTerm, Agent.iclEmptyList);

            boolean answer = false;

            for (Iterator itr = res.iterator(); itr.hasNext();) {
                IclTerm term = (IclTerm) itr.next();

                assertTrue(term.isStruct());
                assertTrue("term.getTerm(0) = " + term.getTerm(0).getClass().getName(), term.getTerm(0).isInt());
                assertTrue("term.getTerm(1) = " + term.getTerm(1).getClass().getName(), term.getTerm(1).isStr());
                assertTrue("Size should be " + size + " but is " + term.getTerm(1).toIdentifyingString().length(), term.getTerm(1).toIdentifyingString().length() == size);
                answer = true;
            }

            assertTrue("No Answer found", answer);
            if (debugDot) System.out.print(".");
        }

        long totalTime = System.currentTimeMillis() - startTime;

        System.out.println();

        List timesList = (List) times.get(name);

        if (timesList == null) {
            timesList = new Vector();
            times.put(name, timesList);
        }

        timesList.add(new Long(totalTime));
    }

    public void tIclDataQ() throws Exception {
        /*LibOaa myOaa = new LibOaa(new LibCom(new LibComTcpProtocol(), new String[] {}));

        if (!myOaa.getComLib().comConnect("parent",
                                          IclTerm.fromString(true, "tcp(Host,Port)"),
                                          null)) {
            throw new Exception("Couldn't connect to facilitator");
        }

        // register the agent's info
        if (!myOaa.oaaRegister("parent",
                               "testIclDataQAgent",
                               IclTerm.fromString(true, "[setData(Data)]"),
                               null)) {
            throw new Exception("Could not register");
        }

        // register the call back method which the facilitator will call
        myOaa.oaaRegisterCallback("oaa_AppDoEvent", new OAAEventListener() {
            public boolean doOAAEvent(
                IclTerm goal, IclList params, IclList answers) {
                if (goal.toIdentifyingString().equals("setData")) {
                    System.out.println("goal = " + goal);
                    System.out.println("term(0) class = " + goal.getTerm(0).getClass().getName());
                    answers.add((IclTerm)goal.clone());
                    return true;
                }
                return false;
            }
        });

        myOaa.oaaReady(true);*/

        LibOaa myOaa_client = new LibOaa(new LibCom(new LibComTcpProtocol(), new String[]{}));

        if (!myOaa_client.getComLib().comConnect("parent",
                IclTerm.fromString(true, "tcp(Host,Port)"),
                null)) {
            throw new Exception("Couldn't connect to facilitator");
        }

        // register the agent's info
        if (!myOaa_client.oaaRegister("parent",
                "testIclDataQAgent",
                IclTerm.fromString(true, "[]"),
                null)) {
            throw new Exception("Could not register");
        }

        // register the call back method which the facilitator will call
        myOaa_client.oaaRegisterCallback("oaa_AppDoEvent", new OAAEventListener() {
            public boolean doOAAEvent(
                    IclTerm goal, IclList params, IclList answers) {
                return false;
            }
        });

        byte[] data = new byte[]{92, 92, 92, 92};

        IclStruct copyData = new IclStruct("copyData", new IclDataQ(data), new IclVar("Ret"));

        IclList answers = new IclList();
        debug("Solving: " + copyData);
        myOaa_client.oaaSolve(copyData, new IclList(), answers);

        myOaa_client.oaaDisconnect("parent", null);
        //myOaa.oaaDisconnect("parent", null);
    }

    public void time100kByteArray() throws Exception {
        times = new LinkedHashMap();
        tests.put("100k Byte Array", times);

        // Time subsequent tests
        for (int i = 0; i < numRuns; i++) {
            if (debugDot) System.out.print(".");
            if (timeFac) time100kByteArray("[]");
            time100kByteArray(dcParams);
        }

        System.out.println();
    }

    public void time500kByteArray() throws Exception {
        times = new LinkedHashMap();
        tests.put("500k Byte Array", times);

        // Time subsequent tests
        for (int i = 0; i < numRuns; i++) {
            if (debugDot) System.out.print(".");
            if (timeFac) time500kByteArray("[]");
            time500kByteArray(dcParams);
        }

        System.out.println();
    }

    public void time1MByteArray() throws Exception {
        times = new LinkedHashMap();
        tests.put("1M Byte Array", times);

        // Time subsequent tests
        for (int i = 0; i < numRuns; i++) {
            // Doesn't work through the facilitator...
            // time1MByteArray("[]");
            if (debugDot) System.out.print(".");
            time1MByteArray(dcParams);
        }

        System.out.println();
    }

    public void time100kByteArray(String params) throws Exception {
        timeByteArray("copyData(100kByteArray,Ret) with " + params, (IclList) IclTerm.fromString(true, params), 100);
    }

    public void time500kByteArray(String params) throws Exception {
        timeByteArray("copyData(500kByteArray,Ret) with " + params, (IclList) IclTerm.fromString(true, params), 500);
    }

    public void timeByteArray(String name,
                              IclList solveArgs,
                              int nKilobytes) throws Exception {
        int size = 1024 * nKilobytes;
        byte[] buffer = new byte[size];
        for (int i = 0; i < buffer.length; i++) {
            // Don't care about loss of precision....
            buffer[i] = (byte) i;
        }
        timeByteArray(name, solveArgs, buffer);
    }

    public void timeByteArrayM(String name,
                               IclList solveArgs,
                               int nMegabytes) throws Exception {
        int size = (int) (Math.pow(2, 20) * nMegabytes);
        byte[] buffer = new byte[size];
        for (int i = 0; i < buffer.length; i++) {
            // Don't care about loss of precision....
            buffer[i] = (byte) i;
        }
        timeByteArray(name, solveArgs, buffer);
    }

    public void time1MByteArray(String params) throws Exception {
        timeByteArrayM("copyData(1MByteArray,Ret) with " + params, (IclList) IclTerm.fromString(true, params), 1);
    }

    public void timeByteArray(String name,
                              IclList solveArgs,
                              byte[] buffer) throws Exception {
        IclTerm fullGoal = new IclStruct("full_goal",
                new IclStruct("copyData", new IclDataQ(buffer),
                        new IclVar("Ret")));

        solveArgs.add(fullGoal);

        IclTerm solveTerm = new IclStruct("oaa_Solve",
                new IclStruct("copyData", new IclVar("In"),
                        new IclVar("Ret")), solveArgs);

        long startTime = System.currentTimeMillis();
        // Send the large string over and wait for it to come back
        IclList res = oaaAgent.interpret(solveTerm, Agent.iclEmptyList);
        long totalTime = System.currentTimeMillis() - startTime;

        List timesList = (List) times.get(name);

        boolean answer = false;

        if (timesList == null) {
            timesList = new Vector();
            times.put(name, timesList);
        }

        int size = buffer.length;

        for (Iterator itr = res.iterator(); itr.hasNext();) {
            IclTerm term = (IclTerm) itr.next();

            assertTrue(term.isStruct());
            assertTrue("term.getTerm(0) = " + term.getTerm(0).getClass().getName(),
                    term.getTerm(0) instanceof IclDataQ);
            assertTrue("term.getTerm(1) = " + term.getTerm(1).getClass().getName(),
                    term.getTerm(1) instanceof IclDataQ);
            byte[] inData = ((IclDataQ) term.getTerm(0)).getData();
            byte[] outData = ((IclDataQ) term.getTerm(1)).getData();
            assertTrue("inData.length = " + inData.length, inData.length == size);
            assertTrue("outData.length = " + outData.length, outData.length == size);
            for (int i = 0; i < size; i++) {
                assertTrue(inData[i] == outData[i]);
            }
            answer = true;

            long time = totalTime;
            timesList.add(new Long(time));
        }

        assertTrue("No Answer found", answer);
    }

    public void timeDataTransfer(long nMegs, int incrKb, boolean sendThruFac) throws Exception {
        times = new LinkedHashMap();
        int incrBytes = incrKb * 1025;
        long numBytes = (long) (nMegs * Math.pow(2, 20));
        tests.put("Data transfer, length = " + nMegs + "M in " + incrKb + "k increments", times);

        for (int i = 0; i < numRuns; i++) {
            if (sendThruFac && timeFac) {
                timeDataTransfer("[]", numBytes, incrBytes);
            }
            timeDataTransfer(dcParams, numBytes, incrBytes);
        }
    }

    public void timeDataTransfer(String params, long numBytes, int incr) throws Exception {
        timeDataTransfer("setData() with " + params, numBytes, incr,
                (IclList) IclTerm.fromString(true, params));
    }

    public void timeDataTransfer(String name, long numBytes, int incr, IclList solveArgs) throws Exception {
        long startTime = System.currentTimeMillis();

        long transfered = 0;
        byte[] buffer = new byte[incr];

        while (transfered < numBytes) {
            int toSend = (int) Math.min(buffer.length, numBytes - transfered);

            for (int i = 0; i < buffer.length; i++) {
                buffer[i] = (byte) Math.round(255.0 * Math.random() - 128);
            }

            byte[] newBuffer = buffer;

            if (toSend < buffer.length) {
                newBuffer = new byte[toSend];
                System.arraycopy(buffer, 0, newBuffer, 0, toSend);
            }

            IclTerm fullGoal = new IclStruct("full_goal",
                    new IclStruct("setData", new IclDataQ(newBuffer), new IclVar("RetLength")));

            IclTerm args = (IclTerm) solveArgs.clone();
            args.add(fullGoal);

            IclTerm solveTerm = new IclStruct("oaa_Solve",
                    new IclStruct("setData",
                            new IclVar("Data"), new IclVar("RetLength")), args);
            IclList res = oaaAgent.interpret(solveTerm, Agent.iclEmptyList);
            assertTrue("No answer found", res.size() > 0);

            for (int i = 0; i < res.size(); i++) {
                IclTerm lengthTerm = res.getTerm(i).getTerm(1);
                assertTrue(lengthTerm.isInt());
                assertTrue(((IclInt) lengthTerm).toInt() == newBuffer.length);
            }

            transfered += toSend;
            if (debugDot) System.out.print(".");
        }

        long totalTime = System.currentTimeMillis() - startTime;

        System.out.println();

        List timesList = (List) times.get(name);

        if (timesList == null) {
            timesList = new Vector();
            times.put(name, timesList);
        }

        long time = totalTime;
        timesList.add(new Long(time));
    }
}