Examples of me.lemire.integercompression.IntWrapper

me.lemire.integercompression.IntWrapper
Essentially a mutable wrapper around an integer. @author dwu

        inlength = Util.greatestMultiple(inlength, BLOCK_SIZE);
        if (inlength == 0)
            return;
        out[outpos.get()] = inlength;
        outpos.increment();
        headlessCompress(in, inpos, inlength, out, outpos, new IntWrapper(0));
    }

View Full Code Here

            IntWrapper outpos) {
        if (inlength == 0)
            return;
        final int outlength = in[inpos.get()];
        inpos.increment();
        headlessUncompress(in,inpos,inlength,out,outpos,outlength, new IntWrapper(0));
    }

View Full Code Here

                }
        }


        private static int compress(PerformanceLogger logger, IntegerCODEC codec,
                int[] src, int[] dst) {
                IntWrapper inpos = new IntWrapper();
                IntWrapper outpos = new IntWrapper();
                logger.compressionTimer.start();
                codec.compress(src, inpos, src.length, dst, outpos);
                logger.compressionTimer.end();
                int outSize = outpos.get();
                logger.addOriginalSize(src.length);
                logger.addCompressedSize(outSize);
                return outSize;
        }

View Full Code Here

                return outSize;
        }


        private static int decompress(PerformanceLogger logger, IntegerCODEC codec,
                int[] src, int srcLen, int[] dst) {
                IntWrapper inpos = new IntWrapper();
                IntWrapper outpos = new IntWrapper();
                logger.decompressionTimer.start();
                codec.uncompress(src, inpos, srcLen, dst, outpos);
                logger.decompressionTimer.end();
                return outpos.get();
        }

