Benchmark: zlip.js( imaya) decomrpess option Raw Deflate Test

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/zlibjs@0.3.1/bin/rawdeflate.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/zlibjs@0.3.1/bin/rawinflate.min.js"></script>

AخA
 
<script src="https://cdn.jsdelivr.net/npm/zlibjs@0.3.1/bin/rawdeflate.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/zlibjs@0.3.1/bin/rawinflate.min.js"></script>

Script Preparation code:

var enc = new TextEncoder();
var a = new Uint8Array([100 * 1024]);
for (var i; i < 100 * 1024; i++)
    a[i] = Math.floor(Math.random() * 256)

var deflate = new Zlib.RawDeflate(a);
var ca = deflate.compress();

​x
 
var enc = new TextEncoder();var a = new Uint8Array([100 * 1024]);for (var i; i < 100 * 1024; i++)    a[i] = Math.floor(Math.random() * 256)​var deflate = new Zlib.RawDeflate(a);var ca = deflate.compress();

Tests:

Default
var inflate = new Zlib.RawInflate(ca); var plain = inflate.decompress();
var inflate = new Zlib.RawInflate(ca);
var plain = inflate.decompress();

Block Size 32

var inflate = new Zlib.RawInflate(ca,{
  bufferType : Zlib.RawInflate.BufferType.BLOCK,
  bufferSize : 32                                  
});
var plain = inflate.decompress();

 
var inflate = new Zlib.RawInflate(ca,{  bufferType : Zlib.RawInflate.BufferType.BLOCK,  bufferSize : 32                                  });var plain = inflate.decompress();

Block Size 64

var inflate = new Zlib.RawInflate(ca,{
  bufferType : Zlib.RawInflate.BufferType.BLOCK,
  bufferSize : 64                                  
});
var plain = inflate.decompress();

 
var inflate = new Zlib.RawInflate(ca,{  bufferType : Zlib.RawInflate.BufferType.BLOCK,  bufferSize : 64                                  });var plain = inflate.decompress();

Block Size 128

var inflate = new Zlib.RawInflate(ca,{
  bufferType : Zlib.RawInflate.BufferType.BLOCK,
  bufferSize : 128                                  
});
var plain = inflate.decompress();

 
var inflate = new Zlib.RawInflate(ca,{  bufferType : Zlib.RawInflate.BufferType.BLOCK,  bufferSize : 128                                  });var plain = inflate.decompress();

Block Size 256

var inflate = new Zlib.RawInflate(ca,{
  bufferType : Zlib.RawInflate.BufferType.BLOCK,
  bufferSize : 256                                 
});
var plain = inflate.decompress();

 
var inflate = new Zlib.RawInflate(ca,{  bufferType : Zlib.RawInflate.BufferType.BLOCK,  bufferSize : 256                                 });var plain = inflate.decompress();

Block Size 512

var inflate = new Zlib.RawInflate(ca,{
  bufferType : Zlib.RawInflate.BufferType.BLOCK,
  bufferSize : 512                                  
});
var plain = inflate.decompress();

 
var inflate = new Zlib.RawInflate(ca,{  bufferType : Zlib.RawInflate.BufferType.BLOCK,  bufferSize : 512                                  });var plain = inflate.decompress();

Block Size 1024

var inflate = new Zlib.RawInflate(ca,{
  bufferType : Zlib.RawInflate.BufferType.BLOCK,
  bufferSize : 1024                                  
});
var plain = inflate.decompress();

 
var inflate = new Zlib.RawInflate(ca,{  bufferType : Zlib.RawInflate.BufferType.BLOCK,  bufferSize : 1024                                  });var plain = inflate.decompress();

Block Size 2048

var inflate = new Zlib.RawInflate(ca,{
  bufferType : Zlib.RawInflate.BufferType.BLOCK,
  bufferSize : 2048                                  
});
var plain = inflate.decompress();

 
var inflate = new Zlib.RawInflate(ca,{  bufferType : Zlib.RawInflate.BufferType.BLOCK,  bufferSize : 2048                                  });var plain = inflate.decompress();

Block Size 4096

var inflate = new Zlib.RawInflate(ca,{
  bufferType : Zlib.RawInflate.BufferType.BLOCK,
  bufferSize : 4096                                  
});
var plain = inflate.decompress();

 
var inflate = new Zlib.RawInflate(ca,{  bufferType : Zlib.RawInflate.BufferType.BLOCK,  bufferSize : 4096                                  });var plain = inflate.decompress();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Default
Block Size 32
Block Size 64
Block Size 128
Block Size 256
Block Size 512
Block Size 1024
Block Size 2048
Block Size 4096

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 114 on Android

