Example #1
0
  @Test
  public void testOverTcp() throws IOException, InterruptedException {
    String name = TMP + "/testOverTcp0";
    String name2 = TMP + "/testOverTcp2";
    ChronicleTools.deleteOnExit(name);
    ChronicleTools.deleteOnExit(name2);

    long start = System.nanoTime();
    int PORT = 12345;
    int size = 0;

    InProcessChronicleSource chronicle =
        new InProcessChronicleSource(new IndexedChronicle(name), PORT);
    DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
    MapWrapper<String, String> strings =
        new MapWrapper<String, String>(
            dataStore,
            "strings",
            String.class,
            String.class,
            new LinkedHashMap<String, String>(),
            16);
    MapWrapper<Integer, Integer> ints =
        new MapWrapper<Integer, Integer>(
            dataStore,
            "ints",
            Integer.class,
            Integer.class,
            new LinkedHashMap<Integer, Integer>(),
            16);
    dataStore.start();
    ints.clear();
    strings.clear();

    InProcessChronicleSink chronicle2 =
        new InProcessChronicleSink(new IndexedChronicle(name2), "localhost", PORT);
    DataStore dataStore2 = new DataStore(chronicle2, ModelMode.READ_ONLY);
    MapWrapper<String, String> strings2 =
        new MapWrapper<String, String>(
            dataStore2,
            "strings",
            String.class,
            String.class,
            new LinkedHashMap<String, String>(),
            16);
    MapWrapper<Integer, Integer> ints2 =
        new MapWrapper<Integer, Integer>(
            dataStore2,
            "ints",
            Integer.class,
            Integer.class,
            new LinkedHashMap<Integer, Integer>(),
            16);

    final AtomicInteger sai = new AtomicInteger();
    MapListener<String, String> stringsListener =
        new AbstractMapListener<String, String>() {
          @Override
          public void update(String key, String oldValue, String newValue) {
            //                System.out.println(key + " " + oldValue + " => " + newValue);
            sai.incrementAndGet();
          }
        };
    strings2.addListener(stringsListener);

    final AtomicInteger iai = new AtomicInteger();
    MapListener<Integer, Integer> intsListener =
        new AbstractMapListener<Integer, Integer>() {
          @Override
          public void update(Integer key, Integer oldValue, Integer newValue) {
            //                System.out.println(key + " " + oldValue + " => " + newValue);
            iai.incrementAndGet();
          }
        };
    ints2.addListener(intsListener);
    dataStore2.start();

    int count = 0;
    for (int j = 0; j < 1000; j++) {
      int collectionSize = 1000;
      for (int i = 0; i < collectionSize; i++) {
        ints.put(i, i + j);
        strings.put(Integer.toString(i), Integer.toString(i + j));
      }
      size += Math.min(strings.size(), ints.size());
      for (int i = 0; i < collectionSize; i++) {
        ints.remove(i);
        strings.remove(Integer.toString(i));
      }
      count += 4 * collectionSize;
    }
    long mid = System.nanoTime();

    //        int timeout = 0;
    while (dataStore2.events() < count) {
      //            if (timeout++ % 10000 == 0)
      //                System.out.println(dataStore2.events());
      dataStore2.nextEvent();
    }

    chronicle.close();
    chronicle2.close();
    long end = System.nanoTime();

    System.out.printf(
        "Startup and write took %.2f us on average and read and shutdown took %.2f on average%n",
        (mid - start) / count / 1e3, (end - mid) / count / 1e3);
  }
