raindrops 0.19.2 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1444bc6e35e67993745b3627e848537490fd3b02a67e12be9721b031e22e70
-  data.tar.gz: 9ed2dff40418e89a71ecf18cfb74b72d28d9570ceef314ee1c81bdff19ed832a
+  metadata.gz: 6f78e29ec57e3f3710146a423cf60915d23a5f4366d70dcabbbef74fb69f71f3
+  data.tar.gz: 8a369d49c33a67af3b6acccaf64b04ed192cba9d163c8d48944cfac887511885
 SHA512:
-  metadata.gz: ccb15ce6a96c1619d53d6090851ef8152ebd673b2db8aed9c6d4bb42757de2d9d051888d3f105d6d3461683eb33575d343e7d31a1ddb91a8f9914bb4e6abcb81
-  data.tar.gz: ce265e39bf3217f3b62931ead0fff78e7e118785466bc0eecff1858f9d808982c12b14f2645ecfffd96c8cb8e0a1a72ac03c0d6ad220c84950dfd2fe05d7f258
+  metadata.gz: b9e5de8e7a7a84038bbe19a954d3d559ebec3ed4c7f68db2e2ada6373b045f4fbcd784c5d5b91005cad1d87f1db93f9dc31c9f7fc59ae56a7f73b98d9a96bf2e
+  data.tar.gz: 9913e9205b2527b9f5bd1bae58b0c2c8962505e87280c06257f603fb722978d6656c99cfa0a297ccd0734a7d6110b0a6ecd5155fec9870ec40a31044a00def4d

data/.olddoc.yml

@@ -5,8 +5,11 @@ public_email: raindrops-public@yhbt.net
 ml_url:
 - https://yhbt.net/raindrops-public/
 - http://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/raindrops-public
+imap_url:
+- imaps://yhbt.net/inbox.comp.lang.ruby.raindrops.0
+- imap://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/inbox.comp.lang.ruby.raindrops.0
 nntp_url:
-- nntp://news.public-inbox.org/inbox.comp.lang.ruby.raindrops
+- nntps://news.public-inbox.org/inbox.comp.lang.ruby.raindrops
 - nntp://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/inbox.comp.lang.ruby.raindrops
 source_code:
 - git clone https://yhbt.net/raindrops.git

data/GIT-VERSION-FILE

@@ -1 +1 @@
-GIT_VERSION = 0.19.2
+GIT_VERSION = 0.20.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v0.19.2
+DEF_VER=v0.20.0
 
 LF='
 '

data/LATEST

@@ -1,7 +1,10 @@
-=== raindrops 0.19.2 / 2021-05-25 23:13 UTC
+=== raindrops 0.20.0 / 2021-12-06 23:41 UTC
 
-  This release fixes compatibility with GC.compact on Ruby 3.x
-  when using ListenStats on Linux.  The listener stats
-  functionality is rarely used and does not affect most users
-  who just have raindrops installed for shared atomic counters.
+  Raindrops may now use file-backed mmap() rather than anonymous
+  memory.  Thanks to KJ Tsanaktsidis for the patch:
+
+  https://yhbt.net/raindrops-public/20211125065618.3432-1-ktsanaktsidis@zendesk.com/T/
+
+  The documentation is also updated to note our mail archives are now
+  available via IMAP(S).
 

data/NEWS

@@ -1,3 +1,13 @@
+=== raindrops 0.20.0 / 2021-12-06 23:41 UTC
+
+  Raindrops may now use file-backed mmap() rather than anonymous
+  memory.  Thanks to KJ Tsanaktsidis for the patch:
+
+  https://yhbt.net/raindrops-public/20211125065618.3432-1-ktsanaktsidis@zendesk.com/T/
+
+  The documentation is also updated to note our mail archives are now
+  available via IMAP(S).
+
 === raindrops 0.19.2 / 2021-05-25 23:13 UTC
 
   This release fixes compatibility with GC.compact on Ruby 3.x

data/README

@@ -58,24 +58,20 @@ If you use RubyGems:
 
 See Raindrops::Middleware and Raindrops::LastDataRecv documentation for
 use Rack servers.  The entire library is fully-documented and we are
-responsive on the publically archived mailing list
-(mailto:raindrops-public@yhbt.net) if
-you have any questions or comments.
+responsive on the publicly archived mailbox
+(mailto:raindrops-public@yhbt.net) if you have any questions or comments.
 
 == Development
 
 You can get the latest source via git from the following locations:
 
-  git://yhbt.net/raindrops.git
-  git://repo.or.cz/raindrops.git (mirror)
+  https://yhbt.net/raindrops.git
+  http://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/raindrops.git
+  http://repo.or.cz/w/raindrops.git (gitweb mirror)
 
-You may browse the code from the web and download the latest snapshot
-tarballs here:
+Snapshots and tarballs are available.
 
-* https://yhbt.net/raindrops.git
-* http://repo.or.cz/w/raindrops.git (gitweb)
-
-Inline patches (from "git format-patch") to the mailing list are
+Inline patches (from "git format-patch") to the mailbox are
 preferred because they allow code review and comments in the reply to
 the patch.
 
