Substantial efficiency improvements

Author: michaelklishin

ChangeLog.md

@@ -1,7 +1,30 @@
-## Changes between 2.3.4 and 2.3.5 (in development)
+## Changes between 2.4.0 and 2.5.0 (in development)
 
 No changes yet.
 
+## Changes between 2.3.4 and 2.4.0 (Dec 30, 2025)
+
+### Bug Fixes
+
+ * Fixed `BadResponseError` constructor which referenced undefined variable `data` instead of `actual`
+
+### Performance Improvements
+
+Optimized encoding and decoding hot paths:
+
+ * Built-in `Q>`/`q>` packing/unpacking directives are 6-7x faster than the original implementation (that originally targeted Ruby 1.8.x)
+ * Switched to `unpack1` instead of `unpack().first` throughout
+ * Use `byteslice` instead of `slice` for binary string operations
+ * Use `getbyte` for single byte access (4x faster than alternatives)
+ * Adopted `frozen_string_literal` pragma
+
+The improvements on Ruby 3.4 are very meaningful:
+
+ * `AMQ::Pack.pack_uint64_big_endian`: about 6.6x faster
+ * `AMQ::Pack.unpack_uint64_big_endian`: about 7.2x faster
+ * `Basic.Deliver.decode`: about 1.7x faster
+ * `Basic.Ack/Nack/Reject.encode`: about 2.5x faster
+
 
 ## Changes between 2.3.3 and 2.3.4 (May 12, 2025)
 
