duel-memcached 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4100ff714345815d7406440fc25bab63b6e3079aab787089d3f43f226fb1dd17
+  data.tar.gz: 83f9ed2340221e9b109c1eb84df79eec67a9a6b1f6de2c066d599a6753b17b3c
+SHA512:
+  metadata.gz: 6d3f2f03e8840190589dd12a95fddc233c776cc5d0bff6d5a9c10af85bd7312bdd4e418d4185f9c668d04febf6c80de1c3c45527f70ea3a565f9479fcbcbc68a
+  data.tar.gz: 4477a598c7dafc1340e19c28c8ec68f25932512933fc2fc228b9fa96eec3a0a3105d8e3e6390c0a2b69531867364b8bbbb9244a603bffcbde29ec6df0a22b662

data/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/2.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-24
+
+The first release. duel-memcached is a Duel plugin, open source under
+the MIT license. It needs Ruby 3.4 or later, Duel 0.1, and `memcached`
+(1.6 or later) on the `PATH`.
+
+### Added
+
+- `c.use :memcached`: a memcached server for each Duel worker, on a
+  Unix socket, and the `memcached_operations`, `memcached_misses` and
+  `memcached_bytes` metrics (and `memcached_cpu`, with `cpu: true`), from
+  its statistics, read over a connection of the plugin's own whose
+  traffic isn't counted.
+- `Duel::Memcached.servers` and `Duel::Memcached.flush`, for benchmarks:
+  `flush` opens a connection of its own, from the worker's
+  `DUEL_MEMCACHED_SERVERS`. It's for `setup` hooks, and `once` and
+  `untimed` blocks: while a benchmark is measured (`Duel.measuring?`) it raises `Duel::Error`,
+  as the flush would be counted.
+- `c.use :memcached` returns the plugin's own connection, opened in each
+  worker (`c.in_worker`) and closed as it ends (`at_stop`). Its
+  `value` fails outside a worker, saying so. The module keeps no
+  connection.
+- `memcached_cpu` is a `kind: :ratio` measure, left out of Duel's
+  across-the-board check (`across: false`), in microseconds
+  (`unit: "µs"`), so reports show it as time. `memcached_bytes` is in
+  bytes (`unit: "B"`), shown after the number. `memcached_operations`
+  and `memcached_misses` are in operations and misses (`unit:`, each
+  with its plural), so reports read "1 operation → 2 operations".
+- Its metrics are costly to read (Duel's `costly`): a benchmark with an
+  `around_iteration` hook reads the server's statistics only as each
+  sample starts and stops, not twice an iteration, and what the hook
+  sends the server (a transaction's `BEGIN` and `ROLLBACK`, say) is
+  learned in each worker and subtracted.
+- Reading the statistics allocates little: the reply is read whole into
+  a buffer the connection reuses (`Connection#stats_reply`), and each
+  metric's statistics are found and read in place, digit by digit. On
+  memcached 1.6's 94 statistics, `memcached_cpu`'s reading allocates
+  nothing, and the counted metrics' allocates only their Hash.
+  `Duel::Memcached.sum` takes that reply.
+
+
+[Unreleased]: https://github.com/sferik/duel-ruby/compare/duel-memcached-v0.1.0...HEAD
+[0.1.0]: https://github.com/sferik/duel-ruby/releases/tag/duel-memcached-v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erik Berlin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,114 @@
+# duel-memcached
+
+[![Duel](https://raw.githubusercontent.com/sferik/duel-ruby/main/assets/badge.svg)](https://github.com/sferik/duel-ruby)
+[![duel-memcached](https://github.com/sferik/duel-ruby/actions/workflows/plugin-memcached.yml/badge.svg)](https://github.com/sferik/duel-ruby/actions/workflows/plugin-memcached.yml)
+[![Gem Version](https://badge.fury.io/rb/duel-memcached.svg)](https://rubygems.org/gems/duel-memcached)
+
+A [Duel](https://github.com/sferik/duel-ruby) plugin for code that talks
+to memcached: each Duel worker gets a memcached server of its own, and
+every benchmark is judged on what memcached did for it too.
+
+| Metric | What it is | A regression |
+|---|---|---|
+| `memcached_operations` | the keys it fetched, stored, touched, deleted, incremented or decremented, and flushes | any increase |
+| `memcached_misses` | the operations that found no key | any increase |
+| `memcached_bytes` | the bytes it read and wrote: requests, replies, keys and values | more than one an iteration |
+| `memcached_cpu` | its CPU time, in µs (only with `cpu: true`) | > 5% slower, 99% confident |
+
+So a change that fetches one more key per request, stops finding what it
+cached, or caches bigger values fails even when its CPU time on the Ruby
+side doesn't change:
+
+```
+REGRESSION store: worse memcached_operations, memcached_bytes in every measurement
+  memcached_operations: 1 operation → 2 operations an iteration
+  memcached_bytes: 34 B → 70 B an iteration
+```
+
+## Installation
+
+```ruby
+# Gemfile
+group :development do
+  gem "duel-memcached"
+end
+```
+
+> [!NOTE]
+> It needs `memcached` (1.6 or later) on the `PATH`.
+
+## Usage
+
+```ruby
+# .duel.rb
+Duel.configure { |c| c.use :memcached }
+```
+
+Each worker's server listens only on a Unix socket in the worker's own
+directory, with 32 MB of memory and one thread. The socket's path is in
+`DUEL_MEMCACHED_SERVERS`, and in `MEMCACHE_SERVERS` too, so a client that
+reads that (Dalli does) finds it and nothing reaches another memcached.
+Benchmarks can call `Duel::Memcached.servers` and
+`Duel::Memcached.flush`:
+
+```ruby
+# duel/cache_duel.rb
+duel "cache: a hit" do
+  once do
+    Duel::Memcached.flush                                # empties the worker's server (over a connection of its own)
+    @cache = Dalli::Client.new(Duel::Memcached.servers) # its socket
+    @cache.set("k", "v")
+  end
+  @cache.get("k")
+end
+```
+
+> [!IMPORTANT]
+> `Duel::Memcached.flush` is for setting up: call it in a `setup` hook,
+> or a `once` or `untimed` block. While a benchmark is measured (`Duel.measuring?`), it
+> raises `Duel::Error` rather than have the flush counted.
+
+Options:
+
+```ruby
+c.use :memcached,
+  server: "/opt/memcached/bin/memcached", # the program (default: DUEL_MEMCACHED_SERVER, or memcached)
+  args: ["-m", "256"],                    # more of its options (they win)
+  env: %w[CACHE_SERVERS],                 # variables given its socket besides DUEL_MEMCACHED_SERVERS (default: MEMCACHE_SERVERS)
+  cpu: true                               # judge memcached_cpu too
+```
+
+The metrics come from the server's `stats`, read over a connection of
+the plugin's own, opened as each worker starts (Duel's `c.in_worker`)
+and closed as it ends. `c.use :memcached` returns it, for a `.duel.rb`
+that reads the server too (`connection.value`, in a worker only).
+`Duel::Memcached.flush` opens a connection of its own, from the worker's
+`DUEL_MEMCACHED_SERVERS`: a flush is an operation, and its bytes count
+as any client's (so it fails while a benchmark is measured).
+`memcached_operations` counts keys, not commands: a
+`get_multi` of ten keys is ten. Memcached keeps no count of commands or
+replies, so a change from one `get_multi` to ten `get`s shows in
+`memcached_bytes`, not in operations.
+
+`memcached_bytes` leaves out the plugin's own traffic, to the byte (a
+reading's reply is longer when the numbers in it are), so it's exact.
+But what the server makes up (CAS ids) grows a digit now and then, and so
+may values of your code's (times, ids), so a byte more an iteration
+isn't a regression.
+
+`memcached_cpu` is off unless asked for: memcached's CPU time (from
+`rusage_user` and `rusage_system`, to the microsecond) is the whole
+process's, background threads and all, and depends on how fast the
+client sends it work. It's noisy, and what it would catch (more work for
+the server) usually shows exactly in operations and bytes first. When
+it's on, it's judged above 300µs a sample (on either version), against
+a limit of 1.05, and not across the board (where Duel judges every
+benchmark's median together, with a margin a quarter of the limit's:
+too fine for it).
+
+Duel's `c.measure` changes any of their settings, or leaves one out:
+
+```ruby
+c.measure("memcached_bytes", tolerance: 8)  # values whose length varies more
+c.measure("memcached_misses", skip: true)
+```

data/lib/duel/memcached/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Duel
+  module Memcached
+    VERSION = "0.1.0"
+  end
+end

data/lib/duel/memcached.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "duel"
+require "socket"
+require_relative "memcached/version"
+
+module Duel
+  # A memcached server of each worker's own, and what it did for each
+  # benchmark:
+  #
+  # - memcached_operations: the keys it fetched, stored, touched,
+  #   deleted, incremented or decremented, and flushes (counted)
+  # - memcached_misses: the operations that found no key (counted)
+  # - memcached_bytes: the bytes it read and wrote, the protocol's and
+  #   the values' (counted)
+  # - memcached_cpu: its CPU time, in microseconds (judged like CPU
+  #   time; only with cpu: true)
+  #
+  #   # .duel.rb
+  #   Duel.configure { |c| c.use :memcached }
+  #
+  # Benchmarks can call Duel::Memcached.servers, and
+  # Duel::Memcached.flush in setup (or untimed blocks): while a benchmark
+  # is measured, it fails.
+  #
+  # The server listens only on a Unix socket in the worker's directory,
+  # with one thread (so its statistics are up to date when they're read);
+  # the socket's path is in DUEL_MEMCACHED_SERVERS, and in
+  # MEMCACHE_SERVERS too (unless +env+ names others), so a client that
+  # reads that (Dalli does) finds it.
+  module Memcached
+    Duel.plugin(:memcached, self)
+
+    SERVERS = "DUEL_MEMCACHED_SERVERS"
+
+    # Configures Duel for the plugin (c.use :memcached): the server
+    # (+server+ is the program, +args+ more of its options) and its
+    # metrics, memcached_cpu too with +cpu+. Returns the plugin's own
+    # connection to it, a worker's (see Config#in_worker, and in tests,
+    # Duel::Testing.in_worker).
+    def self.configure(config, server: ENV.fetch("DUEL_MEMCACHED_SERVER", "memcached"), args: [], env: %w[MEMCACHE_SERVERS], cpu: false)
+      config.prepare(:worker) do |w|
+        socket = w.path("memcached.sock")
+        w.spawn(*[server, "-s", socket, "-m", "32", "-t", "1"] + args)
+        w.wait_until { Connection.ready?(socket) }
+        ([SERVERS] + env).to_h { |name| [name, socket] }
+      end
+      connection = config.in_worker { |w| Connection.new(servers).tap { |memcached| w.at_stop { memcached.close } } }
+      config.metric(METRICS) { stats(connection.value) }.costly
+      config.metric("memcached_cpu", **CPU) { cpu_time(connection.value) }.costly if cpu
+      connection
+    end
+
+    # (Reading the statistics costs these nothing: stats isn't an
+    # operation, and the plugin's own bytes are taken away.)
+    METRICS = {
+      "memcached_operations" => {kind: :counted, unit: %w[operation operations], calibrate: false},
+      "memcached_misses" => {kind: :counted, unit: %w[miss misses], calibrate: false},
+      # Values the server makes up (CAS ids, say) grow a digit now and
+      # then, and so may the code's own: a byte more an iteration isn't a
+      # regression.
+      "memcached_bytes" => {kind: :counted, unit: "B", tolerance: 1, calibrate: false}
+    }
+
+    # memcached_cpu's settings. Its CPU time is the whole process's (its
+    # background threads too), and swings with how the client paces it:
+    # noisy, so judged only above 300µs, against a limit of its own, not
+    # across the board (where the margin is a quarter of that), and only
+    # when asked for. (A metric of its own: read around every sample, as a
+    # ratio one is, where the counted ones are read only in counting
+    # samples.)
+    CPU = {kind: :ratio, unit: "µs", floor: 300, limit: 1.05, across: false}
+
+    # The statistics each is the sum of.
+    OPERATIONS = %w[cmd_get cmd_set cmd_touch cmd_flush delete_hits delete_misses incr_hits incr_misses decr_hits decr_misses].freeze
+    MISSES = %w[get_misses touch_misses delete_misses incr_misses decr_misses cas_misses].freeze
+    BYTES = %w[bytes_read bytes_written].freeze
+    RUSAGE = %w[rusage_user rusage_system].freeze
+
+    # What a statistic's line starts with, by its name (made once each).
+    NEEDLES = Hash.new { |needles, name| needles[name] = "STAT #{name} " }
+
+    # What the worker's server has done so far, read over +connection+
+    # (the plugin's own): its traffic isn't counted (it's known to the
+    # byte, while what readings write varies with the numbers in them).
+    # Read around every counting sample, it allocates only its Hash.
+    def self.stats(connection)
+      stats = connection.stats_reply
+      {"memcached_operations" => sum(stats, OPERATIONS),
+       "memcached_misses" => sum(stats, MISSES),
+       "memcached_bytes" => sum(stats, BYTES) - connection.own}
+    end
+
+    # Its CPU time so far, in microseconds, read over +connection+: the
+    # readings' too, as they're too slight to matter and too unsteady to
+    # take away. Read around every sample, it allocates nothing.
+    def self.cpu_time(connection) = sum(connection.stats_reply, RUSAGE)
+
+    # The sum of +names+ in +stats+, a stats reply as the server sent it.
+    def self.sum(stats, names) = names.sum { |name| value(stats, name) }
+
+    # The value of +name+ in +stats+ (a stats reply), read in place, digit
+    # by digit, so as to allocate nothing: rusage_* are seconds with six
+    # decimals, microseconds without the point.
+    def self.value(stats, name)
+      needle = NEEDLES[name]
+      at = stats.byteindex(needle) or raise KeyError, "key not found: #{name.inspect}"
+      at += needle.bytesize
+      raise ArgumentError, "memcached: #{name} isn't a number" unless stats.match?(/\G\d+(?:\.\d+)?\r/, at)
+
+      value = 0
+      until (byte = stats.getbyte(at)) == 13 # "\r", where the number ends
+        # (A digit, or the point: the value matched, so it's never nil.)
+        value = (value * 10) + byte - 48 unless byte == 46 # steep:ignore UnresolvedOverloading
+        at += 1
+      end
+      value
+    end
+
+    # For benchmarks: the worker's server (its socket's path).
+    def self.servers = ENV.fetch(SERVERS)
+
+    # Empties it, over a connection of its own (opened and closed: a Unix
+    # socket's is cheap). A flush is an operation, and its bytes count as
+    # any client's: so it's for setup or untimed blocks only, and fails
+    # while a benchmark is measured (Duel.measuring?).
+    def self.flush
+      Duel.unmeasured!("Duel::Memcached.flush")
+
+      connection = Connection.new(servers)
+      begin
+        connection.flush_all
+      ensure
+        connection.close
+      end
+    end
+
+    # The least a connection needs to read a server's statistics (text
+    # protocol): not the code's own, whose operations are what's
+    # measured. It counts its own traffic.
+    class Connection
+      # Its bytes the server had counted when it answered the latest
+      # stats: those sent (that stats command's too), and those received
+      # before its reply.
+      attr_reader :own
+
+      # The most read at a time: a whole stats reply (some 2.5KB) at once.
+      READ = 65_536
+
+      def self.ready?(path)
+        socket = UNIXSocket.new(path)
+        begin
+          socket.write("version\r\n")
+          socket.gets.to_s.start_with?("VERSION ")
+        ensure
+          socket.close
+        end
+      rescue SystemCallError, IOError # (JRuby's refusal is an IOError)
+        false
+      end
+
+      def initialize(path)
+        @socket = UNIXSocket.new(path)
+        @sent = @received = @own = 0
+        @reply = +""
+        @chunk = +""
+      end
+
+      # The server's statistics, by name: each line's name and value
+      # sliced from the reply, without a String for each line.
+      def stats
+        reply = stats_reply
+        stats = {} #: Hash[String, String]
+        line = 0
+        while reply.getbyte(line) == 83 # "S": a STAT line, not the END after them
+          name = line + 5 # after "STAT "
+          space = reply.byteindex(" ", name) #: Integer
+          line = reply.byteindex("\r\n", space) #: Integer
+          key = reply.byteslice(name, space - name) #: String
+          value = reply.byteslice(space + 1, line - space - 1) #: String
+          stats[key] = value
+          line += 2
+        end
+        stats
+      end
+
+      # The server's statistics as it sent them (a line each, then END),
+      # read whole into a buffer of the connection's, which the next
+      # reading reuses: nothing's allocated.
+      def stats_reply
+        request("stats\r\n")
+        @own = @sent + @received
+        @reply.clear
+        receive until @reply.end_with?("\r\n") && (!@reply.start_with?("STAT ") || @reply.end_with?("\nEND\r\n"))
+        raise "memcached: #{@reply.chomp}" unless @reply.start_with?("STAT ") || @reply == "END\r\n"
+
+        @reply
+      end
+
+      # Empties the server; returns its reply.
+      def flush_all
+        request("flush_all\r\n")
+        reply
+      end
+
+      def close = @socket.close
+
+      private
+
+      # +command+ is a line, its CRLF too. (Written straight to the
+      # socket, which write would allocate for.)
+      def request(command)
+        @sent += @socket.syswrite(command)
+      end
+
+      # Appends what the server sent next to the reply.
+      def receive
+        @socket.readpartial(READ, @chunk)
+        @received += @chunk.bytesize
+        @reply << @chunk
+      rescue EOFError
+        raise IOError, "memcached closed the connection"
+      end
+
+      def reply
+        line = @socket.gets or raise IOError, "memcached closed the connection"
+        @received += line.bytesize
+        line = line.chomp
+        raise "memcached: #{line}" if line.match?(/\A(?:ERROR|CLIENT_ERROR|SERVER_ERROR)/)
+
+        line
+      end
+    end
+  end
+end

data/sig/duel/memcached.rbs

@@ -0,0 +1,92 @@
+module Duel
+  # A memcached server of each worker's own, and what it did for each
+  # benchmark (memcached_operations, memcached_misses, memcached_bytes,
+  # and with cpu: true memcached_cpu).
+  module Memcached
+    VERSION: String
+
+    SERVERS: String
+
+    METRICS: Hash[String, Metric::settings]
+
+    CPU: Metric::settings
+
+    # The statistics each is the sum of.
+    OPERATIONS: Array[String]
+    MISSES: Array[String]
+    BYTES: Array[String]
+    RUSAGE: Array[String]
+
+    # What a statistic's line starts with, by its name (made once each).
+    NEEDLES: Hash[String, String]
+
+    # Configures Duel for the plugin (c.use :memcached): the server
+    # (+server+ is the program, +args+ more of its options, +env+ the
+    # variables besides DUEL_MEMCACHED_SERVERS given its socket's path)
+    # and its metrics, memcached_cpu too with +cpu+. Returns the plugin's
+    # own connection to it, a worker's.
+    def self.configure: (Config config, ?server: String, ?args: Array[String], ?env: Array[String], ?cpu: bool) -> InWorker[Connection]
+
+    # What the worker's server has done so far (but memcached_cpu), read
+    # over +connection+ (the plugin's own). It allocates only its Hash.
+    def self.stats: (Connection connection) -> Hash[String, Integer]
+
+    # Its CPU time so far, in microseconds, read over +connection+. It
+    # allocates nothing.
+    def self.cpu_time: (Connection connection) -> Integer
+
+    # The sum of +names+ in +stats+, a stats reply as the server sent it.
+    def self.sum: (String stats, Array[String] names) -> Integer
+
+    # The value of +name+ in +stats+ (a stats reply), read in place.
+    def self.value: (String stats, String name) -> Integer
+
+    # For benchmarks: the worker's server (its socket's path).
+    def self.servers: () -> String
+
+    # Empties it, over a connection of its own: in setup or untimed
+    # blocks only (it fails while a benchmark is measured).
+    def self.flush: () -> String
+
+    # The least a connection needs to read a server's statistics.
+    class Connection
+      @socket: UNIXSocket
+      @sent: Integer
+      @received: Integer
+      @reply: String
+      @chunk: String
+
+      # Its bytes the server had counted when it answered the latest stats.
+      attr_reader own: Integer
+
+      # The most read at a time.
+      READ: Integer
+
+      def self.ready?: (String path) -> bool
+
+      def initialize: (String path) -> void
+
+      # The server's statistics, by name.
+      def stats: () -> Hash[String, String]
+
+      # The server's statistics as it sent them, in a buffer the next
+      # reading reuses.
+      def stats_reply: () -> String
+
+      # Empties the server; returns its reply.
+      def flush_all: () -> String
+
+      def close: () -> void
+
+      private
+
+      # +command+ is a line, its CRLF too.
+      def request: (String command) -> Integer
+
+      # Appends what the server sent next to the reply.
+      def receive: () -> String
+
+      def reply: () -> String
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: duel-memcached
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Erik Berlin
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: duel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: 'A Duel plugin: each worker gets a memcached server of its own, and every
+  benchmark is judged on the memcached operations, misses and bytes it took too.'
+email:
+- sferik@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/duel/memcached.rb
+- lib/duel/memcached/version.rb
+- sig/duel/memcached.rbs
+homepage: https://github.com/sferik/duel-ruby/tree/main/plugins/memcached
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/sferik/duel-ruby/tree/main/plugins/memcached
+  changelog_uri: https://github.com/sferik/duel-ruby/blob/main/plugins/memcached/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sferik/duel-ruby/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.23
+specification_version: 4
+summary: A memcached server for each Duel worker, and what it did for each benchmark
+test_files: []