Java tutorial
/** * Copyright 2013, Landz and its contributors. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package z.offheap.contrast.netty; import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBufAllocator; import io.netty.buffer.PooledByteBufAllocator; import org.junit.FixMethodOrder; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ErrorCollector; import org.junit.runners.MethodSorters; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.core.Is.is; @FixMethodOrder(MethodSorters.NAME_ASCENDING) public class SlabFragmentationTest { private static final ByteBufAllocator POOLED_ALLOCATOR_DIRECT = new PooledByteBufAllocator(true); private static final int[] sizes = { 0, 256, 1024, 4096, 65536, 256 * 1024, 1024 * 1024 }; private static final ByteBufAllocator[] allocators = { POOLED_ALLOCATOR_DIRECT };// UNPOOLED_ALLOCATOR_DIRECT}; //XXX: ByteBuf instances should be on heap private ByteBuf[] bufs1; private ByteBuf[] bufs2; private ByteBuf[] bufs3; private ByteBuf[] bufs4; private ByteBuf[] bufs5; @Rule public ErrorCollector collector = new ErrorCollector(); @Test public void testSlabClassification1() { //============== sweep all bufs1 = new ByteBuf[100_000]; bufs2 = new ByteBuf[300_000]; bufs3 = new ByteBuf[150_000]; bufs4 = new ByteBuf[800_000]; bufs5 = new ByteBuf[5_000]; int size = 0; //============== < 800_000k initial free, but not sure exact number size = 7 * 1024; System.out.println("======1.1: apply 100_000*7k..."); for (int i = 0; i < 100_000; i++) { bufs1[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } // System.out.println(POOLED_ALLOCATOR_DIRECT); System.out.println("======1.2: free 50_000*7*1024..."); for (int i = 0; i < 50_000; i++) { bufs1[i].release(); } assertThat(bufs1[49_999].toString().contains("free"), is(true)); assertThat(bufs1[50_000].toString().contains("free"), is(false)); //============== 350_000k used size = 1024; System.out.println("======2.1: apply 300_000*1024(<50_000*7k)..."); for (int i = 0; i < 300_000; i++) { bufs2[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } System.out.println("======2.2: free all 1k bufs..."); for (int i = 0; i < bufs2.length; i++) { bufs2[i].release(); } assertThat(bufs2[0].toString().contains("free"), is(true)); assertThat(bufs2[1].toString().contains("free"), is(true)); //============== 350_000k used size = 2 * 1024; System.out.println("======3.1: apply 150_000*2k(=300_000*1024)..."); for (int i = 0; i < 150_000; i++) { bufs3[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } System.out.println("======3.2: free 100_000 2k bufs..."); for (int i = 0; i < 100_000; i++) { bufs3[i].release(); } assertThat(bufs3[99_999].toString().contains("free"), is(true)); assertThat(bufs3[100_000].toString().contains("free"), is(false)); //============== 450_000k used size = 256; System.out.println("======4.1: apply 800_000*256(=200_000*1024)..."); for (int i = 0; i < 800_000; i++) { bufs4[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } // System.out.println("======4.2: free all 800_000 256 bufs..."); // for (int i = 0; i < bufs4.length; i++) { // bufs4[i].release(); // } //============== 650_000k used size = 16 * 1024; System.out.println("======5.1: apply 5_000*16*1024(=80_000*1024)..."); for (int i = 0; i < 5_000; i++) { bufs5[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } //============== 730_000k used //============== free all for (ByteBuf buf : bufs1) if (buf != null && buf.refCnt() != 0) buf.release(); for (ByteBuf buf : bufs2) if (buf != null && buf.refCnt() != 0) buf.release(); for (ByteBuf buf : bufs3) if (buf != null && buf.refCnt() != 0) buf.release(); for (ByteBuf buf : bufs4) if (buf != null && buf.refCnt() != 0) buf.release(); for (ByteBuf buf : bufs5) if (buf != null && buf.refCnt() != 0) buf.release(); } @Test public void testSlabClassification2() { //============== sweep all bufs1 = new ByteBuf[100_000]; bufs2 = new ByteBuf[300_000]; bufs3 = new ByteBuf[150_000]; bufs4 = new ByteBuf[800_000]; bufs5 = new ByteBuf[2000]; int size = 0; //============== < 800_000k initial free, but not sure exact number size = 7 * 1024; System.out.println("======1.1: apply 100_000*7k..."); for (int i = 0; i < 100_000; i++) { bufs1[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } // System.out.println(POOLED_ALLOCATOR_DIRECT); System.out.println("======1.2: free 50_000*7*1024..."); for (int i = 0; i < 100_000; i += 2) { bufs1[i].release(); } assertThat(bufs1[49_999].toString().contains("free"), is(false)); assertThat(bufs1[50_000].toString().contains("free"), is(true)); //============== 350_000k used size = 1024; System.out.println("======2.1: apply 300_000*1024(<50_000*7k)..."); for (int i = 0; i < 300_000; i++) { bufs2[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } System.out.println("======2.2: free all 1k bufs..."); for (int i = 0; i < bufs2.length; i++) { bufs2[i].release(); } assertThat(bufs2[0].toString().contains("free"), is(true)); assertThat(bufs2[1].toString().contains("free"), is(true)); //============== 350_000k used size = 2 * 1024; System.out.println("======3.1: apply 150_000*2k(=300_000*1024)..."); for (int i = 0; i < 150_000; i++) { bufs3[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } System.out.println("======3.2: free 50_000 2k bufs from 0 to 50_000..."); for (int i = 0; i < 50_000; i++) { bufs3[i].release(); } System.out.println("======3.3: free 50_000 2k bufs from 50_000 to 150_000 in interleaved style..."); for (int i = 50_000; i < 150_000; i += 2) { bufs3[i].release(); } assertThat(bufs3[99_999].toString().contains("free"), is(false)); assertThat(bufs3[100_000].toString().contains("free"), is(true)); //============== 450_000k used size = 256; System.out.println("======4.1: apply 800_000*256(=200_000*1024)..."); for (int i = 0; i < 800_000; i++) { bufs4[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } //============== 650_000k used try { size = 16 * 1024; System.out.println("======5.1: apply 2000*16*1024(=32_000*1024)..."); for (int i = 0; i < 2000; i++) { bufs5[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } } catch (Exception e) { collector.addError(e); } finally { //============== free all System.out.println("======testSlabClassification2 free all..."); for (ByteBuf buf : bufs1) if (buf != null && buf.refCnt() != 0) buf.release(); for (ByteBuf buf : bufs2) if (buf != null && buf.refCnt() != 0) buf.release(); for (ByteBuf buf : bufs3) if (buf != null && buf.refCnt() != 0) buf.release(); for (ByteBuf buf : bufs4) if (buf != null && buf.refCnt() != 0) buf.release(); for (ByteBuf buf : bufs5) if (buf != null && buf.refCnt() != 0) buf.release(); System.out.println("======testSlabClassification2 done."); } //============== 682_000k used } @Test public void testSlabClassification3() { //============== sweep all bufs1 = new ByteBuf[500_000]; bufs2 = new ByteBuf[200_000]; bufs3 = null; bufs4 = null; bufs5 = null; try { int size = 0; //============== < 800_000k initial free, but not sure exact number size = 1024; System.out.println("======1.1: apply 500_000*1024..."); for (int i = 0; i < 500_000; i++) { bufs1[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } System.out.println("======1.2: free 250_000*1k bufs..."); for (int i = 0; i < 500_000; i += 2) { bufs1[i].release(); } assertThat(bufs1[250_000].toString().contains("free"), is(true)); assertThat(bufs1[249_999].toString().contains("free"), is(false)); //============== 250_000k used size = 256; System.out.println("======2.1: apply 200_000*256(=50_000*1024)..."); for (int i = 0; i < 200_000; i++) { bufs2[i] = (POOLED_ALLOCATOR_DIRECT.buffer(size)); } } catch (Exception e) { collector.addError(e); } finally { //============== free all System.out.println("======testSlabClassification3 free all..."); for (ByteBuf buf : bufs1) if (buf != null && buf.refCnt() != 0) buf.release(); for (ByteBuf buf : bufs2) if (buf != null && buf.refCnt() != 0) buf.release(); System.out.println("======testSlabClassification3 done."); } } }