You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pekko.apache.org by he...@apache.org on 2026/05/31 12:14:32 UTC

(pekko) branch perf-tls-jdk-heap-buffers created (now f3facb0199)

This is an automated email from the ASF dual-hosted git repository.

He-Pin pushed a change to branch perf-tls-jdk-heap-buffers
in repository https://gitbox.apache.org/repos/asf/pekko.git


      at f3facb0199 perf(stream): heap transport buffers for the TLS GraphStage

This branch includes the following new commits:

     new f3facb0199 perf(stream): heap transport buffers for the TLS GraphStage

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@pekko.apache.org
For additional commands, e-mail: commits-help@pekko.apache.org


(pekko) 01/01: perf(stream): heap transport buffers for the TLS GraphStage

Posted by he...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

He-Pin pushed a commit to branch perf-tls-jdk-heap-buffers
in repository https://gitbox.apache.org/repos/asf/pekko.git

commit f3facb01993bfc0135479bdfba0692f3ad800552
Author: He-Pin <he...@gmail.com>
AuthorDate: Sun May 31 20:13:25 2026 +0800

    perf(stream): heap transport buffers for the TLS GraphStage
    
    Motivation:
    The JDK SSLEngine works on byte[] internally and makes an extra
    direct<->heap copy on every wrap/unwrap when handed a direct buffer (see
    Netty's SslHandler, SslEngineType.JDK). TlsGraphStage took its three
    transport buffers from the TCP direct BufferPool, so every record paid
    that copy and each connection pinned ~384 KiB of direct memory for
    buffers that normally only hold a single ~16 KiB TLS record.
    
    Modification:
    Allocate the transport buffers on the heap and size them on demand like
    Netty: start at one packet and let growTransportOutBuffer enlarge the
    wrap buffer (capped at MaxApplicationRecordsPerEngineCall packets) only
    when a larger batch is actually produced. Remove the now-unused
    BufferPool/Tcp wiring and the pool-derived applicationBufferSize helper.
    
    Result:
    Per-record heap allocation drops ~5-8% for 4 KiB and 64 KiB payloads and
    stays flat for 256 B (on-demand sizing avoids a fixed-buffer penalty);
    direct memory per connection drops from ~384 KiB to zero. Behaviour is
    unchanged.
    
    Tests:
    - stream-tests/testOnly *TlsGraphStageIsolatedSpec *TlsGraphStageEdgeCasesSpec *TlsGraphStageSpec *TlsSpec *TlsEngineSelectionSpec -> 246 succeeded, 0 failed
    - bench-jmh TlsBenchmark.warmRoundTrip -prof gc (graphstage), gc.alloc.rate.norm: 256B 1657->1672 B/op, 4096B 20559->18980 B/op, 65536B 301864->286199 B/op
    
    References:
    Refs #2878
---
 .../stream/io/TlsGraphStageIsolatedSpec.scala      | 11 ++++
 .../pekko/stream/impl/io/TlsGraphStage.scala       | 63 +++++++---------------
 2 files changed, 30 insertions(+), 44 deletions(-)

diff --git a/stream-tests/src/test/scala/org/apache/pekko/stream/io/TlsGraphStageIsolatedSpec.scala b/stream-tests/src/test/scala/org/apache/pekko/stream/io/TlsGraphStageIsolatedSpec.scala
index 53390bef9f..72fc09311b 100644
--- a/stream-tests/src/test/scala/org/apache/pekko/stream/io/TlsGraphStageIsolatedSpec.scala
+++ b/stream-tests/src/test/scala/org/apache/pekko/stream/io/TlsGraphStageIsolatedSpec.scala
@@ -234,5 +234,16 @@ class TlsGraphStageIsolatedSpec extends StreamSpec(TlsSpec.configOverrides) with
 
       outputs.foldLeft(ByteString.empty)(_ ++ _) shouldEqual expected
     }