View result in a separate tab

Test name	Executions per second
Default	14971.2 Ops/sec
Block Size 32	71714.7 Ops/sec
Block Size 64	72885.3 Ops/sec
Block Size 128	71152.6 Ops/sec
Block Size 256	70534.2 Ops/sec
Block Size 512	67839.0 Ops/sec
Block Size 1024	56247.5 Ops/sec
Block Size 2048	54034.4 Ops/sec
Block Size 4096	43645.1 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

Let's break down the test cases and options being compared.

What is being tested?

The test case measures the performance of different block sizes in decompressing a ZIP file using the Zlib.RawInflate library. The test creates a compressed ZIP file (ca) by compressing an array of random data with Zlib.RawDeflate. Then, it tests decompression at various block sizes (32, 64, 128, 256, 512, 1024, 2048, and 4096) using the Zlib RAW protocol.

Options being compared

The test compares the performance of each block size in decompressing the ZIP file. The options are:

Default: Using the default block size (not specified).
Block Size 32: Compressing and decompressing with a block size of 32 bytes.
Block Size 64: Compressing and decompressing with a block size of 64 bytes.
Block Size 128: Compressing and decompressing with a block size of 128 bytes.
Block Size 256: Compressing and decompressing with a block size of 256 bytes.
Block Size 512: Compressing and decompressing with a block size of 512 bytes.
Block Size 1024: Compressing and decompressing with a block size of 1024 bytes.
Block Size 2048: Compressing and decompressing with a block size of 2048 bytes.
Block Size 4096: Compressing and decompressing with a block size of 4096 bytes.

Browser performance

The test measures the performance of each block size in different browsers on Android devices:

Chrome Mobile 114: Executions per second for each block size.
Other browsers: Not shown, but presumably measured using a similar approach.

What does it mean?

The results indicate that smaller block sizes (32, 64, and 128) are faster than larger block sizes (256, 512, 1024, and 2048). The default block size is the slowest. The performance difference between different block sizes suggests that Zlib RAW optimization for varying block sizes can have a significant impact on decompression speed.

Keep in mind that this test is just one aspect of measuring Zlib performance, and there may be other factors affecting overall compression/decompression efficiency.

LLMs can make mistakes. Check important info.

Let's break down the test cases and options being compared.

**What is being tested?**

The test case measures the performance of different block sizes in decompressing a ZIP file using the `Zlib.RawInflate` library. The test creates a compressed ZIP file (`ca`) by compressing an array of random data with `Zlib.RawDeflate`. Then, it tests decompression at various block sizes (32, 64, 128, 256, 512, 1024, 2048, and 4096) using the `Zlib RAW` protocol.

**Options being compared**

The test compares the performance of each block size in decompressing the ZIP file. The options are:

1. **Default**: Using the default block size (not specified).
2. **Block Size 32**: Compressing and decompressing with a block size of 32 bytes.
3. **Block Size 64**: Compressing and decompressing with a block size of 64 bytes.
4. **Block Size 128**: Compressing and decompressing with a block size of 128 bytes.
5. **Block Size 256**: Compressing and decompressing with a block size of 256 bytes.
6. **Block Size 512**: Compressing and decompressing with a block size of 512 bytes.
7. **Block Size 1024**: Compressing and decompressing with a block size of 1024 bytes.
8. **Block Size 2048**: Compressing and decompressing with a block size of 2048 bytes.
9. **Block Size 4096**: Compressing and decompressing with a block size of 4096 bytes.

**Browser performance**

The test measures the performance of each block size in different browsers on Android devices:

1. **Chrome Mobile 114**: Executions per second for each block size.
2. **Other browsers**: Not shown, but presumably measured using a similar approach.

**What does it mean?**

The results indicate that smaller block sizes (32, 64, and 128) are faster than larger block sizes (256, 512, 1024, and 2048). The default block size is the slowest. The performance difference between different block sizes suggests that `Zlib RAW` optimization for varying block sizes can have a significant impact on decompression speed.

Keep in mind that this test is just one aspect of measuring `Zlib` performance, and there may be other factors affecting overall compression/decompression efficiency.

Related benchmarks:

zlip.js( imaya) decomrpess option Raw Deflate Test (version: 0)

zlip.js(imaya) decompress option Test

Comparing performance of: Default vs Block Size 32 vs Block Size 64 vs Block Size 128 vs Block Size 256 vs Block Size 512 vs Block Size 1024 vs Block Size 2048 vs Block Size 4096

Created: one year ago by: Guest

Jump to the latest result

Default