Reduce memory usage of QuicheQuicChannel (#653)

Motivation:

We might have a lot of QuicheQuicChannel in memory so we should try to
keep the memory usage as low as possible.

Modifications:

Grow long[] for readable streams and writable streams dynamically

Result:

Less memory usage when not a lot of streams are active

codec-classes-quic/src/main/java/io/netty/incubator/codec/quic/QuicheQuicChannel.java

@@ -118,8 +118,8 @@ public void operationComplete(ChannelFuture channelFuture) {
     };
 
     private static final ChannelMetadata METADATA = new ChannelMetadata(false, 16);
-    private final long[] readableStreams = new long[128];
-    private final long[] writableStreams = new long[128];
+    private long[] readableStreams = new long[4];
+    private long[] writableStreams = new long[4];
 
     private final LongObjectMap<QuicheQuicStreamChannel> streams = new LongObjectHashMap<>();
     private final QuicheQuicChannelConfig config;
@@ -220,6 +220,19 @@ static QuicheQuicChannel forServer(Channel parent, ByteBuffer key, InetSocketAdd
                 sslTaskExecutor);
     }
 
+    private static final int MAX_ARRAY_LEN = 128;
+
+    private static long[] growIfNeeded(long[] array, int maxLength) {
+        if (maxLength > array.length) {
+            if (array.length == MAX_ARRAY_LEN) {
+                return array;
+            }
+            // Increase by 4 until we reach MAX_ARRAY_LEN
+            return new long[Math.min(MAX_ARRAY_LEN, array.length + 4)];
+        }
+        return array;
+    }
+
     @Override
     public boolean isTimedOut() {
         return timedOut;
@@ -979,6 +992,7 @@ private boolean handleWritableStreams() {
                     Quiche.quiche_conn_is_in_early_data(connAddr)) {
                 long writableIterator = Quiche.quiche_conn_writable(connAddr);
 
+                int totalWritable = 0;
                 try {
                     // For streams we always process all streams when at least on read was requested.
                     for (;;) {
@@ -997,6 +1011,9 @@ private boolean handleWritableStreams() {
                                 }
                             }
                         }
+                        if (writable > 0) {
+                            totalWritable += writable;
+                        }
                         if (writable < writableStreams.length) {
                             // We did handle all writable streams.
                             break;
@@ -1005,6 +1022,7 @@ private boolean handleWritableStreams() {
                 } finally {
                     Quiche.quiche_stream_iter_free(writableIterator);
                 }
+                writableStreams = growIfNeeded(writableStreams, totalWritable);
             }
             return mayNeedWrite;
         } finally {
@@ -1674,6 +1692,7 @@ void recv() {
         private void recvStream() {
             long connAddr = connection.address();
             long readableIterator = Quiche.quiche_conn_readable(connAddr);
+            int totalReadable = 0;
             if (readableIterator != -1) {
                 try {
                     // For streams we always process all streams when at least on read was requested.
@@ -1699,11 +1718,15 @@ private void recvStream() {
                                 streamReadable = false;
                                 break;
                             }
+                            if (readable > 0) {
+                                totalReadable += readable;
+                            }
                         }
                     }
                 } finally {
                     Quiche.quiche_stream_iter_free(readableIterator);
                 }
+                readableStreams = growIfNeeded(readableStreams, totalReadable);
             }
         }