+
+    "grow the on-demand transport buffers for multi-record payloads without losing bytes" in {
+      // Transport buffers start at a single packet and grow on demand (heap, to avoid the JDK
+      // SSLEngine's direct<->heap copy). A payload spanning many records forces transportOut to grow
+      // past its initial size and then be reused across records; the round trip must still deliver
+      // every byte in order.
+      val payloadSize = 200 * 1024
+      val payload = ByteString(Array.tabulate[Byte](payloadSize)(i => (i % 251).toByte))
+
+      roundTrip(initSslContext("TLSv1.2"), List(payload), timeout = 30.seconds) shouldEqual payload
+    }
   }
 }
diff --git a/stream/src/main/scala/org/apache/pekko/stream/impl/io/TlsGraphStage.scala b/stream/src/main/scala/org/apache/pekko/stream/impl/io/TlsGraphStage.scala
index f700db110b..40e1e0c701 100644
--- a/stream/src/main/scala/org/apache/pekko/stream/impl/io/TlsGraphStage.scala
+++ b/stream/src/main/scala/org/apache/pekko/stream/impl/io/TlsGraphStage.scala
@@ -30,7 +30,6 @@ import scala.util.control.NonFatal
 
 import org.apache.pekko
 import pekko.annotation.InternalApi
-import pekko.io.{ BufferPool, Tcp }
 import pekko.stream._
 import pekko.stream.TLSProtocol._
 import pekko.stream.impl.Stages.DefaultAttributes
@@ -78,12 +77,11 @@ import pekko.util.ByteString
       private var transportInBuffer: ByteBuffer = _
       private var transportUnreadBuffer: ByteBuffer = _
       private var userInBuffer: ByteBuffer = _
-      private var bufferPool: BufferPool = _
-      private var pooledBufferSize = 0
       private var transportPacketSize = 0
       private var applicationRecordSize = 0
       private var maxUserInBufferSize = 0
       private var maxUserOutBufferSize = 0
+      private var maxTransportOutBufferSize = 0
 
       private val userInput = new UserInputSlot(plainIn)
       private val transportInput = new TransportInputSlot(cipherIn)