@@ -16,13 +39,13 @@ GitHub issue: [#80](https://github.com/ruby-amqp/amq-protocol/pull/80)
 
 ### Improved Compatibility with Ruby 3.4
 
-Contribiuted by @BenTalagan.
+Contributed by @BenTalagan.
 
 GitHub issue: [#79](https://github.com/ruby-amqp/amq-protocol/pull/79)
 
 ### Support Binary-Encoded Frozen Strings for Payloads
 
-Contribiuted by @djrodgerspryor.
+Contributed by @djrodgerspryor.
 
 GitHub issue: [#78](https://github.com/ruby-amqp/amq-protocol/pull/78)
 

Gemfile

@@ -10,6 +10,11 @@ group :development do
   gem "rake"
 end
 
+group :benchmark do
+  gem "benchmark-ips", "~> 2.12"
+  gem "benchmark-memory", "~> 0.2"
+end
+
 group :test do
   gem "rspec", ">= 3.8.0"
   gem "rspec-its"

benchmarks/frame_encoding.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "amq/protocol/client"
+require "benchmark/ips"
+
+puts
+puts "-" * 80
+puts "Frame Encoding Benchmarks on #{RUBY_DESCRIPTION}"
+puts "-" * 80
+
+# Test data
+SMALL_PAYLOAD = "x" * 100
+MEDIUM_PAYLOAD = "x" * 1024
+LARGE_PAYLOAD = "x" * 16384
+
+CHANNEL = 1
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("Frame.encode(:method, small)") do
+    AMQ::Protocol::Frame.encode(:method, SMALL_PAYLOAD, CHANNEL)
+  end
+
+  x.report("Frame.encode(:method, medium)") do
+    AMQ::Protocol::Frame.encode(:method, MEDIUM_PAYLOAD, CHANNEL)
+  end
+
+  x.report("Frame.encode(:body, large)") do
+    AMQ::Protocol::Frame.encode(:body, LARGE_PAYLOAD, CHANNEL)
+  end
+
+  x.report("MethodFrame.new + encode") do
+    frame = AMQ::Protocol::MethodFrame.new(SMALL_PAYLOAD, CHANNEL)
+    frame.encode
+  end
+
+  x.report("BodyFrame.new + encode") do
+    frame = AMQ::Protocol::BodyFrame.new(MEDIUM_PAYLOAD, CHANNEL)
+    frame.encode
+  end
+
+  x.report("HeartbeatFrame.encode") do
+    AMQ::Protocol::HeartbeatFrame.encode
+  end
+
+  x.compare!
+end
+
+puts
+puts "-" * 80
+puts "Frame Header Decoding"
+puts "-" * 80
+
+# Encoded frame headers
+METHOD_HEADER = [1, 0, 1, 0, 0, 0, 100].pack("CnN")  # type=1, channel=1, size=100
+BODY_HEADER = [3, 0, 5, 0, 0, 16, 0].pack("CnN")     # type=3, channel=5, size=4096
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("Frame.decode_header (method)") do
+    AMQ::Protocol::Frame.decode_header(METHOD_HEADER)
+  end
+
+  x.report("Frame.decode_header (body)") do
+    AMQ::Protocol::Frame.decode_header(BODY_HEADER)
+  end
+
+  x.compare!
+end

benchmarks/method_encoding.rb

@@ -0,0 +1,198 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "amq/protocol/client"
+require "benchmark/ips"
+
+puts
+puts "-" * 80
+puts "AMQP Method Encoding/Decoding Benchmarks on #{RUBY_DESCRIPTION}"
+puts "-" * 80
+
+FRAME_SIZE = 131072  # 128KB, typical default
+
+# Common message properties
+BASIC_PROPERTIES = {
+  content_type: "application/json",
+  delivery_mode: 2,
+  priority: 0,
+  headers: { "x-custom" => "value" }
+}.freeze
+
+MINIMAL_PROPERTIES = {
+  delivery_mode: 2
+}.freeze
+
+# Payloads
+SMALL_BODY = '{"id":1}'.freeze
+MEDIUM_BODY = ('x' * 1024).freeze
+LARGE_BODY = ('x' * 65536).freeze
+
+puts "=== Basic.Publish (Full Message Encoding) ==="
+puts "This is the critical hot path for publishing messages"
+puts
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("Publish small (8B) + minimal props") do
+    AMQ::Protocol::Basic::Publish.encode(
+      1,              # channel
+      SMALL_BODY,     # payload
+      MINIMAL_PROPERTIES,
+      "",             # exchange
+      "test.queue",   # routing_key
+      false,          # mandatory
+      false,          # immediate
+      FRAME_SIZE
+    )
+  end
+
+  x.report("Publish small (8B) + full props") do
+    AMQ::Protocol::Basic::Publish.encode(
+      1,
+      SMALL_BODY,
+      BASIC_PROPERTIES,
+      "",
+      "test.queue",
+      false,
+      false,
+      FRAME_SIZE
+    )
+  end
+
+  x.report("Publish medium (1KB) + full props") do
+    AMQ::Protocol::Basic::Publish.encode(
+      1,
+      MEDIUM_BODY,
+      BASIC_PROPERTIES,
+      "",
+      "test.queue",
+      false,
+      false,
+      FRAME_SIZE
+    )
+  end
+
+  x.report("Publish large (64KB) + full props") do
+    AMQ::Protocol::Basic::Publish.encode(
+      1,
+      LARGE_BODY,
+      BASIC_PROPERTIES,
+      "",
+      "test.queue",
+      false,
+      false,
+      FRAME_SIZE
+    )
+  end
+
+  x.compare!
+end
+
+# Create sample encoded methods for decoding benchmarks
+puts
+puts "=== Method Decoding ==="
+
+# Simulate encoded Basic.Deliver frame payload (after class/method ID)
+# Basic.Deliver: consumer_tag(shortstr), delivery_tag(longlong), redelivered(bit), exchange(shortstr), routing_key(shortstr)
+def make_deliver_payload(consumer_tag, delivery_tag, exchange, routing_key)
+  buffer = String.new(encoding: 'BINARY')
+  buffer << consumer_tag.bytesize.chr
+  buffer << consumer_tag
+  buffer << AMQ::Pack.pack_uint64_big_endian(delivery_tag)
+  buffer << "\x00"  # redelivered = false
+  buffer << exchange.bytesize.chr
+  buffer << exchange
+  buffer << routing_key.bytesize.chr
+  buffer << routing_key
+  buffer
+end
+
+DELIVER_PAYLOAD_SHORT = make_deliver_payload("ctag", 1, "", "q")
+DELIVER_PAYLOAD_TYPICAL = make_deliver_payload("bunny-consumer-12345", 999999, "amq.topic", "events.user.created")
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("Basic.Deliver.decode (short)") do
+    AMQ::Protocol::Basic::Deliver.decode(DELIVER_PAYLOAD_SHORT)
+  end
+
+  x.report("Basic.Deliver.decode (typical)") do
+    AMQ::Protocol::Basic::Deliver.decode(DELIVER_PAYLOAD_TYPICAL)
+  end
+
+  x.compare!
+end
+
+puts
+puts "=== Properties Encoding/Decoding ==="
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("encode_properties (minimal)") do
+    AMQ::Protocol::Basic.encode_properties(100, MINIMAL_PROPERTIES)
+  end
+
+  x.report("encode_properties (full)") do
+    AMQ::Protocol::Basic.encode_properties(1024, BASIC_PROPERTIES)
+  end
+
+  x.compare!
+end
+
+# Create encoded properties for decode benchmark
+ENCODED_MINIMAL_PROPS = AMQ::Protocol::Basic.encode_properties(100, MINIMAL_PROPERTIES)
+ENCODED_FULL_PROPS = AMQ::Protocol::Basic.encode_properties(1024, BASIC_PROPERTIES)
+
+# Skip the first 12 bytes (class_id, weight, body_size)
+PROPS_DATA_MINIMAL = ENCODED_MINIMAL_PROPS[12..-1]
+PROPS_DATA_FULL = ENCODED_FULL_PROPS[12..-1]
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("decode_properties (minimal)") do
+    AMQ::Protocol::Basic.decode_properties(PROPS_DATA_MINIMAL)
+  end
+
+  x.report("decode_properties (full)") do
+    AMQ::Protocol::Basic.decode_properties(PROPS_DATA_FULL)
+  end
+
+  x.compare!
+end
+
+puts
+puts "=== Other Common Methods ==="
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("Basic.Ack.encode") do
+    AMQ::Protocol::Basic::Ack.encode(1, 12345, false)
+  end
+
+  x.report("Basic.Nack.encode") do
+    AMQ::Protocol::Basic::Nack.encode(1, 12345, false, true)
+  end
+
+  x.report("Basic.Reject.encode") do
+    AMQ::Protocol::Basic::Reject.encode(1, 12345, true)
+  end
+
+  x.report("Queue.Declare.encode") do
+    AMQ::Protocol::Queue::Declare.encode(1, "test.queue", false, true, false, false, false, {})
+  end
+
+  x.report("Exchange.Declare.encode") do
+    AMQ::Protocol::Exchange::Declare.encode(1, "test.exchange", "topic", false, true, false, false, false, {})
+  end
+
+  x.compare!
+end