Esempio n. 1
0
        private static void test(int N, int nbr)
        {
            ClusteredDataGenerator cdg = new ClusteredDataGenerator();

            Console.WriteLine("[BasicTest.test] N = " + N + " " + nbr);
            for (int sparsity = 1; sparsity < 31 - nbr; sparsity += 4)
            {
                int[][] data = new int[N][];
                int     max  = (1 << (nbr + sparsity));
                for (int k = 0; k < N; ++k)
                {
                    data[k] = cdg.generateClustered((1 << nbr), max);
                }

                testCodec(new IntegratedComposition(new IntegratedBinaryPacking(), new IntegratedVariableByte()), new IntegratedComposition(new IntegratedBinaryPacking(), new IntegratedVariableByte()), data, max);
                testCodec(new JustCopy(), new JustCopy(), data, max);
                testCodec(new VariableByte(), new VariableByte(), data, max);
                testCodec(new IntegratedVariableByte(), new IntegratedVariableByte(), data, max);
                testCodec(new Composition(new BinaryPacking(), new VariableByte()), new Composition(new BinaryPacking(), new VariableByte()), data, max);
                testCodec(new Composition(new NewPFD(), new VariableByte()), new Composition(new NewPFD(), new VariableByte()), data, max);
                testCodec(new Composition(new NewPFDS9(), new VariableByte()), new Composition(new NewPFDS9(), new VariableByte()), data, max);
                testCodec(new Composition(new NewPFDS16(), new VariableByte()), new Composition(new NewPFDS16(), new VariableByte()), data, max);
                testCodec(new Composition(new OptPFD(), new VariableByte()), new Composition(new OptPFD(), new VariableByte()), data, max);
                testCodec(new Composition(new OptPFDS9(), new VariableByte()), new Composition(new OptPFDS9(), new VariableByte()), data, max);
                testCodec(new Composition(new OptPFDS16(), new VariableByte()), new Composition(new OptPFDS16(), new VariableByte()), data, max);
                testCodec(new Composition(new FastPFOR128(), new VariableByte()), new Composition(new FastPFOR128(), new VariableByte()), data, max);
                testCodec(new Composition(new FastPFOR(), new VariableByte()), new Composition(new FastPFOR(), new VariableByte()), data, max);
                testCodec(new Simple9(), new Simple9(), data, max);
            }
        }
        /**
         * Generate test data.
         *
         * @param N
         *            How many input arrays to generate
         * @param nbr
         *            How big (in log2) should the arrays be
         * @param sparsity
         *            How sparse test data generated
         */
        private static int[][] generateTestData(ClusteredDataGenerator dataGen, int N, int nbr, int sparsity)
        {
            int[][] data = new int[N][];

            int dataSize = (1 << (nbr + sparsity));

            for (int i = 0; i < N; ++i)
            {
                data[i] = dataGen.generateClustered((1 << nbr), dataSize);
            }
            return(data);
        }
Esempio n. 3
0
        private static void test(IntegerCODEC c, IntegerCODEC co, int N, int nbr)
        {
            ClusteredDataGenerator cdg = new ClusteredDataGenerator();

            for (int sparsity = 1; sparsity < 31 - nbr; sparsity += 4)
            {
                int[][] data = new int[N][];
                int     max  = (1 << (nbr + 9));
                for (int k = 0; k < N; ++k)
                {
                    data[k] = cdg.generateClustered((1 << nbr), max);
                }

                testCodec(c, co, data, max);
            }
        }
        /**
         * Generates data and calls other tests.
         *
         * @param csvLog
         *            Writer for CSV log.
         * @param N
         *            How many input arrays to generate
         * @param nbr
         *            how big (in log2) should the arrays be
         * @param repeat
         *            How many times should we repeat tests.
         */
        public static void test(StreamWriter csvLog, int N, int nbr, int repeat)
        {
            csvLog.WriteLine("\"Algorithm\",\"Sparsity\",\"Bits per int\",\"Compress speed (MiS)\",\"Decompress speed (MiS)\"");
            ClusteredDataGenerator cdg = new ClusteredDataGenerator();

            int max_sparsity = 31 - nbr;

            for (int sparsity = 1; sparsity < max_sparsity; sparsity += 4)
            {
                Console.WriteLine("# sparsity " + sparsity);
                Console.WriteLine("# generating random data...");
                int[][] data = generateTestData(cdg, N, nbr, sparsity);
                Console.WriteLine("# generating random data... ok.");
                foreach (object c in codecs)
                {
                    testCodec(csvLog, sparsity, c, data, repeat, false);
                    testCodec(csvLog, sparsity, c, data, repeat, false);
                    testCodec(csvLog, sparsity, c, data, repeat, true);
                    testCodec(csvLog, sparsity, c, data, repeat, true);
                    testCodec(csvLog, sparsity, c, data, repeat, true);
                }
            }
        }
