Comprima documentos de qualquer tamanho aplicando paralelismo

Arquivo paralelo: liberando o poder do processamento multinúcleo

Visão geral

A maioria dos algoritmos de compressão foram projetados para processadores de núcleo único. No entanto, na era das CPUs multi-core, é benéfico utilizar todos os núcleos da CPU para acelerar a criação de arquivos. Aspose.ZIP fornece esse recurso para alguns formatos de arquivo.

Métodos paralelos em arquivos BZIP2, LZIP e XZ

A paralelização é possível devido à natureza de bloco desses algoritmos. No nível do programa, esses arquivos usam uma abordagem comum de compactação multinúcleo. O usuário pode definir o número de threads por meio da propriedade CompressionThreads . Portanto, se esta propriedade for mais de uma, vários núcleos de CPU serão usados.

Sample 1 – Parallel compression to BZIP2    using (Bzip2Archive archive = new Bzip2Archive())
    {
        archive.SetSource("data.bin");
        archive.Save("archive.bz2", new Bzip2SaveOptions() { CompressionThreads = 4 });
    }

Sample 2 - Parallel compression to LZIP    var settings = new LzipArchiveSettings(16777216) { CompressionThreads = 4 }
    using (LzipArchive archive = new LzipArchive(settings))
    {
        archive.SetSource("data.bin");
        archive.Save("archive.lz");
    }

Sample 3 - Parallel compression to XZ    using (Bzip2Archive archive = new Bzip2Archive())
    {
        archive.SetSource("data.bin");
        archive.Save("archive.bz2", new Bzip2SaveOptions() { CompressionThreads = 4 });
    }

Como compactar uma pasta com .NET

Os arquivos ZIP servem para compactar e consolidar um ou vários arquivos ou pastas em um contêiner unificado. Em .NET , você pode usar a classe ZipFile para trabalhar com arquivos ZIP e compactação. O objetivo principal do arquivamento é normalmente diminuir o tamanho do arquivo para armazenamento ou transmissão, ao mesmo tempo que incorpora medidas de criptografia para maior segurança. Além das ferramentas tradicionais de compactação de arquivos, os recursos automatizados de compactação/extração são aplicados em diversos aplicativos de desktop e web, facilitando tarefas como upload, download, compartilhamento ou criptografia de arquivos.

Arquivos 7Z LZMA2

Um dos métodos de compactação do formato 7Z é o LZMA2 , que pode ser compactado em vários threads. Da mesma forma que nos tipos de arquivos anteriores, você pode definir o número de threads por meio da propriedade CompressionThreads.

Sample 1 – Parallel compression to 7Z LZMA2    var settings = new SevenZipEntrySettings(new SevenZipLZMA2CompressionSettings(){ CompressionThreads = 4 });
    using (SevenZipArchive archive = new SevenZipArchive(settings))
    {
        archive.CreateEntry("first.bin", "data.bin");
        archive.Save("result.7z");
    }

Método paralelo em arquivos ZIP

Para classes de arquivo anteriores, a paralelização foi aplicada em nível de bloco ou algoritmo. Para o arquivo ZIP é possível no nível de entrada. Para fazer isso, instancie ParallelOptions ao salvar o arquivo.

Sample 1 – Parallel compression to zip    using (Archive archive = new Archive())
    {
        archive.CreateEntries(@"C:\Data");
        archive.Save(zipFile, new ArchiveSaveOptions()
        {
            ParallelOptions = new ParallelOptions() 
            { ParallelCompressInMemory = ParallelCompressionMode.Auto }
        });
    }

A estratégia de configuração Parallel-Compress-In-Memory é usada para realizar multitarefas

A configuração ParallelCompressInMemory indica a estratégia que escolhemos para multitarefa. Aqui estão três opções :
ParallelCompressionMode.Never: compactação de todas as entradas é sequencial. Apenas um núcleo da CPU funciona na compactação e libera os dados compactados conforme eles chegam.
ParallelCompressionMode.Always: Ele força a compactação de entradas em threads diferentes, independentemente do tamanho da entrada, da memória disponível e de outros fatores. Cada núcleo da CPU compacta simultaneamente um arquivo mantendo seus dados compactados na RAM. Após a entrada ser compactada, ela é liberada para o fluxo de resultados. Se a quantidade de RAM for pequena e o tamanho total de algumas N entradas (onde N é o número de núcleos da CPU) for enorme, pode acontecer que toda a RAM disponível para CLR se esgote e surja OutOfMemoryExcepton.
ParallelCompressionMode.Auto: Estima núcleos de CPU, tamanhos de entradas, memória disponível e escolhe se deseja compactar entradas em paralelo ou sequencialmente. Neste modo, algumas entradas menores são compactadas em paralelo, enquanto outras são compactadas sequencialmente. As entradas LZMA e PPMd não são compactadas em paralelo devido ao alto consumo de memória. Geralmente, é seguro escolher esta opção; Aspose.ZIP é cauteloso com estimativas e muda para compactação sequencial como alternativa. Há mais uma propriedade de ParallelOptions para este modo - AvailableMemorySize. É inútil para qualquer outro modo. Grosso modo, é o limite máximo de memória alocada ao compactar entradas com todos os núcleos da CPU, em megabytes. Aspose.ZIP usa esse número para estimar o maior tamanho de entrada que é seguro para ser compactado em paralelo. Entradas acima do limite serão compactadas sequencialmente. AvailableMemorySize é uma faca de dois gumes: sendo definido muito alto com entradas enormes, pode produzir esgotamento de RAM, troca intensa e até mesmo pode haver exceção de falta de memória. Sendo definido muito baixo, a maioria das entradas será compactada de forma sequencial, sem muita aceleração. Portanto, usuários sofisticados podem atribuí-lo considerando a compensação.
Encorajamos você a experimentar diferentes modos de compactação paralela em seus dados típicos para determinar quais são as melhores configurações para o seu caso.