Example #2
0
  @Test
  public void testMethods() throws IOException {
    String name = TMP + "/set-methods";
    ChronicleTools.deleteOnExit(name);
    {
      MapListener stringsListener = createMock("strings", MapListener.class);
      stringsListener.eventStart(1, "strings");
      stringsListener.add("Hello", "hi");
      stringsListener.eventEnd(true);

      stringsListener.eventStart(3, "strings");
      stringsListener.add("World", "all");
      stringsListener.eventEnd(true);

      MapListener intListener = createMock("ints", MapListener.class);
      for (int i = 0; i < 3; i++) {
        intListener.eventStart(i * 2, "ints");
        intListener.add(i, i + 1000);
        intListener.eventEnd(true);
      }

      replay(stringsListener);
      replay(intListener);
      Chronicle chronicle = new IndexedChronicle(name);
      DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
      MapWrapper<String, String> strings =
          new MapWrapper<String, String>(
              dataStore,
              "strings",
              String.class,
              String.class,
              new LinkedHashMap<String, String>(),
              16);
      strings.addListener(stringsListener);
      MapWrapper<Integer, Integer> ints =
          new MapWrapper<Integer, Integer>(
              dataStore,
              "ints",
              Integer.class,
              Integer.class,
              new LinkedHashMap<Integer, Integer>(),
              16);
      ints.addListener(intListener);

      dataStore.start();

      ints.put(0, 1000);
      strings.put("Hello", "hi");
      ints.put(1, 1001);
      strings.put("World", "all");
      ints.put(2, 1002);

      verify(stringsListener);
      verify(intListener);

      assertEquals("{Hello=hi, World=all}", strings.toString());
      assertEquals("{0=1000, 1=1001, 2=1002}", ints.toString());

      chronicle.close();
    }
    {
      MapListener stringsListener = createMock("strings", MapListener.class);
      stringsListener.eventStart(5, "strings");
      stringsListener.add("!", "end");
      stringsListener.eventEnd(true);

      MapListener intListener = createMock("ints", MapListener.class);

      intListener.eventStart(6, "ints");
      intListener.add(3, 1003);
      intListener.eventEnd(true);

      replay(stringsListener);
      replay(intListener);

      Chronicle chronicle = new IndexedChronicle(name);
      DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
      MapWrapper<String, String> strings =
          new MapWrapper<String, String>(
              dataStore,
              "strings",
              String.class,
              String.class,
              new LinkedHashMap<String, String>(),
              16);
      strings.addListener(stringsListener);
      MapWrapper<Integer, Integer> ints =
          new MapWrapper<Integer, Integer>(
              dataStore,
              "ints",
              Integer.class,
              Integer.class,
              new LinkedHashMap<Integer, Integer>(),
              16);
      ints.addListener(intListener);

      // assume we have  all the events written so far
      dataStore.start(chronicle.size());

      strings.put("!", "end");
      ints.put(3, 1003);

      verify(stringsListener);
      verify(intListener);

      assertEquals("{Hello=hi, World=all, !=end}", strings.toString());
      assertEquals("{0=1000, 1=1001, 2=1002, 3=1003}", ints.toString());
      chronicle.close();
    }
  }
Example #3
0
  @Test
  public void testMapPerformance() throws IOException {
    String name = TMP + "/map-perf";
    ChronicleTools.deleteOnExit(name);
    long start = System.nanoTime();
    int size = 0;
    {
      Chronicle chronicle = new IndexedChronicle(name);
      DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
      MapWrapper<String, String> strings =
          new MapWrapper<String, String>(
              dataStore,
              "strings",
              String.class,
              String.class,
              new LinkedHashMap<String, String>(),
              16);
      MapWrapper<Integer, Integer> ints =
          new MapWrapper<Integer, Integer>(
              dataStore,
              "ints",
              Integer.class,
              Integer.class,
              new LinkedHashMap<Integer, Integer>(),
              16);
      dataStore.start();
      ints.clear();
      strings.clear();

      for (int j = 0; j < 10000; j++) {
        for (int i = 0; i < 100; i++) {
          ints.put(i, i + j);
          strings.put(Integer.toString(i), Integer.toString(i + j));
        }
        size += Math.min(strings.size(), ints.size());
        for (int i = 0; i < 100; i++) {
          ints.remove(i);
          strings.remove(Integer.toString(i));
        }
      }

      chronicle.close();
    }
    long mid = System.nanoTime();
    {
      Chronicle chronicle = new IndexedChronicle(name);
      DataStore dataStore = new DataStore(chronicle, ModelMode.MASTER);
      MapWrapper<String, String> strings =
          new MapWrapper<String, String>(
              dataStore,
              "strings",
              String.class,
              String.class,
              new LinkedHashMap<String, String>(),
              16);
      MapWrapper<Integer, Integer> ints =
          new MapWrapper<Integer, Integer>(
              dataStore,
              "ints",
              Integer.class,
              Integer.class,
              new LinkedHashMap<Integer, Integer>(),
              16);
      dataStore.start();
      chronicle.close();
    }
    long end = System.nanoTime();
    System.out.printf(
        "Took %.1f seconds avg to add&remove %,d elements and %.1f seconds avg to reload them%n",
        (mid - start) / 2e9, size, (end - mid) / 2e9);
  }