Optimize PagesSerde

Refactor PagesSerde to avoid:

- Unnecessary memory copy
- Unnecessary Cipher initialization
- Unnecessary allocations when jumbo pages (>4MB) are serialized

This is done by implementing block based encryption in compression.
Instead of trying to encrypt/compress an entire page a page in
serialized form is split into multiple fixed size blocks (64kb by
default)

Benchmark results

Before:

```
Benchmark                        (compressed)  (encrypted)  (randomSeed)   Mode  Cnt     Score    Error  Units
BenchmarkPagesSerde.deserialize          true         true          1000  thrpt   10  1194.138 ±  7.442  ops/s
BenchmarkPagesSerde.deserialize          true        false          1000  thrpt   10  2281.985 ±  8.634  ops/s
BenchmarkPagesSerde.deserialize         false         true          1000  thrpt   10  1416.509 ±  2.928  ops/s
BenchmarkPagesSerde.deserialize         false        false          1000  thrpt   10  5891.232 ± 14.932  ops/s
BenchmarkPagesSerde.serialize            true         true          1000  thrpt   10   312.647 ±  0.800  ops/s
BenchmarkPagesSerde.serialize            true        false          1000  thrpt   10   601.053 ±  1.522  ops/s
BenchmarkPagesSerde.serialize           false         true          1000  thrpt   10   451.260 ±  0.996  ops/s
BenchmarkPagesSerde.serialize           false        false          1000  thrpt   10  3446.756 ±  6.949  ops/s
```

After:

```
Benchmark                        (compressed)  (encrypted)  (randomSeed)   Mode  Cnt     Score    Error  Units
BenchmarkPagesSerde.deserialize          true         true          1000  thrpt   10  1732.440 ±  4.044  ops/s
BenchmarkPagesSerde.deserialize          true        false          1000  thrpt   10  3059.334 ±  5.412  ops/s
BenchmarkPagesSerde.deserialize         false         true          1000  thrpt   10  2093.146 ±  3.505  ops/s
BenchmarkPagesSerde.deserialize         false        false          1000  thrpt   10  5906.148 ± 13.923  ops/s
BenchmarkPagesSerde.serialize            true         true          1000  thrpt   10   329.150 ±  1.269  ops/s
BenchmarkPagesSerde.serialize            true        false          1000  thrpt   10   617.507 ±  1.808  ops/s
BenchmarkPagesSerde.serialize           false         true          1000  thrpt   10   493.182 ±  0.687  ops/s
BenchmarkPagesSerde.serialize           false        false          1000  thrpt   10  3816.939 ±  7.984  ops/s
```

Author: arhimondr

core/trino-main/src/main/java/io/trino/execution/QueryStateMachine.java

@@ -23,7 +23,6 @@
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import io.airlift.log.Logger;
-import io.airlift.slice.Slices;
 import io.airlift.units.Duration;
 import io.trino.Session;
 import io.trino.exchange.ExchangeInput;
@@ -57,10 +56,8 @@
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.GuardedBy;
 import javax.annotation.concurrent.ThreadSafe;
-import javax.crypto.KeyGenerator;
 
 import java.net.URI;
-import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -97,9 +94,10 @@
 import static io.trino.execution.StageInfo.getAllStages;
 import static io.trino.operator.RetryPolicy.TASK;
 import static io.trino.server.DynamicFilterService.DynamicFiltersStats;
-import static io.trino.spi.StandardErrorCode.GENERIC_INTERNAL_ERROR;
 import static io.trino.spi.StandardErrorCode.NOT_FOUND;
 import static io.trino.spi.StandardErrorCode.USER_CANCELED;
+import static io.trino.util.Ciphers.createRandomAesEncryptionKey;
+import static io.trino.util.Ciphers.serializeAesEncryptionKey;
 import static io.trino.util.Failures.toFailure;
 import static java.util.Objects.requireNonNull;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
@@ -280,14 +278,7 @@ static QueryStateMachine beginWithTicker(
 
         if (getRetryPolicy(session) == TASK && faultTolerantExecutionExchangeEncryptionEnabled) {
             // encryption is mandatory for fault tolerant execution as it relies on an external storage to store intermediate data generated during an exchange
-            try {
-                KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
-                keyGenerator.init(256);
-                session = session.withExchangeEncryption(Slices.wrappedBuffer(keyGenerator.generateKey().getEncoded()));
-            }
-            catch (NoSuchAlgorithmException e) {
-                throw new TrinoException(GENERIC_INTERNAL_ERROR, "Failed to generate new secret key: " + e.getMessage(), e);
-            }
+            session = session.withExchangeEncryption(serializeAesEncryptionKey(createRandomAesEncryptionKey()));
         }
 
         QueryStateMachine queryStateMachine = new QueryStateMachine(