Ejemplo n.º 1
0
  @Test
  public void testMultiThreads() throws IOException {
    mappedPageFactory =
        new MappedPageFactoryImpl(1024 * 1024 * 128, testDir + "/test_multi_threads", 2 * 1000);

    int pageNumLimit = 200;
    int threadNum = 1000;

    Map<Integer, IMappedPage[]> sharedMap1 =
        this.testAndGetSharedMap(mappedPageFactory, threadNum, pageNumLimit);
    assertTrue(this.mappedPageFactory.getCacheSize() == pageNumLimit);
    Map<Integer, IMappedPage[]> sharedMap2 =
        this.testAndGetSharedMap(mappedPageFactory, threadNum, pageNumLimit);
    assertTrue(this.mappedPageFactory.getCacheSize() == pageNumLimit);
    // pages in two maps should be same since they are all cached
    verifyMap(sharedMap1, sharedMap2, threadNum, pageNumLimit, true);
    verifyClosed(sharedMap1, threadNum, pageNumLimit, false);

    TestUtil.sleepQuietly(2500);
    this.mappedPageFactory.acquirePage(pageNumLimit + 1); // trigger mark&sweep
    assertTrue(this.mappedPageFactory.getCacheSize() == 1);
    Map<Integer, IMappedPage[]> sharedMap3 =
        this.testAndGetSharedMap(mappedPageFactory, threadNum, pageNumLimit);
    assertTrue(this.mappedPageFactory.getCacheSize() == pageNumLimit + 1);
    // pages in two maps should be different since all pages in sharedMap1 has expired and purged
    // out
    verifyMap(sharedMap1, sharedMap3, threadNum, pageNumLimit, false);
    verifyClosed(sharedMap3, threadNum, pageNumLimit, false);

    verifyClosed(sharedMap1, threadNum, pageNumLimit, true);

    // ensure no memory leak
    assertTrue(((MappedPageFactoryImpl) mappedPageFactory).getLockMapSize() == 0);
  }
Ejemplo n.º 2
0
  @Test
  public void testSingleThread() throws IOException {

    mappedPageFactory =
        new MappedPageFactoryImpl(1024 * 1024 * 128, testDir + "/test_single_thread", 2 * 1000);

    IMappedPage mappedPage = mappedPageFactory.acquirePage(0); // first acquire
    assertNotNull(mappedPage);
    IMappedPage mappedPage0 = mappedPageFactory.acquirePage(0); // second acquire
    assertSame(mappedPage, mappedPage0);

    IMappedPage mappedPage1 = mappedPageFactory.acquirePage(1);
    assertNotSame(mappedPage0, mappedPage1);

    mappedPageFactory.releasePage(0); // release first acquire
    mappedPageFactory.releasePage(0); // release second acquire
    TestUtil.sleepQuietly(2200); // let page0 expire
    mappedPageFactory.acquirePage(2); // trigger mark&sweep and purge old page0
    mappedPage = mappedPageFactory.acquirePage(0); // create a new page0
    assertNotSame(mappedPage, mappedPage0);
    TestUtil.sleepQuietly(1000); // let the async cleaner do the job
    assertTrue(!mappedPage.isClosed());
    assertTrue(mappedPage0.isClosed());

    for (long i = 0; i < 100; i++) {
      assertNotNull(mappedPageFactory.acquirePage(i));
    }
    assertTrue(mappedPageFactory.getCacheSize() == 100);
    Set<Long> indexSet = mappedPageFactory.getExistingBackFileIndexSet();
    assertTrue(indexSet.size() == 100);
    for (long i = 0; i < 100; i++) {
      assertTrue(indexSet.contains(i));
    }

    this.mappedPageFactory.deletePage(0);
    assertTrue(mappedPageFactory.getCacheSize() == 99);
    indexSet = mappedPageFactory.getExistingBackFileIndexSet();
    assertTrue(indexSet.size() == 99);

    this.mappedPageFactory.deletePage(1);
    assertTrue(mappedPageFactory.getCacheSize() == 98);
    indexSet = mappedPageFactory.getExistingBackFileIndexSet();
    assertTrue(indexSet.size() == 98);

    for (long i = 2; i < 50; i++) {
      this.mappedPageFactory.deletePage(i);
    }
    assertTrue(mappedPageFactory.getCacheSize() == 50);
    indexSet = mappedPageFactory.getExistingBackFileIndexSet();
    assertTrue(indexSet.size() == 50);

    this.mappedPageFactory.deleteAllPages();
    assertTrue(mappedPageFactory.getCacheSize() == 0);
    indexSet = mappedPageFactory.getExistingBackFileIndexSet();
    assertTrue(indexSet.size() == 0);

    long start = System.currentTimeMillis();
    for (long i = 0; i < 5; i++) {
      assertNotNull(this.mappedPageFactory.acquirePage(i));
      TestUtil.sleepQuietly(1000);
    }
    indexSet = mappedPageFactory.getPageIndexSetBefore(start - 1000);
    assertTrue(indexSet.size() == 0);
    indexSet = mappedPageFactory.getPageIndexSetBefore(start + 2500);
    assertTrue(indexSet.size() == 3);
    indexSet = mappedPageFactory.getPageIndexSetBefore(start + 5000);
    assertTrue(indexSet.size() == 5);

    mappedPageFactory.deletePagesBefore(start + 2500);
    indexSet = mappedPageFactory.getExistingBackFileIndexSet();
    assertTrue(indexSet.size() == 2);
    assertTrue(mappedPageFactory.getCacheSize() == 2);

    mappedPageFactory.releaseCachedPages();
    assertTrue(mappedPageFactory.getCacheSize() == 0);

    assertTrue(((MappedPageFactoryImpl) mappedPageFactory).getLockMapSize() == 0);
    mappedPageFactory.deleteAllPages();

    start = System.currentTimeMillis();
    for (int i = 0; i <= 100; i++) {
      IMappedPage mappedPageI = mappedPageFactory.acquirePage(i);
      mappedPageI.getLocal(0).put(("hello " + i).getBytes());
      mappedPageI.setDirty(true);
      ((MappedPageImpl) mappedPageI).flush();
      long currentTime = System.currentTimeMillis();
      long iPageFileLastModifiedTime = mappedPageFactory.getPageFileLastModifiedTime(i);
      assertTrue(iPageFileLastModifiedTime >= start);
      assertTrue(iPageFileLastModifiedTime <= currentTime);

      long index = mappedPageFactory.getFirstPageIndexBefore(currentTime + 1);
      assertTrue(index == i);

      start = currentTime;
    }

    mappedPageFactory.deleteAllPages();

    // test wrapped case
    mappedPageFactory.acquirePage(Long.MAX_VALUE - 1);
    mappedPageFactory.acquirePage(Long.MAX_VALUE);
    long index = mappedPageFactory.getFirstPageIndexBefore(System.currentTimeMillis() + 1);
    assertTrue(index == Long.MAX_VALUE);

    mappedPageFactory.acquirePage(0);
    index = mappedPageFactory.getFirstPageIndexBefore(System.currentTimeMillis() + 1);
    assertTrue(index == 0);

    mappedPageFactory.acquirePage(1);
    index = mappedPageFactory.getFirstPageIndexBefore(System.currentTimeMillis() + 1);
    assertTrue(index == 1);
  }