@@ -104,10 +102,6 @@ import pekko.util.ByteString
 
       override def preStart(): Unit =
         try {
-          val tcp = Tcp(materializer.system)
-          bufferPool = tcp.bufferPool
-          pooledBufferSize = tcp.Settings.DirectBufferSize
-
           engine = createSSLEngine()
           currentSession = engine.getSession
           allocateBuffers(currentSession)
@@ -135,15 +129,20 @@ import pekko.util.ByteString
       private def allocateBuffers(session: SSLSession): Unit = {
         val packetSize = math.max(1, session.getPacketBufferSize)
         val applicationSize = math.max(1, session.getApplicationBufferSize)
-        val applicationBatchSize = applicationBufferSize(applicationSize, packetSize)
         transportPacketSize = packetSize
         applicationRecordSize = applicationSize
-        maxUserInBufferSize = applicationBatchSize
-        maxUserOutBufferSize = applicationBatchSize
-
-        transportOutBuffer = acquireTransportBuffer(packetSize)
-        transportInBuffer = acquireTransportBuffer(packetSize)
-        transportUnreadBuffer = acquireTransportBuffer(packetSize)
+        maxUserInBufferSize = applicationSize * MaxApplicationRecordsPerEngineCall
+        maxUserOutBufferSize = applicationSize * MaxApplicationRecordsPerEngineCall
+        maxTransportOutBufferSize = packetSize * MaxApplicationRecordsPerEngineCall
+
+        // The JDK SSLEngine operates on byte[] internally and makes an extra direct<->heap copy per
+        // wrap/unwrap when handed a direct buffer (see Netty SslHandler's SslEngineType.JDK). Use heap
+        // buffers and, like Netty, size them on demand: start at a single record so small-payload or
+        // short-lived connections allocate little, and let growTransportOutBuffer enlarge the wrap
+        // buffer when a larger batch is actually produced.
+        transportOutBuffer = ByteBuffer.allocate(packetSize)
+        transportInBuffer = ByteBuffer.allocate(packetSize)
+        transportUnreadBuffer = ByteBuffer.allocate(packetSize)
         userInBuffer = ByteBuffer.allocate(applicationSize)
         userOutBuffer = ByteBuffer.allocate(applicationSize)
 
@@ -152,12 +151,6 @@ import pekko.util.ByteString
         TlsEngineHelpers.emptyReadBuffer(transportUnreadBuffer)
       }
 
-      private def applicationBufferSize(applicationSize: Int, packetSize: Int): Int = {
-        val recordsThatFitTransportBuffer = math.max(1, pooledBufferSize / packetSize)
-        val recordsPerEngineCall = math.min(MaxApplicationRecordsPerEngineCall, recordsThatFitTransportBuffer)
-        applicationSize * recordsPerEngineCall
-      }
-
       private def runPump(): Unit =
         if ((stateBits & (StageClosedFlag | StageCompletionPendingFlag)) == 0 &&
           (stateBits & InitialPumpEnabledFlag) != 0) {
@@ -403,6 +396,8 @@ import pekko.util.ByteString
         var result = engine.wrap(userInBuffer, transportOutBuffer)
 
         while (canContinueWrapping(result)) {
+          if (transportOutBuffer.remaining < transportPacketSize)
+            growTransportOutBuffer()
           val userPosition = userInBuffer.position()
           val transportPosition = transportOutBuffer.position()
           result = engine.wrap(userInBuffer, transportOutBuffer)
@@ -417,7 +412,8 @@ import pekko.util.ByteString
         result.getStatus == OK &&
         result.getHandshakeStatus == NOT_HANDSHAKING &&
         userInBuffer.hasRemaining &&
-        transportOutBuffer.remaining >= transportPacketSize
+        (transportOutBuffer.remaining >= transportPacketSize ||
+        transportOutBuffer.capacity < maxTransportOutBufferSize)
 
       @tailrec
       private def doUnwrap(ignoreOutput: Boolean): Unit = {
@@ -567,15 +563,13 @@ import pekko.util.ByteString
       }
 
       private def growTransportOutBuffer(): Unit = {
-        val oldBuffer = transportOutBuffer
-        val oldCapacity = oldBuffer.capacity()
+        val oldCapacity = transportOutBuffer.capacity()
         if (oldCapacity > Int.MaxValue / 2)
           throw new IllegalStateException(s"Cannot grow TLS transport output buffer beyond $oldCapacity bytes")
 
-        val bigger = acquireTransportBuffer(oldCapacity * 2)
+        val bigger = ByteBuffer.allocate(oldCapacity * 2)
         transportOutBuffer.flip()
         bigger.put(transportOutBuffer)
-        releaseTransportBuffer(oldBuffer)
         transportOutBuffer = bigger
       }
 
@@ -660,32 +654,13 @@ import pekko.util.ByteString
       }
 
       private def releaseBuffers(): Unit = {
-        releaseTransportBuffer(transportOutBuffer)
         transportOutBuffer = null
         userOutBuffer = null
-        releaseTransportBuffer(transportInBuffer)
         transportInBuffer = null
-        releaseTransportBuffer(transportUnreadBuffer)
         transportUnreadBuffer = null
         userInBuffer = null
       }
 
-      private def acquireTransportBuffer(requiredCapacity: Int): ByteBuffer = {
-        val buffer = bufferPool.acquire()
-        if (buffer.capacity >= requiredCapacity) buffer
-        else {
-          releaseTransportBuffer(buffer)
-          throw new IllegalStateException(
-            s"TLS packet buffer requires $requiredCapacity bytes but pekko.io.tcp.direct-buffer-size is $pooledBufferSize")
-        }
-      }
-
-      private def releaseTransportBuffer(buffer: ByteBuffer): Unit =
-        if (buffer ne null) {
-          buffer.clear()
-          bufferPool.release(buffer)
-        }
-
       private final class UserInputSlot(inlet: Inlet[SslTlsOutbound]) extends InHandler {
         private val pendingQueue = new Array[AnyRef](UserInputQueueSize)
         private var pendingHead = 0


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@pekko.apache.org
For additional commands, e-mail: commits-help@pekko.apache.org