add:Benchmark Test

src/test/java/packet/CPacketBenchmark.java

@@ -0,0 +1,120 @@
+package packet;/*
+ * @Author: feng Zhao
+ * @Description:
+ * @Version: 1.0.0
+ * @Date: 16:41 2021/4/22
+ * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
+ */
+
+import encoding.*;
+import org.bouncycastle.crypto.CryptoException;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+@BenchmarkMode(Mode.AverageTime)
+@State(Scope.Thread)
+@Fork(1)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+public class CPacketBenchmark {
+    private static byte[] payLoad;
+    private static byte[] payLoad1K;
+    private static byte[] payLoad8K;
+    private static CPacket packet = new CPacket();
+    private static CPacket packet1K= new CPacket();
+    private static CPacket packet8K= new CPacket();
+
+    private static byte[] createPayload(int mode){
+        byte[] res = null;
+        switch (mode){
+            case 0:
+                return new byte[]{1};
+            case 1:
+                res = new byte[1024];
+                for (int i = 0; i < 1024 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            case 8:
+                res = new byte[8192];
+                for (int i = 0; i < 8192 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            default:
+                return res;
+        }
+    }
+    static {
+        try {
+            payLoad = createPayload(0);
+            payLoad1K = createPayload(1);
+            payLoad8K = createPayload(8);
+            packet.payload.setValue(payLoad);
+            packet1K.payload.setValue(payLoad1K);
+            packet8K.payload.setValue(payLoad8K);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Benchmark
+    public void testEncode() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        packet.wireEncode(encoder);
+    }
+
+
+    @Benchmark
+    public void testEncode1k() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        packet1K.wireEncode(encoder);
+    }
+    @Benchmark
+    public void testEncode8k() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        packet8K.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public void testEncode_Decode() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        packet.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        CPacket cPacket = new CPacket();
+        cPacket.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode1K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        packet1K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        CPacket cPacket = new CPacket();
+        cPacket.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode8K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        packet8K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        CPacket cPacket = new CPacket();
+        cPacket.wireDecode(block);
+    }
+}

src/test/java/packet/DataBenchmark.java

@@ -0,0 +1,115 @@
+package packet;/*
+ * @Author: feng Zhao
+ * @Description:
+ * @Version: 1.0.0
+ * @Date: 19:02 2021/4/22
+ * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
+ */
+
+import encoding.*;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@State(Scope.Thread)
+@Fork(1)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+public class DataBenchmark {
+    private static byte[] payLoad;
+    private static byte[] payLoad1K;
+    private static byte[] payLoad8K;
+    private static Data data = new Data();
+    private static Data data1K = new Data();
+    private static Data data8K = new Data();
+
+    private static byte[] createPayload(int mode){
+        byte[] res = null;
+        switch (mode){
+            case 0:
+                return new byte[]{1};
+            case 1:
+                res = new byte[1024];
+                for (int i = 0; i < 1024 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            case 8:
+                res = new byte[8192];
+                for (int i = 0; i < 8192 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            default:
+                return res;
+        }
+    }
+    static {
+        try {
+            payLoad = createPayload(0);
+            payLoad1K = createPayload(1);
+            payLoad8K = createPayload(8);
+            data.payload.setValue(payLoad);
+            data1K.payload.setValue(payLoad1K);
+            data8K.payload.setValue(payLoad8K);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Benchmark
+    public static void testEncode() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        data.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public static void testEncode1K() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        data1K.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public static void testEncode8K() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        data8K.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public void testEncode_Decode() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        data.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        Data newData = new Data();
+        newData.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode1K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        data1K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        Data newData = new Data();
+        newData.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode8K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        data8K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        Data newData = new Data();
+        newData.wireDecode(block);
+    }
+}

src/test/java/packet/InterestBenchmark.java

@@ -0,0 +1,115 @@
+package packet;/*
+ * @Author: feng Zhao
+ * @Description:
+ * @Version: 1.0.0
+ * @Date: 20:00 2021/4/22
+ * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
+ */
+
+import encoding.*;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@State(Scope.Thread)
+@Fork(1)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+public class InterestBenchmark {
+    private static byte[] payLoad;
+    private static byte[] payLoad1K;
+    private static byte[] payLoad8K;
+    private static Interest interest = new Interest();
+    private static Interest interest1K = new Interest();
+    private static Interest interest8K = new Interest();
+
+    private static byte[] createPayload(int mode){
+        byte[] res = null;
+        switch (mode){
+            case 0:
+                return new byte[]{1};
+            case 1:
+                res = new byte[1024];
+                for (int i = 0; i < 1024 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            case 8:
+                res = new byte[8192];
+                for (int i = 0; i < 8192 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            default:
+                return res;
+        }
+    }
+    static {
+        try {
+            payLoad = createPayload(0);
+            payLoad1K = createPayload(1);
+            payLoad8K = createPayload(8);
+            interest.payload.setValue(payLoad);
+            interest1K.payload.setValue(payLoad1K);
+            interest8K.payload.setValue(payLoad8K);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Benchmark
+    public static void testEncode() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        interest.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public static void testEncode1K() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        interest1K.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public static void testEncode8K() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        interest8K.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public void testEncode_Decode() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        interest.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        Interest newInterest = new Interest();
+        newInterest.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode1K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        interest1K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        Interest newInterest = new Interest();
+        newInterest.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode8K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        interest8K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        Interest newInterest = new Interest();
+        newInterest.wireDecode(block);
+    }
+}

src/test/java/packet/LpPacketBenchmark.java

@@ -0,0 +1,115 @@
+package packet;/*
+ * @Author: feng Zhao
+ * @Description:
+ * @Version: 1.0.0
+ * @Date: 22:36 2021/4/22
+ * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
+ */
+
+import encoding.*;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@State(Scope.Thread)
+@Fork(1)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+public class LpPacketBenchmark {
+    private static byte[] payLoad;
+    private static byte[] payLoad1K;
+    private static byte[] payLoad8K;
+    private static LpPacket lpPacket = new LpPacket();
+    private static LpPacket lpPacket1K = new LpPacket();
+    private static LpPacket lpPacket8K = new LpPacket();
+
+    private static byte[] createPayload(int mode){
+        byte[] res = null;
+        switch (mode){
+            case 0:
+                return new byte[]{1};
+            case 1:
+                res = new byte[1024];
+                for (int i = 0; i < 1024 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            case 8:
+                res = new byte[8192];
+                for (int i = 0; i < 8192 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            default:
+                return res;
+        }
+    }
+    static {
+        try {
+            payLoad = createPayload(0);
+            payLoad1K = createPayload(1);
+            payLoad8K = createPayload(8);
+            lpPacket.payload.setValue(payLoad);
+            lpPacket1K.payload.setValue(payLoad1K);
+            lpPacket8K.payload.setValue(payLoad8K);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Benchmark
+    public static void testEncode() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        lpPacket.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public static void testEncode1K() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        lpPacket1K.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public static void testEncode8K() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        lpPacket8K.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public void testEncode_Decode() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        lpPacket.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        LpPacket packet = new LpPacket();
+        packet.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode1K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        lpPacket1K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        LpPacket packet = new LpPacket();
+        packet.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode8K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        lpPacket8K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        LpPacket packet = new LpPacket();
+        packet.wireDecode(block);
+    }
+}

src/test/java/packet/NackBenchmark.java

@@ -0,0 +1,119 @@
+package packet;/*
+ * @Author: feng Zhao
+ * @Description:
+ * @Version: 1.0.0
+ * @Date: 20:19 2021/4/22
+ * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
+ */
+
+import encoding.*;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.concurrent.TimeUnit;
+
+
+@BenchmarkMode(Mode.AverageTime)
+@State(Scope.Thread)
+@Fork(1)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+public class NackBenchmark {
+    private static byte[] payLoad;
+    private static byte[] payLoad1K;
+    private static byte[] payLoad8K;
+    private static Interest interest = new Interest();
+    private static Interest interest1K = new Interest();
+    private static Interest interest8K = new Interest();
+
+    private static byte[] createPayload(int mode){
+        byte[] res = null;
+        switch (mode){
+            case 0:
+                return new byte[]{1};
+            case 1:
+                res = new byte[1024];
+                for (int i = 0; i < 1024 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            case 8:
+                res = new byte[8192];
+                for (int i = 0; i < 8192 ; i++) {
+                    res[i] = (byte) (i % 128);
+                }
+                return res;
+            default:
+                return res;
+        }
+    }
+    static {
+        try {
+            payLoad = createPayload(0);
+            payLoad1K = createPayload(1);
+            payLoad8K = createPayload(8);
+            interest.payload.setValue(payLoad);
+            interest1K.payload.setValue(payLoad1K);
+            interest8K.payload.setValue(payLoad8K);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Benchmark
+    public static void testEncode() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        Nack nack = new Nack(interest,2333);
+        nack.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public static void testEncode1K() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        Nack nack1K = new Nack(interest1K,2333);
+        nack1K.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public static void testEncode8K() throws EncoderException, PacketException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        Nack nack8K = new Nack(interest8K,2333);
+        nack8K.wireEncode(encoder);
+    }
+
+    @Benchmark
+    public void testEncode_Decode() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        Nack nack = new Nack(interest,2333);
+        nack.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        nack.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode1K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        Nack nack1K = new Nack(interest1K,2333);
+        nack1K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        nack1K.wireDecode(block);
+    }
+
+    @Benchmark
+    public void testEncode_Decode8K() throws EncoderException, PacketException, BlockException {
+        Encoder encoder=new Encoder();
+        encoder.encoderReset(new SizeT(Encoder.MaxPacketSize),new SizeT(0));
+        Nack nack8K = new Nack(interest8K,2333);
+        nack8K.wireEncode(encoder);
+        byte[] buf = encoder.getBuffer();
+        Block block = Block.createBlockByBuffer(buf,false);
+        nack8K.wireDecode(block);
+    }
+}