% divANS 模块

概述

divANS 库旨在用于通用数据压缩。该算法经过调整，在压缩比和性能之间取得了显著的平衡，在 150 Mbit/s 的行速度下运行。

该名称来源于 "divided-ANS"，因为中间表示形式是从 ANS 编码器中分离出来的

更多信息请参阅 https://blogs.dropbox.com/tech/2018/06/building-better-compression-together-with-divans/

Divans 应主要考虑用于冷存储和压缩研究。该压缩算法高度模块化，新的算法只需编写一次，因为通用的特化结构在编译时为压缩和解压缩优化了编解码器。

Rust 使用

解压缩

extern crate divans;
fn main() {
    use std::io;
    let stdin = &mut io::stdin();
    {
        use std::io::{Read, Write};
        let mut reader = divans::DivansDecompressorReader::new(
            stdin,
            4096, // buffer size
        );
        let mut buf = [0u8; 4096];
        loop {
            match reader.read(&mut buf[..]) {
                Err(e) => {
                    if let io::ErrorKind::Interrupted = e.kind() {
                        continue;
                    }
                    panic!(e);
                }
                Ok(size) => {
                    if size == 0 {
                        break;
                    }
                    match io::stdout().write_all(&buf[..size]) {
                        Err(e) => panic!(e),
                        Ok(_) => {},
                    }
                }
            }
        }
    }   
}

压缩

extern crate divans;
fn main() {
    use std::io;
    let stdout = &mut io::stdout();
    {
        use std::io::{Read, Write};
        let mut writer = divans::DivansBrotliHybridCompressorWriter::new(
            stdout,
            divans::DivansCompressorOptions{
                literal_adaptation:None, // should we override how fast the cdfs converge for literals?
                window_size:Some(22), // log 2 of the window size
                lgblock:None, // should we override how often metablocks are created in brotli
                quality:Some(11), // the quality of brotli commands
                dynamic_context_mixing:Some(2), // if we want to mix together the stride prediction and the context map
                use_brotli:divans::BrotliCompressionSetting::default(), // ignored
                use_context_map:true, // whether we should use the brotli context map in addition to the last 8 bits of each byte as a prior
                force_stride_value: divans::StrideSelection::UseBrotliRec, // if we should use brotli to decide on the stride
            },
            4096, // internal buffer size
        );
        let mut buf = [0u8; 4096];
        loop {
            match io::stdin().read(&mut buf[..]) {
                Err(e) => {
                    if let io::ErrorKind::Interrupted = e.kind() {
                        continue;
                    }
                    panic!(e);
                }
                Ok(size) => {
                    if size == 0 {
                        match writer.flush() {
                            Err(e) => {
                                if let io::ErrorKind::Interrupted = e.kind() {
                                    continue;
                                }
                                panic!(e)
                            }
                            Ok(_) => break,
                        }
                    }
                    match writer.write_all(&buf[..size]) {
                        Err(e) => panic!(e),
                        Ok(_) => {},
                    }
                }
            }
        }
    }
}

C 语言使用

C api 是一个标准的压缩 API，类似于 zlib 提供的 API。尽管是 Rust 代码，但除非传递了 CAllocator 结构并设置 custom_malloc 字段为 NULL，否则不会进行分配。这意味着任何 divans 库的使用者都可以提供自己的分配系统，所有分配都将通过该分配系统进行。custom_malloc 返回的指针必须是 32 字节对齐的。

压缩

#include "divans/ffi.h"
// compress to stdout
DivansResult compress(const unsigned char *data, size_t len) {
    unsigned char buf[4096];
    struct CAllocator alloc = {custom_malloc, custom_free, custom_alloc_opaque}; // set all 3 to NULL to use rust allocators
    struct DivansCompressorState *state = divans_new_compressor_with_custom_alloc(alloc);
    divans_set_option(state, DIVANS_OPTION_USE_CONTEXT_MAP, 1);
    divans_set_option(state, DIVANS_OPTION_DYNAMIC_CONTEXT_MIXING, 2);
    divans_set_option(state, DIVANS_OPTION_QUALITY, 11);
    while (len) {
        size_t read_offset = 0;
        size_t buf_offset = 0;
        DivansResult res = divans_encode(state,
                                         data, len, &read_offset,
                                         buf, sizeof(buf), &buf_offset);
        if (res == DIVANS_FAILURE) {
            divans_free_compressor(state);
            return res;
        }
        data += read_offset;
        len -= read_offset;
        fwrite(buf, buf_offset, 1, stdout);
    }
    DivansResult res;
    do {
        size_t buf_offset = 0;
        res = divans_encode_flush(state,
                                  buf, sizeof(buf), &buf_offset);
        if (res == DIVANS_FAILURE) {
            divans_free_compressor(state);
            return res;
        }
        fwrite(buf, buf_offset, 1, stdout);
    } while(res != DIVANS_SUCCESS);
    divans_free_compressor(state);
    return DIVANS_SUCCESS;
}

