Logo Search packages:      
Sourcecode: zeroc-ice-java version File versions  Download package

Client.java

// **********************************************************************
//
// Copyright (c) 2003-2006 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

import Demo.*;

class TestApp extends Ice.Application
{
    TestApp(String envName)
    {
      _envName = envName;
    }

    void
    IntIntMapTest(Freeze.Map m, boolean fast)
    {
      //
      // Populate the database.
      //
      _watch.start();
      Freeze.Transaction tx = _connection.beginTransaction();
      if(fast)
      {
          for(int i = 0; i < _repetitions; ++i)
          {
            m.fastPut(new Integer(i), new Integer(i));
          }
      }
      else
      {
          for(int i = 0; i < _repetitions; ++i)
          {
            m.put(new Integer(i), new Integer(i));
          }
      }
      tx.commit();

      double total = _watch.stop();
        double perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " " + ((fast) ? "fast " : "") + "writes: " + total + "ms");
        System.out.println("\ttime per write: " + perRecord + "ms");

      //
      // Read each record.
      //
      _watch.start();
      for(int i = 0; i < _repetitions; ++i)
      {
          Integer n = (Integer)m.get(new Integer(i));
          test(n.intValue() == i);
      }
        total = _watch.stop();
        perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " reads: " + total + "ms");
        System.out.println("\ttime per read: " + perRecord + "ms");

      if(m instanceof IndexedIntIntMap)
      {
          IndexedIntIntMap indexedM = (IndexedIntIntMap)m;
          //
          // Read each record using the index
          //
          _watch.start();
          for(int i = 0; i < _repetitions; ++i)
          {
            java.util.Iterator p = indexedM.findByValue(i);
            test(p.hasNext());
            java.util.Map.Entry e = (java.util.Map.Entry)p.next();
            test(((Integer)e.getKey()).intValue() == i);
            m.closeAllIterators();
          }
          total = _watch.stop();
          perRecord = total / _repetitions;
          
          System.out.println("\ttime for " + _repetitions + " indexed reads: " + total + "ms");
          System.out.println("\ttime per indexed read: " + perRecord + "ms");
      }


      //
      // Remove each record.
      //
      _watch.start();
      tx = _connection.beginTransaction();
      if(fast)
      {
          for(int i = 0; i < _repetitions; ++i)
          {
            test(m.fastRemove(new Integer(i)));
          }
      }
      else
      {
          for(int i = 0; i < _repetitions; ++i)
          {
            Integer n = (Integer)m.remove(new Integer(i));
            test(n.intValue() == i);
          }
      }
      tx.commit();
      total = _watch.stop();
        perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " " + ((fast) ? "fast " : "") + "removes: " + total + "ms");
        System.out.println("\ttime per remove: " + perRecord + "ms");

      m.close();
    }

    interface Generator
    {
      int next();
      String toString();
    }

    static class RandomGenerator implements Generator
    {
      RandomGenerator(int seed, int max)
      {
          _r = new java.util.Random(0);
          _max = max;
      }

      public int
      next()
      {
          return _r.nextInt(_max);
      }

      public String
      toString()
      {
          return "random(" + _max + ")";
      }

      private java.util.Random _r;
      private int _max;
    }

    static class SequentialGenerator implements Generator
    {
      SequentialGenerator(int min, int max)
      {
          _min = min;
          _max = max;
          _current = _min;
      }

      public int
      next()
      {
          int n = _current;
          ++_current;
          if(_current > _max)
          {
            _current = _min;
          }
          return n;
      }

      public String
      toString()
      {
          return new Integer((_max - _min)+1).toString();
      }

      private int _min;
      private int _max;
      private int _current;
    }

    void
    generatedRead(Freeze.Map m, int reads, Generator gen)
    {
      _watch.start();
      for(int i = 0; i < reads; ++i)
      {
          int key = gen.next();
          Integer n = (Integer)m.get(new Integer(key));
          test(n.intValue() == key);
      }
        double total = _watch.stop();
        double perRecord = total / reads;

        System.out.println("\ttime for " + reads + " reads of " + gen + " records: " +
                     total + "ms");
      System.out.println("\ttime per read: " + perRecord + "ms");

      if(m instanceof IndexedIntIntMap)
      {
          IndexedIntIntMap indexedM = (IndexedIntIntMap)m;
          _watch.start();
          for(int i = 0; i < reads; ++i)
          {
            int val = gen.next();
            java.util.Iterator p = indexedM.findByValue(val);
            test(p.hasNext());
            java.util.Map.Entry e = (java.util.Map.Entry)p.next();
            test(((Integer)e.getKey()).intValue() == val);
            m.closeAllIterators();
          }
          total = _watch.stop();
          perRecord = total / reads;
          
          System.out.println("\ttime for " + reads + " reverse (indexed) reads of " + gen + " records: " +
                         total + "ms");
          System.out.println("\ttime per reverse (indexed) read: " + perRecord + "ms");
      }
    }

    void
    IntIntMapReadTest(Freeze.Map m)
    {
      //
      // Populate the database.
      //
      _watch.start();
      Freeze.Transaction tx = _connection.beginTransaction();
      for(int i = 0; i < _repetitions; ++i)
      {
          m.fastPut(new Integer(i), new Integer(i));
      }
      tx.commit();
      double total = _watch.stop();
        double perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " writes: " + total + "ms");
        System.out.println("\ttime per write: " + perRecord + "ms");

      //
      // Do some read tests.
      //
      generatedRead(m, _repetitions, new SequentialGenerator(1000, 1000));
      generatedRead(m, _repetitions, new SequentialGenerator(2000, 2009));
      generatedRead(m, _repetitions, new SequentialGenerator(3000, 3099));
      generatedRead(m, _repetitions, new SequentialGenerator(4000, 4999));

      //
      // Do a random read test.
      //
      generatedRead(m, _repetitions, new RandomGenerator(0, 10000));

      //
      // Remove each record.
      //