@@ -89,14 +85,17 @@ raindrops is licensed under the LGPL-2.1+
 == Contact
 
 All feedback (bug reports, user/development discussion, patches, pull
-requests) go to the publically archived mailing list:
+requests) go to the publicly archived mailbox:
 mailto:raindrops-public@yhbt.net
 
-Mailing list archives are available over HTTPS and NNTP:
+Mail archives are available over HTTP(S), IMAP(S) and NNTP(S):
 
 * https://yhbt.net/raindrops-public/
 * http://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/raindrops-public/
-* nntp://news.public-inbox.org/inbox.comp.lang.ruby.raindrops
+* imaps://yhbt.net/inbox.comp.lang.ruby.raindrops.0
+* imap://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/inbox.comp.lang.ruby.raindrops.0
+* nntps://news.public-inbox.org/inbox.comp.lang.ruby.raindrops
+* nntp://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/inbox.comp.lang.ruby.raindrops
 
 Since archives are public, scrub sensitive information and
 use anonymity tools such as Tor or Mixmaster if you deem necessary.

data/ext/raindrops/raindrops.c

@@ -4,6 +4,7 @@
 #include <assert.h>
 #include <errno.h>
 #include <stddef.h>
+#include <string.h>
 #include "raindrops_atomic.h"
 
 #ifndef SIZET2NUM
@@ -34,9 +35,17 @@ struct raindrops {
 	size_t size;
 	size_t capa;
 	pid_t pid;
+	VALUE io;
 	struct raindrop *drops;
 };
 
+/* called by GC */
+static void rd_mark(void *ptr)
+{
+	struct raindrops *r = ptr;
+	rb_gc_mark(r->io);
+}
+
 /* called by GC */
 static void rd_free(void *ptr)
 {
@@ -60,7 +69,7 @@ static size_t rd_memsize(const void *ptr)
 
 static const rb_data_type_t rd_type = {
 	"raindrops",
-	{ NULL, rd_free, rd_memsize, /* reserved */ },
+	{ rd_mark, rd_free, rd_memsize, /* reserved */ },
 	/* parent, data, [ flags ] */
 };
 
@@ -87,16 +96,10 @@ static struct raindrops *get(VALUE self)
 }
 
 /*
- * call-seq:
- *	Raindrops.new(size)	-> raindrops object
- *
- * Initializes a Raindrops object to hold +size+ counters.  +size+ is
- * only a hint and the actual number of counters the object has is
- * dependent on the CPU model, number of cores, and page size of
- * the machine.  The actual size of the object will always be equal
- * or greater than the specified +size+.
+ * This is the _actual_ implementation of #initialize - the Ruby wrapper
+ * handles keyword-argument handling then calls this method.
  */