View Full Code Here

                // These variables hold time in microseconds (10^-6).
                long compressTime = 0;
                long decompressTime = 0;


                int size = 0;
                IntWrapper inpos = new IntWrapper();
                IntWrapper outpos = new IntWrapper();


                for (int r = 0; r < repeat; ++r) {
                        size = 0;
                        for (int k = 0; k < N; ++k) {
                                int[] backupdata = Arrays.copyOf(data[k],
                                        data[k].length);


                                // compress data.
                                long beforeCompress = System.nanoTime() / 1000;
                                inpos.set(1);
                                outpos.set(0);
                                if (!(c instanceof IntegratedIntegerCODEC)) {
                                        Delta.delta(backupdata);
                                }
                                c.compress(backupdata, inpos, backupdata.length
                                        - inpos.get(), compressBuffer, outpos);
                                long afterCompress = System.nanoTime() / 1000;


                                // measure time of compression.
                                compressTime += afterCompress - beforeCompress;
                                final int thiscompsize = outpos.get() + 1;
                                size += thiscompsize;


                                // extract (uncompress) data
                                long beforeDecompress = System.nanoTime() / 1000;
                                inpos.set(0);
                                outpos.set(1);
                                decompressBuffer[0] = backupdata[0];
                                c.uncompress(compressBuffer, inpos,
                                        thiscompsize - 1, decompressBuffer,
                                        outpos);
                                if (!(c instanceof IntegratedIntegerCODEC))
                                        Delta.fastinverseDelta(decompressBuffer);
                                long afterDecompress = System.nanoTime() / 1000;


                                // measure time of extraction (uncompression).
                                decompressTime += afterDecompress
                                        - beforeDecompress;
                                if (outpos.get() != data[k].length)
                                        throw new RuntimeException(
                                                "we have a bug (diff length) "
                                                        + c + " expected "
                                                        + data[k].length
                                                        + " got "
                                                        + outpos.get());


                                // verify: compare original array with
                                // compressed and
                                // uncompressed.


                                for (int m = 0; m < outpos.get(); ++m) {
                                        if (decompressBuffer[m] != data[k][m]) {
                                                throw new RuntimeException(
                                                        "we have a bug (actual difference), expected "
                                                                + data[k][m]
                                                                + " found "

View Full Code Here

                // These variables hold time in microseconds (10^-6).
                long compressTime = 0;
                long decompressTime = 0;


                int size = 0;
                IntWrapper inpos = new IntWrapper();
                IntWrapper outpos = new IntWrapper();


                for (int r = 0; r < repeat; ++r) {
                        size = 0;
                        for (int k = 0; k < N; ++k) {
                                int[] backupdata = Arrays.copyOf(data[k],
                                        data[k].length);


                                // compress data.
                                long beforeCompress = System.nanoTime() / 1000;
                                inpos.set(1);
                                outpos.set(0);
                                if (!(c instanceof IntegratedByteIntegerCODEC)) {
                                        Delta.delta(backupdata);
                                }
                                c.compress(backupdata, inpos, backupdata.length
                                        - inpos.get(), compressBuffer, outpos);
                                long afterCompress = System.nanoTime() / 1000;


                                // measure time of compression.
                                compressTime += afterCompress - beforeCompress;
                                final int thiscompsize = outpos.get() + 1;
                                size += thiscompsize;


                                // extract (uncompress) data
                                long beforeDecompress = System.nanoTime() / 1000;
                                inpos.set(0);
                                outpos.set(1);
                                decompressBuffer[0] = backupdata[0];
                                c.uncompress(compressBuffer, inpos,
                                        thiscompsize - 1, decompressBuffer,
                                        outpos);
                                if (!(c instanceof IntegratedByteIntegerCODEC))
                                        Delta.fastinverseDelta(decompressBuffer);
                                long afterDecompress = System.nanoTime() / 1000;


                                // measure time of extraction (uncompression).
                                decompressTime += afterDecompress
                                        - beforeDecompress;
                                if (outpos.get() != data[k].length)
                                        throw new RuntimeException(
                                                "we have a bug (diff length) "
                                                        + c + " expected "
                                                        + data[k].length
                                                        + " got "
                                                        + outpos.get());


                                // verify: compare original array with
                                // compressed and
                                // uncompressed.
                                for (int m = 0; m < outpos.get(); ++m) {
                                        if (decompressBuffer[m] != data[k][m]) {
                                                throw new RuntimeException(
                                                        "we have a bug (actual difference), expected "
                                                                + data[k][m]
                                                                + " found "

View Full Code Here


    private static int compressWithSkipTable(Object c, int[] data,
            int[] output, IntWrapper outpos, int[] metadata, int blocksize) {
        int metapos = 0;
        metadata[metapos++] = data.length;
        IntWrapper inpos = new IntWrapper();
        int initvalue = 0;
        IntWrapper ival = new IntWrapper(initvalue);
        while (inpos.get() < data.length) {
            metadata[metapos++] = outpos.get();
            metadata[metapos++] = initvalue;
            if (c instanceof SkippableIntegerCODEC) {
                int size = blocksize > data.length - inpos.get() ? data.length
                        - inpos.get() : blocksize;
                initvalue = Delta.delta(data, inpos.get(), size, initvalue);


                ((SkippableIntegerCODEC) c).headlessCompress(data, inpos,
                        blocksize, output, outpos);
            } else if (c instanceof SkippableIntegratedIntegerCODEC) {
                ival.set(initvalue);
                ((SkippableIntegratedIntegerCODEC) c).headlessCompress(data,
                        inpos, blocksize, output, outpos, ival);
                initvalue = ival.get();
            } else {
                throw new RuntimeException("Unrecognized codec " + c);
            }
        }
        return metapos;

View Full Code Here


    private static int decompressFromSkipTable(Object c, int[] compressed,
            IntWrapper compressedpos, int[] metadata, int blocksize, int[] data) {
        int metapos = 0;
        int length = metadata[metapos++];
        IntWrapper uncomppos = new IntWrapper();
        IntWrapper ival = new IntWrapper();
        while (uncomppos.get() < length) {
            int num = blocksize;
            if (num > length - uncomppos.get())
                num = length - uncomppos.get();
            int location = metadata[metapos++];
            // System.out.println("location = "+location);
            int initvalue = metadata[metapos++];
            int outputlocation = uncomppos.get();
            if (location != compressedpos.get())
                throw new RuntimeException("Bug " + location + " "
                        + compressedpos.get() + " codec " + c);
            if (c instanceof SkippableIntegerCODEC) {
                ((SkippableIntegerCODEC) c).headlessUncompress(compressed,
                        compressedpos, compressed.length - uncomppos.get(),
                        data, uncomppos, num);
                initvalue = Delta.fastinverseDelta(data, outputlocation, num,
                        initvalue);
            } else if (c instanceof SkippableIntegratedIntegerCODEC) {
                ival.set(initvalue);
                ((SkippableIntegratedIntegerCODEC) c).headlessUncompress(
                        compressed, compressedpos, compressed.length
                                - uncomppos.get(), data, uncomppos, num, ival);
            } else {
                throw new RuntimeException("Unrecognized codec " + c);

View Full Code Here

            for (int k = 0; k < N; ++k) {
                int[] backupdata = Arrays.copyOf(data[k], data[k].length);


                // compress data.
                long beforeCompress = System.nanoTime() / 1000;
                IntWrapper outpos = new IntWrapper();
                compressWithSkipTable(c, backupdata, compressBuffer, outpos,
                        metadataBuffer, blocksize);
                long afterCompress = System.nanoTime() / 1000;


                // measure time of compression.
                compressTime += afterCompress - beforeCompress;
                final int thiscompsize = outpos.get();
                size += thiscompsize;
                // dry run
                int volume = 0;
                {
                    IntWrapper compressedpos = new IntWrapper(0);
                    volume = decompressFromSkipTable(c, compressBuffer,
                            compressedpos, metadataBuffer, blocksize,
                            decompressBuffer);


                    // let us check the answer
                    if (volume != backupdata.length)
                        throw new RuntimeException(
                                "Bad output size with codec " + c);
                    for (int j = 0; j < volume; ++j) {
                        if (data[k][j] != decompressBuffer[j])
                            throw new RuntimeException("bug in codec " + c);
                    }
                }
                // extract (uncompress) data
                long beforeDecompress = System.nanoTime() / 1000;
                for (int t = 0; t < times; ++t) {
                    IntWrapper compressedpos = new IntWrapper(0);
                    volume = decompressFromSkipTable(c, compressBuffer,
                            compressedpos, metadataBuffer, blocksize,
                            decompressBuffer);
                }
                long afterDecompress = System.nanoTime() / 1000;

View Full Code Here

TOP

Related Classes of me.lemire.integercompression.IntWrapper

me.lemire.integercompression.benchmarktools.Benchmark

me.lemire.integercompression.benchmarktools.BenchmarkOffsettedSeries

me.lemire.integercompression.benchmarktools.BenchmarkSkippable

me.lemire.integercompression.differential.IntegratedBinaryPacking

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.