/*
 *      For this test I don't want to remove the records because I
 *      want to examine the cache stats for the database.
 *
      _watch.start();
      for(int i = 0; i < _repetitions; ++i)
      {
          test(m.fastRemove(new Integer(i)));
      }
      total = _watch.stop();
        perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " removes: " + total + "ms");
        System.out.println("\ttime per remove: " + perRecord + "ms");
*/

      m.close();
    }

    void
    Struct1Struct2MapTest(Freeze.Map m)
    {
      //
      // Populate the database.
      //
      Struct1 s1 = new Struct1();
      Struct2 s2 = new Struct2();
      _watch.start();
      Freeze.Transaction tx = _connection.beginTransaction();
      for(int i = 0; i < _repetitions; ++i)
      {
          s1.l = i;
          s2.s = new Integer(i).toString();
          s2.s1 = s1;
          m.fastPut(s1, s2);
      }
      tx.commit();
      double total = _watch.stop();
        double perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " writes: " + total + "ms");
        System.out.println("\ttime per write: " + perRecord + "ms");

      //
      // Read each record.
      //
      _watch.start();
      for(int i = 0; i < _repetitions; ++i)
      {
          s1.l = i;
          Struct2 ns2 = (Struct2)m.get(s1);
          test(ns2.s.equals(new Integer(i).toString()));
      }
        total = _watch.stop();
        perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " reads: " + total + "ms");
        System.out.println("\ttime per read: " + perRecord + "ms");

      
      //
      // Optional index test
      //

      if(m instanceof IndexedStruct1Struct2Map)
      {
          IndexedStruct1Struct2Map indexedM = (IndexedStruct1Struct2Map)m;
          _watch.start();
          for(int i = 0; i < _repetitions; ++i)
          {
            String s = (new Integer(i)).toString();
            java.util.Iterator p = indexedM.findByS(s);
            test(p.hasNext());
            java.util.Map.Entry e = (java.util.Map.Entry)p.next();
            test(((Struct1)e.getKey()).l == i);
            m.closeAllIterators();
          }

          for(int i = 0; i < _repetitions; ++i)
          {
            s1.l = i;
            java.util.Iterator p = indexedM.findByS1(s1);
            test(p.hasNext());
            java.util.Map.Entry e = (java.util.Map.Entry)p.next();
            test(((Struct1)e.getKey()).l == i);
            m.closeAllIterators();
          }
          total = _watch.stop();
          perRecord = total / (2 * _repetitions);

          System.out.println("\ttime for " + 2 * _repetitions + " indexed reads: " + total + "ms");
          System.out.println("\ttime per indexed read: " + perRecord + "ms");
      }

      //
      // Remove each record.
      //
      _watch.start();
      tx = _connection.beginTransaction();
      for(int i = 0; i < _repetitions; ++i)
      {
          s1.l = i;
          test(m.fastRemove(s1));
      }
      tx.commit();
      total = _watch.stop();
        perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " removes: " + total + "ms");
        System.out.println("\ttime per remove: " + perRecord + "ms");

      m.close();
    }

    void
    Struct1Class1MapTest(Freeze.Map m)
    {
      //
      // Populate the database.
      //
      Struct1 s1 = new Struct1();
      Class1 c1 = new Class1();
      _watch.start();
      Freeze.Transaction tx = _connection.beginTransaction();
      for(int i = 0; i < _repetitions; ++i)
      {
          s1.l = i;
          c1.s = new Integer(i).toString();
          m.fastPut(s1, c1);
      }
      tx.commit();
      double total = _watch.stop();
        double perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " writes: " + total + "ms");
        System.out.println("\ttime per write: " + perRecord + "ms");

      //
      // Read each record.
      //
      _watch.start();
      for(int i = 0; i < _repetitions; ++i)
      {
          s1.l = i;
          Class1 nc1 = (Class1)m.get(s1);
          test(nc1.s.equals(new Integer(i).toString()));
      }
        total = _watch.stop();
        perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " reads: " + total + "ms");
        System.out.println("\ttime per read: " + perRecord + "ms");


      //
      // Optional index test
      //

      if(m instanceof IndexedStruct1Class1Map)
      {
          IndexedStruct1Class1Map indexedM = (IndexedStruct1Class1Map)m;
          _watch.start();
          for(int i = 0; i < _repetitions; ++i)
          {
            String s = (new Integer(i)).toString();
            java.util.Iterator p = indexedM.findByS(s);
            test(p.hasNext());
            java.util.Map.Entry e = (java.util.Map.Entry)p.next();
            test(((Struct1)e.getKey()).l == i);
            m.closeAllIterators();
          }

          total = _watch.stop();
          perRecord = total /  _repetitions;

          System.out.println("\ttime for " +  _repetitions + " indexed reads: " + total + "ms");
          System.out.println("\ttime per indexed read: " + perRecord + "ms");
      }

      //
      // Remove each record.
      //
      _watch.start();
      tx = _connection.beginTransaction();
      for(int i = 0; i < _repetitions; ++i)
      {
          s1.l = i;
          test(m.fastRemove(s1));
      }
      tx.commit();
      total = _watch.stop();
        perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " removes: " + total + "ms");
        System.out.println("\ttime per remove: " + perRecord + "ms");

      m.close();
    }

    void
    Struct1ObjectMapTest(Freeze.Map m)
    {
      //
      // Populate the database.
      //
      Struct1 s1 = new Struct1();
      Class1 c1 = new Class1();
      Class2 c2 = new Class2();
      c2.rec = c2;
      c2.obj = c1;
      _watch.start();
      Freeze.Transaction tx = _connection.beginTransaction();
      for(int i = 0; i < _repetitions; ++i)
      {
          s1.l = i;
          Object o;
          if((i % 2) == 0)
          {
            o = c2;
          }
          else
          {
            o = c1;
          }
          c1.s = new Integer(i).toString();

          m.fastPut(s1, o);
      }
      tx.commit();

      double total = _watch.stop();
        double perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " writes: " + total + "ms");
        System.out.println("\ttime per write: " + perRecord + "ms");

      //
      // Read each record.
      //
      _watch.start();
      for(int i = 0; i < _repetitions; ++i)
      {
          s1.l = i;

          Object o = m.get(s1);

          Class1 nc1;
          if((i % 2) == 0)
          {
            Class2 nc2 = (Class2)o;
            test(nc2.rec == nc2);
            nc1 = (Class1)nc2.obj;
          }
          else
          {
            nc1 = (Class1)o;
          }

          test(nc1.s.equals(new Integer(i).toString()));
      }
        total = _watch.stop();
        perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " reads: " + total + "ms");
        System.out.println("\ttime per read: " + perRecord + "ms");

      //
      // Remove each record.
      //
      _watch.start();
      tx = _connection.beginTransaction();
      for(int i = 0; i < _repetitions; ++i)
      {
          s1.l = i;
          test(m.fastRemove(s1));
      }
      tx.commit();
      total = _watch.stop();
        perRecord = total / _repetitions;

        System.out.println("\ttime for " + _repetitions + " removes: " + total + "ms");
        System.out.println("\ttime per remove: " + perRecord + "ms");

      m.close();
    }
    
    public int
    run(String[] args)
    {
      _connection = Freeze.Util.createConnection(communicator(), _envName);

      System.out.println("IntIntMap (Collections API)");
      IntIntMapTest(new IntIntMap(_connection, "IntIntMap", true), false);

      System.out.println("IntIntMap (Fast API)");
      IntIntMapTest(new IntIntMap(_connection, "IntIntMap.fast", true), true);

      System.out.println("IntIntMap with index (Collections API)");
      IntIntMapTest(new IndexedIntIntMap(_connection, "IndexedIntIntMap", true), false);

      System.out.println("IntIntMap with index (Fast API)");
      IntIntMapTest(new IndexedIntIntMap(_connection, "IndexedIntIntMap.fast", true), true);

      System.out.println("Struct1Struct2Map");
      Struct1Struct2MapTest(new Struct1Struct2Map(_connection, "Struct1Struct2", true));

      System.out.println("Struct1Struct2Map with index");
      Struct1Struct2MapTest(new IndexedStruct1Struct2Map(_connection, "IndexedStruct1Struct2", true));
      
      System.out.println("Struct1Class1Map");
      Struct1Class1MapTest(new Struct1Class1Map(_connection, "Struct1Class1", true));

      System.out.println("Struct1Class1Map with index");
      Struct1Class1MapTest(new IndexedStruct1Class1Map(_connection, "IndexedStruct1Class1", true));

      System.out.println("IntIntMap (read test)");
      IntIntMapReadTest(new IntIntMap(_connection, "IntIntMap", true));

      System.out.println("IntIntMap (read test with index)");
      IntIntMapReadTest(new IndexedIntIntMap(_connection, "IndexedIntIntMap", true));
      

      System.out.println("Struct1ObjectMap");
      Struct1ObjectMapTest(new Struct1ObjectMap(_connection, "Struct1Object", true));

      _connection.close();

      return 0;
    }

    private static void
    test(boolean b)
    {
        if(!b)
        {
            throw new RuntimeException();
        }
    }

    private Freeze.Connection _connection;
    private int _repetitions = 10000;
    private StopWatch _watch = new StopWatch();
    private String _envName;
}

public class Client
{
    static public void
    main(String[] args)
    {
      TestApp app = new TestApp("db");
      app.main("test.Freeze.bench.Client", args);
    }
}

Generated by  Doxygen 1.6.0   Back to index