Comprima documentos de cualquier tamaño aplicando paralelismo

Archivo paralelo: Liberando el poder del procesamiento multinúcleo

Descripción general

La mayoría de los algoritmos de compresión fueron diseñados para procesadores de un solo núcleo. Sin embargo, en la era de las CPU de múltiples núcleos, es beneficioso utilizar todos los núcleos de la CPU para acelerar la creación de archivos. Aspose.ZIP proporciona esta capacidad para algunos formatos de archivo.

Métodos paralelos en archivos BZIP2, LZIP y XZ

La paralelización es posible debido a la naturaleza de bloque de estos algoritmos. A nivel de programa, estos archivos utilizan un enfoque común de compresión multinúcleo. El usuario puede establecer el número de subprocesos a través de la propiedad CompressionThreads . Entonces, si esta propiedad es más de una, se usarían varios núcleos de CPU.

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 });
    }

Cómo comprimir una carpeta con .NET

Los archivos ZIP sirven para comprimir y consolidar uno o varios archivos o carpetas en un contenedor unificado. En .NET , puede utilizar la clase ZipFile para trabajar con archivos ZIP y compresión. El objetivo principal del archivado suele ser reducir el tamaño del archivo para su almacenamiento o transmisión, incorporando al mismo tiempo medidas de cifrado para mejorar la seguridad. Más allá de las herramientas tradicionales de compresión de archivos, las funciones de compresión/extracción automatizadas encuentran aplicación en diversas aplicaciones web y de escritorio, facilitando tareas como cargar, descargar, compartir o cifrar archivos.

Archivos del 7Z LZMA2

Uno de los métodos de compresión del formato 7Z es LZMA2 , que se puede comprimir en varios subprocesos. De manera similar al tipo de archivos anterior, puede establecer la cantidad de subprocesos a través de la propiedad 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 en archivos ZIP

Para las clases de archivo anteriores, la paralelización se aplicó a nivel de bloque o de algoritmo. Para el archivo ZIP es posible en el nivel básico. Para hacerlo, cree una instancia de ParallelOptions al guardar el archivo.

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 }
        });
    }

La estrategia de configuración Parallel-Compress-In-Memory se utiliza para realizar múltiples tareas

La configuración de ParallelCompressInMemory indica la estrategia que elegimos para realizar múltiples tareas. Aquí hay tres opciones :
ParallelCompressionMode.Never: compresión de todas las entradas es secuencial. Sólo un núcleo de CPU funciona con compresión y vacía los datos comprimidos a medida que llegan.
ParallelCompressionMode.Always: Fuerza la compresión de entradas en diferentes subprocesos independientemente del tamaño de la entrada, la memoria disponible y otros factores. Cada núcleo de la CPU comprime simultáneamente un archivo manteniendo sus datos comprimidos en la RAM. Una vez que se comprime la entrada, se descarga en el flujo de resultados. Si su cantidad de RAM es pequeña y el tamaño total de algunas N entradas (donde N es el número de núcleos de CPU) es enorme, puede suceder que toda la RAM disponible para CLR se agote y surja OutOfMemoryExcepton.
ParallelCompressionMode.Auto: Estima los núcleos de CPU, los tamaños de las entradas, la memoria disponible y elige si comprimir las entradas en paralelo o secuencialmente. En este modo, algunas entradas más pequeñas se comprimen en paralelo y otras de forma secuencial. Las entradas LZMA y PPMd no se comprimen en paralelo debido al alto consumo de memoria. Generalmente, es seguro optar por esta opción; Aspose.ZIP desconfía de las estimaciones y cambia a la compresión secuencial como alternativa. Hay una propiedad más de ParallelOptions para este modo: DisponibleMemorySize. No tiene sentido para ningún otro modo. En términos generales, es el límite superior de memoria asignada al comprimir entradas con todos los núcleos de CPU, en megabytes. Aspose.ZIP usa ese número para estimar el tamaño más grande de entrada que es seguro comprimir en paralelo. Las entradas por encima del umbral se comprimirán secuencialmente. AvailableMemorySize es un arma de doble filo: si se establece demasiado alto con entradas grandes, puede producir agotamiento de la RAM, intercambio intenso, e incluso podría ser una excepción de falta de memoria. Si se establece demasiado bajo, la mayoría de las entradas se comprimirán de forma secuencial sin mucha aceleración. Por lo tanto, los usuarios sofisticados pueden asignarlo teniendo en cuenta las compensaciones.
Le recomendamos que juegue con diferentes modos de compresión paralela en sus datos típicos para determinar cuáles son las mejores configuraciones en su caso.