Esempio n. 5
0
        /**
         * Generates data and calls other tests.
         *
         * @param csvLog
         *                Writer for CSV log.
         * @param N
         *                How many input arrays to generate
         * @param nbr
         *                how big (in log2) should the arrays be
         * @param repeat
         *                How many times should we repeat tests.
         */
        public static void test(StreamWriter csvLog, int N, int nbr, int repeat)
        {
            csvLog.WriteLine("\"Algorithm\",\"Sparsity\",\"Bits per int\",\"Compress speed (MiS)\",\"Decompress speed (MiS)\"");
            ClusteredDataGenerator cdg = new ClusteredDataGenerator();

            int max_sparsity = 31 - nbr;

            for (int sparsity = 1; sparsity < max_sparsity; ++sparsity)
            {
                Console.WriteLine("# sparsity " + sparsity);
                Console.WriteLine("# generating random data...");
                int[][] data = generateTestData(cdg, N, nbr, sparsity);
                Console.WriteLine("# generating random data... ok.");

                testCodec(csvLog, sparsity, new Composition(
                              new FastPFOR128(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new FastPFOR128(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new FastPFOR128(), new VariableByte()), data,
                          repeat, true);
                Console.WriteLine();
                testCodec(csvLog, sparsity, new Composition(
                              new FastPFOR(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new FastPFOR(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new FastPFOR(), new VariableByte()), data,
                          repeat, true);
                Console.WriteLine();

                //TODO: port
                // TODO: support CSV log output.
                //testKamikaze(data, repeat, false);
                //testKamikaze(data, repeat, false);
                //testKamikaze(data, repeat, true);
                Console.WriteLine();

                testCodec(csvLog, sparsity, new IntegratedComposition(
                              new IntegratedBinaryPacking(),
                              new IntegratedVariableByte()), data, repeat,
                          false);
                testCodec(csvLog, sparsity, new IntegratedComposition(
                              new IntegratedBinaryPacking(),
                              new IntegratedVariableByte()), data, repeat,
                          false);
                testCodec(csvLog, sparsity, new IntegratedComposition(
                              new IntegratedBinaryPacking(),
                              new IntegratedVariableByte()), data, repeat,
                          true);
                Console.WriteLine();

                testCodec(csvLog, sparsity, new JustCopy(), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new JustCopy(), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new JustCopy(), data,
                          repeat, true);
                Console.WriteLine();

                testByteCodec(csvLog, sparsity, new VariableByte(),
                              data, repeat, false);
                testByteCodec(csvLog, sparsity, new VariableByte(),
                              data, repeat, false);
                testByteCodec(csvLog, sparsity, new VariableByte(),
                              data, repeat, true);
                Console.WriteLine();

                testByteCodec(csvLog, sparsity,
                              new IntegratedVariableByte(), data, repeat,
                              false);
                testByteCodec(csvLog, sparsity,
                              new IntegratedVariableByte(), data, repeat,
                              false);
                testByteCodec(csvLog, sparsity,
                              new IntegratedVariableByte(), data, repeat,
                              true);
                Console.WriteLine();

                testCodec(csvLog, sparsity, new Composition(
                              new BinaryPacking(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new BinaryPacking(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new BinaryPacking(), new VariableByte()), data,
                          repeat, true);
                Console.WriteLine();

                testCodec(csvLog, sparsity, new Composition(
                              new NewPFD(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new NewPFD(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new NewPFD(), new VariableByte()), data,
                          repeat, true);
                Console.WriteLine();

                testCodec(csvLog, sparsity, new Composition(
                              new NewPFDS9(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new NewPFDS9(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new NewPFDS9(), new VariableByte()), data,
                          repeat, true);
                Console.WriteLine();

                testCodec(csvLog, sparsity, new Composition(
                              new NewPFDS16(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new NewPFDS16(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new NewPFDS16(), new VariableByte()), data,
                          repeat, true);
                Console.WriteLine();

                testCodec(csvLog, sparsity, new Composition(
                              new OptPFD(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new OptPFD(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new OptPFD(), new VariableByte()), data,
                          repeat, true);
                Console.WriteLine();

                testCodec(csvLog, sparsity, new Composition(
                              new OptPFDS9(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new OptPFDS9(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new OptPFDS9(), new VariableByte()), data,
                          repeat, true);
                Console.WriteLine();

                testCodec(csvLog, sparsity, new Composition(
                              new OptPFDS16(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new OptPFDS16(), new VariableByte()), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Composition(
                              new OptPFDS16(), new VariableByte()), data,
                          repeat, true);
                Console.WriteLine();


                testCodec(csvLog, sparsity, new Simple9(), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Simple9(), data,
                          repeat, false);
                testCodec(csvLog, sparsity, new Simple9(), data,
                          repeat, true);
                Console.WriteLine();

                {
                    IntegerCODEC c = new Composition(
                        new XorBinaryPacking(),
                        new VariableByte());
                    testCodec(csvLog, sparsity, c, data, repeat,
                              false);
                    testCodec(csvLog, sparsity, c, data, repeat,
                              false);
                    testCodec(csvLog, sparsity, c, data, repeat,
                              true);
                    Console.WriteLine();
                }

                {
                    IntegerCODEC c = new Composition(
                        new DeltaZigzagBinaryPacking(),
                        new DeltaZigzagVariableByte());
                    testCodec(csvLog, sparsity, c, data, repeat,
                              false);
                    testCodec(csvLog, sparsity, c, data, repeat,
                              false);
                    testCodec(csvLog, sparsity, c, data, repeat,
                              true);
                    Console.WriteLine();
                }
            }
        }