解压缩

#include "divans/ffi.h"
//decompress to stdout
DivansResult decompress(const unsigned char *data, size_t len) {
    unsigned char buf[4096];
    struct CAllocator alloc = {custom_malloc, custom_free, custom_alloc_opaque}; // set all 3 to NULL for using rust allocators
    struct DivansDecompressorState *state = divans_new_decompressor_with_custom_alloc(alloc);
    DivansResult res;
    do {
        size_t read_offset = 0;
        size_t buf_offset = 0;
        res = divans_decode(state,
                            data, len, &read_offset,
                            buf, sizeof(buf), &buf_offset);
        if (res == DIVANS_FAILURE || (res == DIVANS_NEEDS_MORE_INPUT && len == 0)) {
            divans_free_decompressor(state);
            return res;
        }
        data += read_offset;
        len -= read_offset;
        fwrite(buf, buf_offset, 1, stdout);
    } while (res != DIVANS_SUCCESS);
    divans_free_decompressor(state);
    return DIVANS_SUCCESS;
}

divANS 代码库结构

顶级模块

总体流程

要编码文件，

• 一个 writer::DivansBrotliHybridCompressorWriter 实例化一个 brotli_ir_gen::BrotliDivansHybridCompressor
• 该压缩器既有来自 brotli crate 的 brotli::BrotliEncoderStateStruct，也有一个 codec::DivansCodec<ANSEncoder, EncodeSpecialization>.
• 使用 brotli_ir_gen::BrotliDivansHybridCompressor::encode，压缩器通过调用 brotli::BrotliEncoderCompressStream 将输入数据馈入 brotli::BrotliEncoderStateStruct
  • 通过调用 brotli::BrotliEncoderCompressStream
• brotli::BrotliEncoderCompressStream 可以触发调用 brotli_ir_gen::BrotliDivansHybridCompressor::divans_encode_commands
  • 回调将包括一个 brotli::interface::Command 项的切片
  • 这些项被馈入 codec::DivansCodec<ANSEncoder, EncodeSpecialization>::encode_or_decode，将其编码为 divans 格式。
    • codec::DivansCodec<ANSEncoder, cmd_to_divans::EncoderSpecialization>::encode_or_decode通过使用EncoderSpecialization来拉取输入命令作为真实来源来完成这项任务。
    • 不幸的是，brotli可以将尽可能多的数据传递给调用者，最多可达16兆的最大元块大小。
      • 这意味着调用者必须在一个resizable_buffer::ResizableBuffer中缓冲这些数据。
• 当所有回调完成时，brotli_ir_gen::BrotliDivansHybridCompressor::encode_stream会尽可能地将原始缓冲区刷新。
• 最终，当用户调用brotli_ir_gen::BrotliDivansHybridCompressor::flush时，将遵循类似的程序，但设置了完成标志。

要解码一个文件，

• 实例化一个reader::DivansDecompressorReader来创建一个divans_decompressor::DivansDecompressor。
• 解压器是一个枚举，在解析完16字节的原始头部后，从HeaderParser模式切换到Decode模式。
• divans_decompressor::DivansDecompressor::Decode包含一个codec::DivansCodec<ANSDecoder, DecoderSpecialization>。
• 使用brotli_ir_gen::DivansDeompressor::decode，解压器将输入数据直接馈入codec::DivansCodec<ANSDecoder, DecoderSpecialization>。
  • 编解码器的encode_or_decode方法旨在在编码时接收命令作为输入，因此divans_to_raw::DecoderSpecialization简单地为每种类型的命令创建占位符命令，以便相同的代码路径可以编码和解码命令。
• 当达到最终状态时，写入校验和并返回成功。