amq-protocol 2.3.4 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90852fae30dd15d9f1f6ee5f9c0d98e856c3efcbd4c11e7e824caf63a01360f7
-  data.tar.gz: a000c7b2f435fc08f2d9c90a765f81e0414ca1c3038fcab1915ff7bcd4bdb929
+  metadata.gz: 6d6619ef67f8b1e30048f898796d21854eae2a35dfdfe83286e0a5e894cbbf1c
+  data.tar.gz: 0d62824daba6da208b96b7681e4c1db4f5c32a93a7a8a7714b875b8ad8f603e2
 SHA512:
-  metadata.gz: 718a613e5a2355791ef4d07bd38676b005cb00cd54969183a31eeba96cc3439ba223a8d9636050aa9aaf2ac5ca63150d3e3c53ce3e4638b53191097183b47ba3
-  data.tar.gz: 598de750f0c0ba6c838f4d1f34b4fb24f05b0a580c6b8beb7804d4edae437c628c18ac56d8ef87afc78ad56876ca4baafcf051f90f1eea9bb0cf3d48e993ea66
+  metadata.gz: cac00e1594a26adcb0863b6505ba789e8fce9a1dee3a38584e58cf838479661ba857a37ac3d747c69e7751549e15877a6478dd51559a8003af70c68e856badb1
+  data.tar.gz: 040e923fd9dcf5931a157007835085ec30b7ac44897c5a76ee05545f14f76cf431a3611f73fddb562e6bf9230fb82151fc808bfed24bc2244f12c85164541b6e

data/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)
 

data/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"

data/README.md

@@ -9,6 +9,8 @@ needs for you, including RabbitMQ extensions to AMQP 0.9.1.
 
 ## Supported Ruby Versions
 
+ * amq-protocol `2.3.4` has fixes for Ruby 3.5 compatibility
+ * amq-protocol `2.3.3` has fixes for Ruby 3.4 compatibility
  * amq-protocol `2.3.0` only supports Ruby 2.2+.
  * amq-protocol `2.0.0` through `2.2.0` and later supports Ruby 2.0+.
  * amq-protocol `1.9.2` was the last version to support Ruby 1.8 and 1.9.
