From a21f9b6d8b9b027e64795dcdec40494bad76675e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20Anic=CC=81?= <igor.anic@gmail.com>
Date: Wed, 13 Mar 2024 18:22:08 +0100
Subject: [PATCH 1/3] compress.xz: remove copyForwards from tight loop

In the example from the issue #19052 to_read holds 213_315_584
uncompressed bytes. Calling read with small output results in many
shifts of that big buffer.
This removes need to shift to_read after each read.
---
 lib/std/compress/xz/block.zig | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/lib/std/compress/xz/block.zig b/lib/std/compress/xz/block.zig
index cd2c465dc5..6e0a09c8dd 100644
--- a/lib/std/compress/xz/block.zig
+++ b/lib/std/compress/xz/block.zig
@@ -34,6 +34,7 @@ pub fn Decoder(comptime ReaderType: type) type {
         check: xz.Check,
         err: ?Error,
         to_read: ArrayListUnmanaged(u8),
+        read_pos: usize,
         block_count: usize,
 
         fn init(allocator: Allocator, in_reader: ReaderType, check: xz.Check) !Self {
@@ -43,6 +44,7 @@ pub fn Decoder(comptime ReaderType: type) type {
                 .check = check,
                 .err = null,
                 .to_read = .{},
+                .read_pos = 0,
                 .block_count = 0,
             };
         }
@@ -57,13 +59,12 @@ pub fn Decoder(comptime ReaderType: type) type {
 
         pub fn read(self: *Self, output: []u8) Error!usize {
             while (true) {
-                if (self.to_read.items.len > 0) {
-                    const input = self.to_read.items;
+                const input = self.to_read.items[self.read_pos..];
+                if (input.len > 0) {
                     const n = @min(input.len, output.len);
                     @memcpy(output[0..n], input[0..n]);
-                    std.mem.copyForwards(u8, input, input[n..]);
-                    self.to_read.shrinkRetainingCapacity(input.len - n);
-                    if (self.to_read.items.len == 0 and self.err != null) {
+                    self.read_pos += n;
+                    if (self.read_pos == self.to_read.items.len and self.err != null) {
                         if (self.err.? == DecodeError.EndOfStreamWithNoError) {
                             return n;
                         }
@@ -77,6 +78,10 @@ pub fn Decoder(comptime ReaderType: type) type {
                     }
                     return self.err.?;
                 }
+                if (self.read_pos > 0) {
+                    self.to_read.shrinkRetainingCapacity(0);
+                    self.read_pos = 0;
+                }
                 self.readBlock() catch |e| {
                     self.err = e;
                 };

From 54f882c4aa49fd79c375374985cc01843d72124c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20Anic=CC=81?= <igor.anic@gmail.com>
Date: Wed, 13 Mar 2024 18:41:20 +0100
Subject: [PATCH 2/3] compress.xz: make reader loop little more readable

No need to do same error check on two places. First return all
uncompressed data then on last read check error.
---
 lib/std/compress/xz/block.zig | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/lib/std/compress/xz/block.zig b/lib/std/compress/xz/block.zig
index 6e0a09c8dd..50a562c9cc 100644
--- a/lib/std/compress/xz/block.zig
+++ b/lib/std/compress/xz/block.zig
@@ -59,24 +59,18 @@ pub fn Decoder(comptime ReaderType: type) type {
 
         pub fn read(self: *Self, output: []u8) Error!usize {
             while (true) {
-                const input = self.to_read.items[self.read_pos..];
-                if (input.len > 0) {
-                    const n = @min(input.len, output.len);
-                    @memcpy(output[0..n], input[0..n]);
+                const unread_len = self.to_read.items.len - self.read_pos;
+                if (unread_len > 0) {
+                    const n = @min(unread_len, output.len);
+                    @memcpy(output[0..n], self.to_read.items[self.read_pos..][0..n]);
                     self.read_pos += n;
-                    if (self.read_pos == self.to_read.items.len and self.err != null) {
-                        if (self.err.? == DecodeError.EndOfStreamWithNoError) {
-                            return n;
-                        }
-                        return self.err.?;
-                    }
                     return n;
                 }
-                if (self.err != null) {
-                    if (self.err.? == DecodeError.EndOfStreamWithNoError) {
+                if (self.err) |e| {
+                    if (e == DecodeError.EndOfStreamWithNoError) {
                         return 0;
                     }
-                    return self.err.?;
+                    return e;
                 }
                 if (self.read_pos > 0) {
                     self.to_read.shrinkRetainingCapacity(0);

From 791c4491a7677506ee7f028c0692065664d0b56c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20Anic=CC=81?= <igor.anic@gmail.com>
Date: Wed, 13 Mar 2024 18:43:36 +0100
Subject: [PATCH 3/3] compress.xz: remove unnecessary variable

`to_read.items.len is always zero when entering readBlock.
---
 lib/std/compress/xz/block.zig | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/lib/std/compress/xz/block.zig b/lib/std/compress/xz/block.zig
index 50a562c9cc..a2557fba7c 100644
--- a/lib/std/compress/xz/block.zig
+++ b/lib/std/compress/xz/block.zig
@@ -83,8 +83,6 @@ pub fn Decoder(comptime ReaderType: type) type {
         }
 
         fn readBlock(self: *Self) Error!void {
-            const unpacked_pos = self.to_read.items.len;
-
             var block_counter = std.io.countingReader(self.inner_reader);
             const block_reader = block_counter.reader();
 
@@ -165,7 +163,7 @@ pub fn Decoder(comptime ReaderType: type) type {
                     return error.CorruptInput;
             }
 
-            const unpacked_bytes = self.to_read.items[unpacked_pos..];
+            const unpacked_bytes = self.to_read.items;
             if (unpacked_size) |s| {
                 if (s != unpacked_bytes.len)
                     return error.CorruptInput;