-static VALUE init(VALUE self, VALUE size)
+static VALUE init_cimpl(VALUE self, VALUE size, VALUE io, VALUE zero)
 {
 	struct raindrops *r = DATA_PTR(self);
 	int tries = 1;
@@ -113,9 +116,19 @@ static VALUE init(VALUE self, VALUE size)
 	r->capa = tmp / raindrop_size;
 	assert(PAGE_ALIGN(raindrop_size * r->capa) == tmp && "not aligned");
 
+	r->io = io;
+
 retry:
-	r->drops = mmap(NULL, tmp,
-	                PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
+	if (RTEST(r->io)) {
+		int fd = NUM2INT(rb_funcall(r->io, rb_intern("fileno"), 0));
+		rb_funcall(r->io, rb_intern("truncate"), 1, SIZET2NUM(tmp));
+		r->drops = mmap(NULL, tmp,
+				PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+	} else {
+		r->drops = mmap(NULL, tmp,
+				PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED,
+				-1, 0);
+	}
 	if (r->drops == MAP_FAILED) {
 		int err = errno;
 
@@ -127,6 +140,9 @@ retry:
 	}
 	r->pid = getpid();
 
+	if (RTEST(zero))
+		memset(r->drops, 0, tmp);
+
 	return self;
 }
 
@@ -217,14 +233,16 @@ static VALUE capa(VALUE self)
  * call-seq:
  *	rd.dup		-> rd_copy
  *
- * Duplicates and snapshots the current state of a Raindrops object.
+ * Duplicates and snapshots the current state of a Raindrops object. Even
+ * if the given Raindrops object is backed by a file, the copy will be backed
+ * by independent, anonymously mapped memory.
  */
 static VALUE init_copy(VALUE dest, VALUE source)
 {
 	struct raindrops *dst = DATA_PTR(dest);
 	struct raindrops *src = get(source);
 
-	init(dest, SIZET2NUM(src->size));
+	init_cimpl(dest, SIZET2NUM(src->size), Qnil, Qfalse);
 	memcpy(dst->drops, src->drops, raindrop_size * src->size);
 
 	return dest;
@@ -375,6 +393,20 @@ static VALUE evaporate_bang(VALUE self)
 	return Qnil;
 }
 
+/*
+ * call-seq:
+ * 	to_io	-> IO
+ *
+ * Returns the IO object backing the memory for this raindrop, if
+ * one was specified when constructing this Raindrop. If this
+ * Raindrop is backed by anonymous memory, this method returns nil.
+ */
+static VALUE to_io(VALUE self)
+{
+	struct raindrops *r = get(self);
+	return r->io;
+}
+
 void Init_raindrops_ext(void)
 {
 	VALUE cRaindrops = rb_define_class("Raindrops", rb_cObject);
@@ -433,7 +465,7 @@ void Init_raindrops_ext(void)
 
 	rb_define_alloc_func(cRaindrops, alloc);
 
-	rb_define_method(cRaindrops, "initialize", init, 1);
+	rb_define_private_method(cRaindrops, "initialize_cimpl", init_cimpl, 3);
 	rb_define_method(cRaindrops, "incr", incr, -1);
 	rb_define_method(cRaindrops, "decr", decr, -1);
 	rb_define_method(cRaindrops, "to_ary", to_ary, 0);
@@ -444,6 +476,7 @@ void Init_raindrops_ext(void)
 	rb_define_method(cRaindrops, "capa", capa, 0);
 	rb_define_method(cRaindrops, "initialize_copy", init_copy, 1);
 	rb_define_method(cRaindrops, "evaporate!", evaporate_bang, 0);
+	rb_define_method(cRaindrops, "to_io", to_io, 0);
 
 #ifdef __linux__
 	Init_raindrops_linux_inet_diag();

data/lib/raindrops.rb

@@ -36,6 +36,30 @@ class Raindrops
     def total
       active + queued
     end
+  end unless defined? ListenStats
+
+  # call-seq:
+  #	Raindrops.new(size, io: nil)	-> raindrops object
+  #
+  # Initializes a Raindrops object to hold +size+ counters.  +size+ is
+  # only a hint and the actual number of counters the object has is
+  # dependent on the CPU model, number of cores, and page size of
+  # the machine.  The actual size of the object will always be equal
+  # or greater than the specified +size+.
+  # If +io+ is provided, then the Raindrops memory will be backed by
+  # the specified file; otherwise, it will allocate anonymous memory.
+  # The IO object must respond to +truncate+, as this is used to set
+  # the size of the file.
+  # If +zero+ is provided, then the memory region is zeroed prior to
+  # returning. This is only meaningful if +io+ is also provided; in
+  # that case it controls whether any existing counter values in +io+
+  # are retained (false) or whether it is entirely zeroed (true).
+  def initialize(size, io: nil, zero: false)
+    # This ruby wrapper exists to handle the keyword-argument handling,
+    # which is otherwise kind of awkward in C. We delegate the keyword
+    # arguments to the _actual_ initialize implementation as positional
+    # args.
+    initialize_cimpl(size, io, zero)
   end
 
   autoload :Linux, 'raindrops/linux'

data/test/test_raindrops.rb

@@ -1,6 +1,7 @@
 # -*- encoding: binary -*-
 require 'test/unit'
 require 'raindrops'
+require 'tempfile'
 
 class TestRaindrops < Test::Unit::TestCase
 
@@ -162,4 +163,45 @@ class TestRaindrops < Test::Unit::TestCase
     assert status.success?
     assert_equal [ 1, 2 ], tmp.to_ary
   end
+
+  def test_io_backed
+    file = Tempfile.new('test_io_backed')
+    rd = Raindrops.new(4, io: file, zero: true)
+    rd[0] = 123
+    rd[1] = 456
+
+    assert_equal 123, rd[0]
+    assert_equal 456, rd[1]
+
+    rd.evaporate!
+
+    file.rewind
+    data = file.read
+    assert_equal 123, data.unpack('L!')[0]
+    assert_equal 456, data[Raindrops::SIZE..data.size].unpack('L!')[0]
+  end
+
+  def test_io_backed_reuse
+    file = Tempfile.new('test_io_backed')
+    rd = Raindrops.new(4, io: file, zero: true)
+    rd[0] = 123
+    rd[1] = 456
+    rd.evaporate!
+
+    rd = Raindrops.new(4, io: file, zero: false)
+    assert_equal 123, rd[0]
+    assert_equal 456, rd[1]
+  end
+
+  def test_iobacked_noreuse
+    file = Tempfile.new('test_io_backed')
+    rd = Raindrops.new(4, io: file, zero: true)
+    rd[0] = 123
+    rd[1] = 456
+    rd.evaporate!
+
+    rd = Raindrops.new(4, io: file, zero: true)
+    assert_equal 0, rd[0]
+    assert_equal 0, rd[1]
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raindrops
 version: !ruby/object:Gem::Version
-  version: 0.19.2
+  version: 0.20.0
 platform: ruby
 authors:
 - raindrops hackers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-25 00:00:00.000000000 Z
+date: 2021-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aggregate