@@ -45,21 +47,14 @@ To run tests, use
 amq-protocol is maintained by [Michael Klishin](https://github.com/michaelklishin).
 
 
-## CI Status
-
-[![Build Status](https://secure.travis-ci.org/ruby-amqp/amq-protocol.svg)](https://travis-ci.org/ruby-amqp/amq-protocol)
-
-
 ## Issues
 
 Please report any issues you may find to our [Issue tracker](http://github.com/ruby-amqp/amq-protocol/issues) on GitHub.
 
-
 ## Mailing List
 
 Any questions you may have should be sent to the [Ruby AMQP mailing list](http://groups.google.com/group/ruby-amqp).
 
-
 ## License
 
 MIT (see LICENSE in the repository root).

data/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

data/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

data/benchmarks/pack_unpack.rb

@@ -0,0 +1,158 @@
+#!/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 "Pack/Unpack Micro-benchmarks on #{RUBY_DESCRIPTION}"
+puts "-" * 80
+
+# Test data
+UINT64_VALUE = 0x123456789ABCDEF0
+UINT32_VALUE = 0x12345678
+UINT16_VALUE = 0x1234
+
+PACKED_UINT64_BE = (+"\x12\x34\x56\x78\x9A\xBC\xDE\xF0").force_encoding('BINARY').freeze
+PACKED_UINT32_BE = (+"\x12\x34\x56\x78").force_encoding('BINARY').freeze
+PACKED_UINT16_BE = (+"\x12\x34").force_encoding('BINARY').freeze
+
+puts "=== Pack Operations ==="
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("AMQ::Pack.pack_uint64_big_endian") do
+    AMQ::Pack.pack_uint64_big_endian(UINT64_VALUE)
+  end
+
+  # Alternative: direct pack with 'Q>' directive (Ruby 1.9.3+)
+  x.report("[val].pack('Q>')") do
+    [UINT64_VALUE].pack('Q>')
+  end
+
+  x.report("[val].pack('N') uint32") do
+    [UINT32_VALUE].pack('N')
+  end
+
+  x.report("[val].pack('n') uint16") do
+    [UINT16_VALUE].pack('n')
+  end
+
+  x.compare!
+end
+
+puts
+puts "=== Unpack Operations ==="
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("AMQ::Pack.unpack_uint64_big_endian") do
+    AMQ::Pack.unpack_uint64_big_endian(PACKED_UINT64_BE)
+  end
+
+  # Alternative: direct unpack with 'Q>' directive
+  x.report("data.unpack('Q>')") do
+    PACKED_UINT64_BE.unpack('Q>')
+  end
+
+  x.report("data.unpack1('Q>')") do
+    PACKED_UINT64_BE.unpack1('Q>')
+  end
+
+  x.report("data.unpack('N').first") do
+    PACKED_UINT32_BE.unpack('N').first
+  end
+
+  x.report("data.unpack1('N')") do
+    PACKED_UINT32_BE.unpack1('N')
+  end
+
+  x.compare!
+end
+
+puts
+puts "=== String Slicing ==="
+
+DATA = ("x" * 1000).force_encoding('BINARY').freeze
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("data[offset, length]") do
+    DATA[100, 50]
+  end
+
+  x.report("data.byteslice(offset, length)") do
+    DATA.byteslice(100, 50)
+  end
+
+  x.report("data.slice(offset, length)") do
+    DATA.slice(100, 50)
+  end
+
+  x.compare!
+end
+
+puts
+puts "=== Single Byte Access ==="
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("data[0, 1].unpack('C').first") do
+    DATA[0, 1].unpack('C').first
+  end
+
+  x.report("data.getbyte(0)") do
+    DATA.getbyte(0)
+  end
+
+  x.report("data[0].ord") do
+    DATA[0].ord
+  end
+
+  x.report("data.unpack1('C')") do
+    DATA.unpack1('C')
+  end
+
+  x.compare!
+end
+
+puts
+puts "=== Buffer Building ==="
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("String.new + <<") do
+    buf = String.new
+    buf << "hello"
+    buf << "world"
+    buf << [1234].pack('N')
+    buf
+  end
+
+  x.report("+'' + <<") do
+    buf = +''
+    buf << "hello"
+    buf << "world"
+    buf << [1234].pack('N')
+    buf
+  end
+
+  x.report("Array#join") do
+    parts = []
+    parts << "hello"
+    parts << "world"
+    parts << [1234].pack('N')
+    parts.join
+  end
+
+  x.compare!
+end

data/benchmarks/run_all.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# frozen_string_literal: true
+
+# Master benchmark runner
+# Usage: ruby benchmarks/run_all.rb
+
+require 'fileutils'
+
+BENCHMARK_DIR = File.dirname(__FILE__)
+RESULTS_DIR = File.join(BENCHMARK_DIR, "results")
+
+FileUtils.mkdir_p(RESULTS_DIR)
+
+benchmarks = %w[
+  pack_unpack.rb
+  frame_encoding.rb
+  table_encoding.rb
+  method_encoding.rb
+]
+
+timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+ruby_version = RUBY_VERSION.gsub('.', '_')
+results_file = File.join(RESULTS_DIR, "benchmark_#{ruby_version}_#{timestamp}.txt")
+
+puts "=" * 80
+puts "AMQ-Protocol Benchmark Suite"
+puts "=" * 80
+puts "Ruby: #{RUBY_DESCRIPTION}"
+puts "Time: #{Time.now}"
+puts "Results will be saved to: #{results_file}"
+puts "=" * 80
+puts
+
+File.open(results_file, 'w') do |f|
+  f.puts "AMQ-Protocol Benchmark Results"
+  f.puts "Ruby: #{RUBY_DESCRIPTION}"
+  f.puts "Time: #{Time.now}"
+  f.puts "=" * 80
+  f.puts
+
+  benchmarks.each do |benchmark|
+    benchmark_path = File.join(BENCHMARK_DIR, benchmark)
+
+    if File.exist?(benchmark_path)
+      puts "\n>>> Running #{benchmark}..."
+      puts
+
+      output = `ruby #{benchmark_path} 2>&1`
+      puts output
+
+      f.puts ">>> #{benchmark}"
+      f.puts output
+      f.puts
+    else
+      puts "Warning: #{benchmark_path} not found, skipping..."
+    end
+  end
+end
+
+puts
+puts "=" * 80
+puts "Benchmark complete! Results saved to: #{results_file}"
+puts "=" * 80

data/benchmarks/table_encoding.rb

@@ -0,0 +1,110 @@
+#!/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 "Table Encoding/Decoding Benchmarks on #{RUBY_DESCRIPTION}"
+puts "-" * 80
+
+# Test data - various table sizes and types
+EMPTY_TABLE = {}
+
+SIMPLE_TABLE = {
+  "key1" => "value1",
+  "key2" => 42,
+  "key3" => true
+}.freeze
+
+TYPICAL_HEADERS = {
+  "content_type" => "application/json",
+  "content_encoding" => "utf-8",
+  "x-custom-header" => "some-value",
+  "x-retry-count" => 3,
+  "x-timestamp" => Time.now.to_i
+}.freeze
+
+COMPLEX_TABLE = {
+  "string" => "hello world",
+  "integer" => 123456789,
+  "float" => 3.14159,
+  "boolean_true" => true,
+  "boolean_false" => false,
+  "nested" => {
+    "inner_key" => "inner_value",
+    "inner_number" => 999
+  },
+  "array" => [1, 2, 3, "four", true]
+}.freeze
+
+LARGE_TABLE = (1..50).to_h { |i| ["key_#{i}", "value_#{i}"] }.freeze
+
+# Pre-encode tables for decode benchmarks
+ENCODED_EMPTY = AMQ::Protocol::Table.encode(EMPTY_TABLE)
+ENCODED_SIMPLE = AMQ::Protocol::Table.encode(SIMPLE_TABLE)
+ENCODED_TYPICAL = AMQ::Protocol::Table.encode(TYPICAL_HEADERS)
+ENCODED_COMPLEX = AMQ::Protocol::Table.encode(COMPLEX_TABLE)
+ENCODED_LARGE = AMQ::Protocol::Table.encode(LARGE_TABLE)
+
+puts "Table sizes (bytes): empty=#{ENCODED_EMPTY.bytesize}, simple=#{ENCODED_SIMPLE.bytesize}, typical=#{ENCODED_TYPICAL.bytesize}, complex=#{ENCODED_COMPLEX.bytesize}, large=#{ENCODED_LARGE.bytesize}"
+puts
+
+puts "=== Table Encoding ==="
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("encode empty") do
+    AMQ::Protocol::Table.encode(EMPTY_TABLE)
+  end
+
+  x.report("encode simple (3 keys)") do
+    AMQ::Protocol::Table.encode(SIMPLE_TABLE)
+  end
+
+  x.report("encode typical headers (5 keys)") do
+    AMQ::Protocol::Table.encode(TYPICAL_HEADERS)
+  end
+
+  x.report("encode complex (nested/array)") do
+    AMQ::Protocol::Table.encode(COMPLEX_TABLE)
+  end
+
+  x.report("encode large (50 keys)") do
+    AMQ::Protocol::Table.encode(LARGE_TABLE)
+  end
+
+  x.compare!
+end
+
+puts
+puts "=== Table Decoding ==="
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 2)
+
+  x.report("decode empty") do
+    AMQ::Protocol::Table.decode(ENCODED_EMPTY)
+  end
+
+  x.report("decode simple (3 keys)") do
+    AMQ::Protocol::Table.decode(ENCODED_SIMPLE)
+  end
+
+  x.report("decode typical headers (5 keys)") do
+    AMQ::Protocol::Table.decode(ENCODED_TYPICAL)
+  end
+
+  x.report("decode complex (nested/array)") do
+    AMQ::Protocol::Table.decode(ENCODED_COMPLEX)
+  end
+
+  x.report("decode large (50 keys)") do
+    AMQ::Protocol::Table.decode(ENCODED_LARGE)
+  end
+
+  x.compare!
+end