ioplus 0.0.1.PROTOTYPE

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6242bf07dabdee5e581a67b3fe6139deb291b924
+  data.tar.gz: 569d32580f365d037f8e4bb7342b1b1a1963b13c
+SHA512:
+  metadata.gz: e655c0bea9f742c59c432982470e89618c0fd2a81128c3d72617d473c47681fd96b7e8fadea0995e12267004ce6dafb731a520ae6f1fd223a00fdf63eb5b8376
+  data.tar.gz: 145738e030b55c8838b2a7ba460e3ffa04f4e8d5df9c5c38fb14dc9ea3a931428bc6cce2ccaea43b1e3e48be3e48091c2bdd3271ff237e4f591867d8633184a9

data/LICENSE.md

@@ -0,0 +1,35 @@
+# ioplus License (2-clause BSD License)
+
+----
+
+Copyright (c) 2015, dearblue
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+----
+
+In Japanese.
+
+日本語訳については次のページが参考になるでしょう:
+http://www.freebsd.org/ja/copyright/freebsd-license.html

data/README.ja.md

@@ -0,0 +1,20 @@
+# ioplus - IO 拡張モジュール
+
+このライブラリは IO クラスを拡張させるモジュールが含まれています。
+
+*   非同期読み込みメソッド - ``IO#aio_read`` / ``IO#aread`` <- ``IOPlus::IO#aio_read``
+*   非同期書き込みメソッド - ``IO#aio_write`` / ``IO#awrite`` <- ``IOPlus::IO#aio_write``
+
+これらのメソッドは ``aio_read(2)`` と ``aio_write(2)`` に似た機能を提供します。
+
+***このライブラリはセーフレベルを考慮しないため、セキュリティリスクがあります。信頼できない外部データを取り扱う環境では、このライブラリを読み込まないで下さい。***
+
+## 注意点
+
+*   FreeBSD 上では ``aio.ko`` がカーネルに読み込まれている必要があります。
+
+    ``/boot/loader.conf`` に ``aio_load="YES"`` を追加するか、実行前に ``kldload aio`` を行って下さい。
+
+*   ``IO#read`` / ``IO#write`` を経由するメソッドとの使用は不可解な動作の原因となります。
+
+    必要であれば ``IO#sysread`` / ``IO#syswrite`` などのメソッドを用いて下さい。

data/README.md

@@ -0,0 +1,24 @@
+# ioplus - IO 拡張モジュール
+
+This library is included a module for IO class extension.
+
+These methods are provide similar functions as ``pread(2)``, ``pwrite(2)``, ``aio_read(2)`` and ``aio_write(2)``.
+
+***This library has a security risk, because it is not consideration for the safe-level.***
+
+## Required kernel object on FreeBSD
+
+``aio.ko`` is required for asynchronouse I/O operation on FreeBSD.
+
+Execute ruby script before try following:
+
+```shell:shell
+# echo 'aio_load="YES"' >> /boot/loader.conf
+# shutdown -r now
+```
+
+OR
+
+```shell:shell
+# kldload aio
+```

data/Rakefile

@@ -0,0 +1,143 @@
+
+require "rake/clean"
+
+DOC = FileList["{README,LICENSE,CHANGELOG,Changelog,HISTORY}{,.ja}{,.txt,.rd,.rdoc,.md,.markdown}"] +
+      FileList["ext/**/{README,LICENSE,CHANGELOG,Changelog,HISTORY}{,.ja}{,.txt,.rd,.rdoc,.md,.markdown}"]
+#EXT = FileList["ext/**/*.{h,hh,c,cc,cpp,cxx}"] +
+#      FileList["ext/externals/**/*"]
+EXT = FileList["ext/**/*"]
+BIN = FileList["bin/*"]
+LIB = FileList["lib/**/*.rb"]
+SPEC = FileList["spec/**/*"]
+EXAMPLE = FileList["examples/**/*"]
+RAKEFILE = [File.basename(__FILE__), "gemstub.rb"]
+EXTRA = []
+
+load "gemstub.rb"
+
+EXTCONF = FileList["ext/extconf.rb"]
+EXTCONF.reject! { |n| !File.file?(n) }
+GEMSTUB.extensions += EXTCONF
+GEMSTUB.executables += FileList["bin/*"].map { |n| File.basename n }
+GEMSTUB.executables.sort!
+
+GEMFILE = "#{GEMSTUB.name}-#{GEMSTUB.version}.gem"
+GEMSPEC = "#{GEMSTUB.name}.gemspec"
+
+GEMSTUB.files += DOC + EXT + EXTCONF + BIN + LIB + SPEC + EXAMPLE + RAKEFILE + EXTRA
+GEMSTUB.files.sort!
+GEMSTUB.rdoc_options ||= %w(--charset UTF-8)
+GEMSTUB.extra_rdoc_files += DOC + LIB + EXT.reject { |n| n.include?("/externals/") || !%w(.h .hh .c .cc .cpp .cxx).include?(File.extname(n)) }
+GEMSTUB.extra_rdoc_files.sort!
+
+CLEAN << GEMSPEC
+CLOBBER << GEMFILE
+
+task :default => :all
+
+
+unless EXTCONF.empty?
+  RUBYSET ||= (ENV["RUBYSET"] || "").split(",")
+
+  if RUBYSET.nil? || RUBYSET.empty?
+    $stderr.puts <<-EOS
+#{__FILE__}:
+|
+| If you want binary gem package, launch rake with ``RUBYSET`` enviroment
+| variable for set ruby interpreters by comma separated.
+|
+|   e.g.) $ rake RUBYSET=ruby
+|     or) $ rake RUBYSET=ruby20,ruby21,ruby22
+|
+    EOS
+  else
+    platforms = RUBYSET.map { |ruby| `#{ruby} --disable gems -rrbconfig -e "puts RbConfig::CONFIG['arch']"`.chomp }
+    platforms1 = platforms.uniq
+    unless platforms1.size == 1 && !platforms1[0].empty?
+      raise "different platforms (#{Hash[*RUBYSET.zip(platforms).flatten].inspect})"
+    end
+    PLATFORM = platforms1[0]
+
+    RUBY_VERSIONS = RUBYSET.map do |ruby|
+      ver = `#{ruby} --disable gem -rrbconfig -e "puts RbConfig::CONFIG['ruby_version']"`.slice(/\d+\.\d+/)
+      raise "failed ruby checking - ``#{ruby}''" unless $?.success?
+      [ver, ruby]
+    end
+    SOFILES_SET = RUBY_VERSIONS.map { |(ver, ruby)| ["lib/#{ver}/#{GEMSTUB.name}.so", ruby] }
+    SOFILES = SOFILES_SET.map { |(lib, ruby)| lib }
+
+    GEMSTUB_NATIVE = GEMSTUB.dup
+    GEMSTUB_NATIVE.files += SOFILES
+    GEMSTUB_NATIVE.platform = Gem::Platform.new(PLATFORM).to_s
+    GEMSTUB_NATIVE.extensions.clear
+    GEMFILE_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.version}-#{GEMSTUB_NATIVE.platform}.gem"
+    GEMSPEC_NATIVE = "#{GEMSTUB_NATIVE.name}-#{GEMSTUB_NATIVE.platform}.gemspec"
+
+    task :all => ["native-gem", GEMFILE]
+
+    desc "build binary gem package"
+    task "native-gem" => GEMFILE_NATIVE
+
+    desc "generate binary gemspec"
+    task "native-gemspec" => GEMSPEC_NATIVE
+
+    file GEMFILE_NATIVE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + EXAMPLE + SOFILES + RAKEFILE + [GEMSPEC_NATIVE] do
+      sh "gem build #{GEMSPEC_NATIVE}"
+    end
+
+    file GEMSPEC_NATIVE => __FILE__ do
+      File.write(GEMSPEC_NATIVE, GEMSTUB_NATIVE.to_ruby, mode: "wb")
+    end
+
+    SOFILES_SET.each do |(soname, ruby)|
+      sodir = File.dirname(soname)
+      makefile = File.join(sodir, "Makefile")
+
+      CLEAN << GEMSPEC_NATIVE << sodir
+      CLOBBER << GEMFILE_NATIVE
+
+      directory sodir
+
+      desc "generate Makefile for binary extension library"
+      file makefile => [sodir] + EXTCONF do
+        cd sodir do
+          sh "#{ruby} ../../#{EXTCONF[0]} \"--ruby=#{ruby}\""
+        end
+      end
+
+      desc "build binary extension library"
+      file soname => [makefile] + EXT do
+        cd sodir do
+          sh "make"
+        end
+      end
+    end
+  end
+end
+
+
+task :all => GEMFILE
+
+desc "generate local rdoc"
+task :rdoc => DOC + EXT + LIB do
+  sh *(%w(rdoc) + GEMSTUB.rdoc_options + DOC + EXT + LIB)
+end
+
+desc "launch rspec"
+task rspec: :all do
+  sh "rspec"
+end
+
+desc "build gem package"
+task gem: GEMFILE
+
+desc "generate gemspec"
+task gemspec: GEMSPEC
+
+file GEMFILE => DOC + EXT + EXTCONF + BIN + LIB + SPEC + EXAMPLE + RAKEFILE + [GEMSPEC] do
+  sh "gem build #{GEMSPEC}"
+end
+
+file GEMSPEC => RAKEFILE do
+  File.write(GEMSPEC, GEMSTUB.to_ruby, mode: "wb")
+end

data/examples/aio_read.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+#vim: set fileencoding:utf-8
+
+require "pp"
+require "ioplus"
+
+file = ARGV[0] || "/usr/bin/cc"
+
+puts "read file: #{file}"
+
+File.open(file, "rb") do |f|
+  aio = []
+  aio << f.aio_read(0, 500, b = "".b) { |x| puts "<aio done! offset #{x.offset} +#{x.status}>\n" }
+  aio << f.aio_read(rand(1000000), 1000) { |x| puts "<aio done! offset #{x.offset} +#{x.status}>\n" }
+  aio << f.aio_read(rand(1000000), 100) { |x| puts "<aio done! offset #{x.offset} +#{x.status}>\n" }
+  aio << f.aio_read(rand(1000000), 200) { |x| puts "<aio done! offset #{x.offset} +#{x.status}>\n" }
+  aio << f.aio_read(0, 300, "a".b) { |x| puts "<aio done! offset #{x.offset} +#{x.status}>\n" }
+  p aio[1].cancel rescue nil
+  pp aio
+  IO.aio_suspend(*aio)
+  p b
+  pp aio
+end
+
+GC.start
+
+puts "<finished main thread and 1 sec sleeping>\n"
+sleep 1

data/ext/extconf.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+#vim: set fileencoding:utf-8
+
+require "mkmf"
+
+srcdirpat = File.dirname(__FILE__).gsub(/[\[\{\},]/, "[\\0]")
+$srcs = Dir.glob(File.join(srcdirpat, "*.{c,cc}"))
+vpath = []
+
+case
+when have_header("aio.h")
+  if have_func("kevent", %w(sys/types.h sys/event.h sys/time.h))
+    $defs << " -DEXTIO_HAVE_KEVENT=1"
+  else
+    $stderr.puts <<EOS
+|
+| #{__FILE__}:#{__LINE__}: NOT SUPPORTED PLATFORM.
+|
+EOS
+    exit 1
+  end
+  $srcs += Dir.glob(File.join(srcdirpat, "posix/*.c"))
+  vpath << "$(srcdir)/posix"
+  $defs << " -DEXTIO_WITH_POSIX=1"
+#when have_header("windows.h")
+#  $srcs += Dir.glob(File.join(srcdirpat, "win32/*.c"))
+#  vpath << "$(srcdir)/win32"
+#  $defs << " -DEXTIO_WITH_WIN32=1"
+else
+  $stderr.puts <<EOS
+|
+| #{__FILE__}:#{__LINE__}: NOT SUPPORTED PLATFORM.
+|
+EOS
+  exit 1
+end
+
+create_makefile "ioplus" or exit 1

data/ext/extio.c

@@ -0,0 +1,865 @@
+#include <ruby.h>
+#include <ruby/io.h>
+#include <ruby/thread.h>
+#include <errno.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#if EXTIO_WITH_WIN32
+#   include <windows.h>
+#elif EXTIO_WITH_POSIX
+#   include <aio.h>
+#   if EXTIO_HAVE_KEVENT
+#       include <sys/types.h>
+#       include <sys/event.h>
+#       include <sys/time.h>
+#   endif
+#endif
+
+enum {
+    EXTAIO_READ = 0x00,
+    EXTAIO_WRITE = 0x01,
+};
+
+struct extaio
+{
+    aiocb_t aio;
+    VALUE self;
+    VALUE notify_block;
+    VALUE file;
+    VALUE buffer;
+    VALUE status; /* converted value of aio_return */
+    uint64_t offset;
+    int operation; /* EXTAIO_READ, EXTAIO_WRITE */
+#if EXTIO_HAVE_KEVENT
+    struct kevent kev;
+#else
+    struct extaio *next;
+#endif
+};
+
+static pthread_mutex_t extaio_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t extaio_cond = PTHREAD_COND_INITIALIZER;
+
+#if EXTIO_HAVE_KEVENT
+static int extaio_kqueue;
+#else
+static struct extaio *extaio_queue, *extaio_queue_tail;
+#endif
+
+static VALUE mIOPlus, mIO, mIOClass, cAIO;
+static VALUE extio_lives;
+static ID IDto_time;
+
+static inline struct timespec
+aux_conv_to_timespec(VALUE time)
+{
+    struct timespec ts = { 0, 0 };
+
+    switch (TYPE(time)) {
+    case RUBY_T_FIXNUM:
+    case RUBY_T_BIGNUM:
+        ts.tv_sec = NUM2LL(time);
+        return ts;
+    case RUBY_T_FLOAT:
+        ts.tv_sec = NUM2LL(time);
+        ts.tv_nsec = (int64_t)(NUM2DBL(time) * 1000000000) % 1000000000;
+        return ts;
+    default:
+        if (rb_obj_is_kind_of(time, rb_cTime)) {
+            return rb_time_timespec(time);
+        } else if (rb_respond_to(time, IDto_time)) {
+            time = rb_funcall(time, IDto_time, 0);
+            if (rb_obj_is_kind_of(time, rb_cTime)) {
+                return rb_time_timespec(time);
+            } else {
+                rb_raise(rb_eTypeError,
+                         "not convert to time object by ``to_time''");
+            }
+        } else {
+            time = rb_Float(time);
+            ts.tv_sec = NUM2LL(time);
+            ts.tv_nsec = (int64_t)(NUM2DBL(time) * 1000000000) % 1000000000;
+            return ts;
+        }
+    }
+}
+
+static inline int
+ext_io_getfd(VALUE file)
+{
+    struct rb_io_t *fp;
+    GetOpenFile(file, fp);
+    return fp->fd;
+}
+
+static inline ssize_t
+ext_getiosize(int d)
+{
+    struct stat s;
+    if (fstat(d, &s) == 0) {
+        return s.st_size;
+    } else {
+        return -1;
+    }
+}
+
+static inline struct extaio *
+extaio_refp(VALUE aio)
+{
+    struct extaio *p;
+    Data_Get_Struct(aio, struct extaio, p);
+    return p;
+}
+
+static inline struct extaio *
+extaio_ref(VALUE aio)
+{
+    struct extaio *p = extaio_refp(aio);
+    if (!p) {
+        VALUE v = rb_inspect(aio);
+        rb_raise(rb_eRuntimeError,
+                 "invalid reference - %s",
+                 StringValueCStr(v));
+    }
+    return p;
+}
+
+#if !EXTIO_HAVE_KEVENT
+static void
+extaio_read_notify(union sigval sv)
+{
+    /* NOT RUBY MANAGED THREAD! */
+
+    struct extaio *p = sv.sival_ptr;
+
+    pthread_mutex_lock(&extaio_mutex);
+    if (extaio_queue) {
+        extaio_queue_tail = extaio_queue_tail->next = p;
+    } else {
+        extaio_queue_tail = extaio_queue = p;
+    }
+    pthread_cond_signal(&extaio_cond);
+    pthread_mutex_unlock(&extaio_mutex);
+}
+#endif
+
+static void
+extaio_gcmark(struct extaio *p)
+{
+    if (p) {
+        rb_gc_mark(p->self);
+        rb_gc_mark(p->notify_block);
+        rb_gc_mark(p->file);
+        rb_gc_mark(p->buffer);
+        rb_gc_mark(p->status);
+    }
+}
+
+static void
+extaio_free(struct extaio *p)
+{
+    if (p) {
+        aio_cancel(ext_io_getfd(p->file), &p->aio);
+        const struct aiocb *pp = &p->aio;
+        aio_suspend(&pp, 1, NULL); /* FIXME: GC 中に無限待機の可能性あり? */
+        free(p);
+    }
+}
+
+static inline struct extaio *
+extaio_new(int operation, VALUE file, rb_io_t *fp, uint64_t offset, VALUE buf, uint64_t size)
+{
+    struct extaio *p;
+    VALUE objaio = Data_Make_Struct(cAIO, struct extaio, extaio_gcmark, extaio_free, p);
+    rb_str_locktmp(buf);
+    p->aio.aio_offset   = offset;
+    p->aio.aio_buf      = RSTRING_PTR(buf);
+    p->aio.aio_nbytes   = size;
+    p->aio.aio_reqprio  = 0;
+
+#if EXTIO_HAVE_KEVENT
+    p->aio.aio_sigevent.sigev_notify            = SIGEV_KEVENT;
+    p->aio.aio_sigevent.sigev_notify_kqueue     = extaio_kqueue;
+    p->aio.aio_sigevent.sigev_notify_kevent_flags = EV_ONESHOT;
+#else
+    p->aio.aio_sigevent.sigev_notify            = SIGEV_THREAD;
+    p->aio.aio_sigevent.sigev_notify_function   = extaio_read_notify;
+    p->aio.aio_sigevent.sigev_notify_attributes = NULL;
+#endif
+
+    p->aio.aio_fildes = fp->fd;
+    p->aio.aio_sigevent.sigev_value.sival_ptr = p;
+
+    p->notify_block = rb_block_given_p() ? rb_block_proc() : Qnil;
+    p->operation = operation;
+    p->self = objaio;
+    p->file = file;
+    p->buffer = buf;
+    p->status = Qnil;
+    p->offset = offset;
+
+#if EXTIO_HAVE_KEVENT
+    //EV_SET(&p->kev, fp->fd, EVFILT_AIO, EV_ADD, 0, 0, NULL);
+    //kevent(extaio_kqueue, &p->kev, 1, NULL, 0, NULL);
+#else
+#   error IMPLEMENT ME!
+#endif
+
+    return p;
+}
+
+static void
+extio_aio_read_scanargs(int argc, VALUE argv[], int d, off_t *offset, size_t *size, VALUE *buf)
+{
+    switch (argc) {
+    case 1:
+        *offset = NUM2OFFT(argv[0]);
+        // TODO: エラーの場合 (size_t)-1 が返ってくるけれど、メモリ要求でパンクする
+        // TODO: これではエラーメッセージがわかりにくいからどうにかする
+        *size = ext_getiosize(d);
+        *buf = rb_str_buf_new(*size);
+        break;
+    case 2:
+        *offset = NUM2OFFT(argv[0]);
+        *size = NUM2SIZET(argv[1]);
+        *buf = rb_str_buf_new(*size);
+        break;
+    case 3:
+        *offset = NUM2OFFT(argv[0]);
+        *size = NUM2SIZET(argv[1]);
+        *buf = argv[2];
+        break;
+    default:
+        rb_error_arity(argc, 1, 3);
+        break;
+    }
+
+    rb_check_type(*buf, RUBY_T_STRING);
+    if (OBJ_FROZEN(*buf)) {
+        rb_raise(rb_eTypeError, 
+                 "wrong immutable object for ``buffer''");
+    }
+    rb_str_resize(*buf, *size);
+    rb_str_set_len(*buf, 0);
+}
+
+/*
+ * call-seq:
+ *  aio_read(offset) -> aio_object
+ *  aio_read(offset) { |aio_obj| ... } -> aio_object
+ *  aio_read(offset, size, buf = nil) -> aio_object
+ *  aio_read(offset, size, buf = nil) { |aio_obj| ... } -> aio_object
+ *
+ * I/O オブジェクトに対して非同期読み込みを行います。
+ *
+ * システムに対して読み込み要求を出すだけなので、すぐに制御が戻ります。
+ *
+ * この時の戻り値は、読み込み要求の状態を保持するオブジェクトです。
+ *
+ * このオブジェクトを用いて待機する、処理の完了状態を取得するなどを行うことが出来ます。
+ *
+ * ブロックを指定した場合、読み込みが完了した時に評価されます。
+ *
+ * ブロック引数と戻り値は同じオブジェクトです。
+ *
+ * ioplus ライブラリの実装上の問題として aio_read(2) システムコールよりも大きな遅延があります。
+ *
+ * 数ミリ秒単位の遅延すら許容できないアプリケーションでは使い物にならないことに注意して下さい。
+ *
+ * また、aio_read を呼んだスレッドとは異なるスレッドがブロックを評価します。
+ *
+ * [RETURN]
+ *  IOPlus::AIO インスタンスです。
+ *
+ * [YIELD aio_obj]
+ *  IOPlus::AIO インスタンスです。
+ */
+static VALUE
+extio_aio_read(int argc, VALUE argv[], VALUE file)
+{
+    rb_check_type(file, RUBY_T_FILE);
+    struct rb_io_t *fp;
+    GetOpenFile(file, fp);
+
+    off_t offset;
+    size_t size;
+    VALUE buf;
+    extio_aio_read_scanargs(argc, argv, fp->fd, &offset, &size, &buf);
+
+    struct extaio *p = extaio_new(EXTAIO_READ, file, fp, offset, buf, size);
+
+    if (aio_read(&p->aio) != 0) {
+        DATA_PTR(p->self) = NULL;
+        free(p);
+        VALUE v = rb_inspect(file);
+        rb_sys_fail_str(v);
+    }
+
+    rb_ary_push(extio_lives, p->self);
+
+    return p->self;
+}
+
+static VALUE
+extio_aio_write(VALUE file, VALUE off, VALUE buf)
+{
+    rb_check_type(file, RUBY_T_FILE);
+    struct rb_io_t *fp;
+    GetOpenFile(file, fp);
+
+    off_t offset = NUM2OFFT(off);
+    rb_check_type(buf, RUBY_T_STRING);
+    size_t size = RSTRING_LEN(buf);
+
+    struct extaio *p = extaio_new(EXTAIO_WRITE, file, fp, offset, buf, size);
+
+    if (aio_write(&p->aio) != 0) {
+        DATA_PTR(p->self) = NULL;
+        free(p);
+        VALUE v = rb_inspect(file);
+        rb_sys_fail_str(v);
+    }
+
+    rb_ary_push(extio_lives, p->self);
+
+    return p->self;
+}
+
+/*
+ * このファイルに関するすべての非同期処理の取り消しをシステムに要求します。
+ *
+ * 常に取り消されるわけではないことに注意してください。
+ */
+static VALUE
+extio_aio_cancel(VALUE file)
+{
+    int fd = ext_io_getfd(file);
+    int status = aio_cancel(fd, NULL);
+    switch (status) {
+    case AIO_CANCELED:
+        return ID2SYM(rb_intern("canceled"));
+    case AIO_NOTCANCELED:
+        return ID2SYM(rb_intern("notcanceled"));
+    case AIO_ALLDONE:
+        return ID2SYM(rb_intern("alldone"));
+    case -1:
+        rb_sys_fail_str(rb_inspect(file));
+    default:
+        return rb_sprintf("unknown-status:0x%02x", status);
+    }
+}
+
+static VALUE
+extaio_validate(VALUE aio)
+{
+    if (extaio_refp(aio)) {
+        return aio;
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+extaio_file(VALUE aio)
+{
+    return extaio_ref(aio)->file;
+}
+
+static inline VALUE
+ext_aio_operation_inspect(struct extaio *p)
+{
+    int operation = p->operation;
+    switch (operation) {
+    case EXTAIO_READ:
+        return ID2SYM(rb_intern("read"));
+    case EXTAIO_WRITE:
+        return ID2SYM(rb_intern("write"));
+    default:
+        return rb_sprintf("unknown:0x%02x", operation);
+    }
+}
+
+static VALUE
+extaio_operation(VALUE aio)
+{
+    return ext_aio_operation_inspect(extaio_ref(aio));
+}
+
+static VALUE
+extaio_buffer(VALUE aio)
+{
+    return extaio_ref(aio)->buffer;
+}
+
+static VALUE
+extaio_offset(VALUE aio)
+{
+    return ULL2NUM(extaio_ref(aio)->offset);
+}
+
+static VALUE
+extaio_to_s(VALUE aio)
+{
+    return rb_sprintf("%s:%p", rb_obj_classname(aio), (void *)aio);
+}
+
+static VALUE
+extaio_inspect(VALUE aio)
+{
+    struct extaio *p = extaio_refp(aio);
+    if (!p) {
+        return rb_sprintf("#<%s:%p **INVALID-REFERENCE**>",
+                          rb_obj_classname(aio), (void *)aio);
+    } else {
+        VALUE ioobj = rb_inspect(p->file);
+        int bufsize = RSTRING_LEN(p->buffer);
+        VALUE retval = rb_inspect(p->status);
+        VALUE operation = rb_String(ext_aio_operation_inspect(p));
+        return rb_sprintf("#<%s:%p %s %s offset=%d buffer.bytesize=%d return=%s>",
+                          rb_obj_classname(aio), (void *)aio,
+                          StringValueCStr(operation), StringValueCStr(ioobj),
+                          (int)p->offset, bufsize, StringValueCStr(retval));
+    }
+}
+
+struct extaio_suspend_wait_args
+{
+    struct extaio *aio;
+    int64_t timeout;
+};
+
+enum {
+    EXTAIO_POLLING_INTERVAL_NSEC = 100 * 1000 * 1000,
+    EXTAIO_POLLING_INTERVAL_INFINITY = -1ll,
+    EXTAIO_DONE = 0,
+    EXTAIO_TIMEDOUT = 1,
+    EXTAIO_ERROR = -1,
+};
+
+enum {
+    EXT_1SEC_TO_NSEC = 1 * 1000 * 1000 * 1000,
+};
+
+static int
+extaio_suspend_wait_ungvl(struct extaio_suspend_wait_args *args)
+{
+    /*
+     * aio_suspend を中断するにはシグナルを必要とするが、ruby と
+     * 適合するかどうかわからないためポーリング処理する。
+     * このため、指定された timeout よりも大きな待機時間となる。
+     * 現時点では 100 ms 単位で行う。
+     */
+    struct timespec timeout = { 0, EXTAIO_POLLING_INTERVAL_NSEC };
+    int64_t timerest = args->timeout;
+    VALUE thcur = rb_thread_current();
+
+    for (;;) {
+        if (timerest >= 0 && timerest < EXTAIO_POLLING_INTERVAL_NSEC) {
+            timeout.tv_sec = 0;
+            timeout.tv_nsec = timerest;
+        }
+        int state = aio_suspend((const struct aiocb *const *)&args->aio->aio, 1, &timeout);
+        if (rb_thread_interrupted(thcur)) { return EXTAIO_ERROR; }
+        if (state == 0) { break; }
+        if (state == -1) {
+            switch (errno) {
+            case EAGAIN:
+                if (timerest >= 0 && timerest <= EXTAIO_POLLING_INTERVAL_NSEC) {
+                    return EXTAIO_TIMEDOUT;
+                } else {
+                    timerest -= EXTAIO_POLLING_INTERVAL_NSEC;
+                    continue;
+                }
+            //case EINVAL:
+            //case EINTR:
+            //case ENOSYS:
+            default:
+                return EXTAIO_ERROR;
+            }
+        }
+    }
+
+    /*
+     * 非同期 I/O 要求が正常完了して aio_suspend から戻ってきたが、
+     * ruby 側の処理が完了していないかもしれないため待機する。
+     */
+
+    int status = EXTAIO_DONE;
+
+    timeout.tv_sec = 0;
+    timeout.tv_nsec = EXTAIO_POLLING_INTERVAL_NSEC;
+
+    if (pthread_mutex_lock(&extaio_mutex) == 0) {
+        while (NIL_P(args->aio->status)) {
+            if (timerest >= 0 && timerest <= EXTAIO_POLLING_INTERVAL_NSEC) {
+                timeout.tv_nsec = timerest;
+            }
+
+            if (rb_thread_interrupted(thcur)) {
+                status = EXTAIO_ERROR;
+                break;
+            }
+            int s = pthread_cond_timedwait(&extaio_cond, &extaio_mutex, &timeout);
+            if (s == 0) {
+                break;
+            } else if (s == ETIMEDOUT) {
+                if (timerest <= EXTAIO_POLLING_INTERVAL_NSEC) {
+                    status = EXTAIO_TIMEDOUT;
+                    break;
+                }
+                timerest -= EXTAIO_POLLING_INTERVAL_NSEC;
+            } else if (s == EINTR) {
+                status = EXTAIO_ERROR;
+                errno = s;
+                break;
+            } else {
+                /* TODO: 仕様の上ではなさそうだけれども、どうするべきか考えておこう */
+                status = EXTAIO_ERROR;
+                break;
+            }
+        }
+        pthread_mutex_unlock(&extaio_mutex);
+    }
+
+    return status;
+}
+
+static inline VALUE
+extaio_suspend_wait(struct extaio *aio, int64_t timeout_nsec)
+{
+    if (!NIL_P(aio->status)) {
+        // すでに完了しているため待機の必要はない
+        return aio->self;
+    }
+
+    struct extaio_suspend_wait_args args = {
+        .aio = aio,
+        .timeout = timeout_nsec,
+    };
+    int s = (int)rb_thread_call_without_gvl((void *(*)(void *))extaio_suspend_wait_ungvl,
+                                            &args, RUBY_UBF_PROCESS, NULL);
+
+    if (s == 0) {
+        return aio->self;
+    } else if (s == EXTAIO_TIMEDOUT) {
+        return Qnil;
+    } else if (s == EXTAIO_ERROR) {
+        VALUE v = rb_inspect(aio->self);
+        rb_sys_fail_str(v);
+    } else {
+        rb_bug("%s:%d:%s: extaio_suspend_wait_ungvl returned not handled code (0x%04x)",
+               __FILE__, __LINE__, __func__, s);
+    }
+}
+
+/*
+ * call-seq:
+ *  suspend(timeout = nil) -> self or nil
+ */
+static VALUE
+extaio_suspend(int argc, VALUE argv[], VALUE aio)
+{
+    VALUE timeout;
+    switch (argc) {
+    case 0:
+        timeout = Qnil;
+        break;
+    case 1:
+        timeout = argv[0];
+        break;
+    default:
+        rb_error_arity(argc, 0, 1);
+        timeout = Qnil; /* clear warnings for compiler */
+    }
+
+    if (NIL_P(timeout)) {
+        return extaio_suspend_wait(extaio_ref(aio), EXTAIO_POLLING_INTERVAL_INFINITY);
+    } else {
+        struct timespec time = aux_conv_to_timespec(timeout);
+        int64_t t = time.tv_sec * EXT_1SEC_TO_NSEC + time.tv_nsec;
+        if (t / EXT_1SEC_TO_NSEC != time.tv_sec) {
+            t = EXTAIO_POLLING_INTERVAL_INFINITY;
+        }
+        return extaio_suspend_wait(extaio_ref(aio), t);
+    }
+}
+
+static VALUE
+extaio_fsync(VALUE aio)
+{
+    struct extaio *p = extaio_ref(aio);
+    if (aio_fsync(O_SYNC, &p->aio) != 0) {
+        VALUE v = rb_inspect(p->file);
+        rb_sys_fail_str(v);
+    }
+
+    return aio;
+}
+
+#if 0
+static VALUE
+extaio_fdatasync(VALUE aio)
+{
+    struct extaio *p = extaio_ref(aio);
+    if (aio_fsync(O_DSYNC, p->aio) != 0) {
+        VALUE v = rb_inspect(p->file);
+        rb_sys_fail_str(v);
+    }
+
+    return aio;
+}
+#endif
+
+/*
+ * call-seq:
+ *  status -> object
+ *
+ * <tt>aio_return</tt> の戻り値です。
+ *
+ * 正常完了時は読み込みまたは書き込みデータサイズを返します。
+ *
+ * 処理中であれば nil を返します。
+ *
+ * 異常完了の場合は errno に対する Errno::EXXX クラスを返します。
+ */
+static VALUE
+extaio_status(VALUE aio)
+{
+    return extaio_ref(aio)->status;
+}
+
+/*
+ * 非同期処理の取り消しをシステムに要求します。
+ *
+ * 常に取り消されるわけではないことに注意してください。
+ */
+static VALUE
+extaio_cancel(VALUE aio)
+{
+    struct extaio *p = extaio_ref(aio);
+    int fd = ext_io_getfd(p->file);
+    int status = aio_cancel(fd, &p->aio);
+    switch (status) {
+    case AIO_CANCELED:
+        return ID2SYM(rb_intern("canceled"));
+    case AIO_NOTCANCELED:
+        return ID2SYM(rb_intern("notcanceled"));
+    case AIO_ALLDONE:
+        return ID2SYM(rb_intern("alldone"));
+    case -1:
+        rb_sys_fail_str(rb_inspect(p->file));
+    default:
+        return rb_sprintf("unknown-status:0x%02x", status);
+    }
+}
+
+/*
+ * 正常値であれば自身を返す。
+ *
+ * 非同期処理中であれば nil を返す。
+ *
+ * エラーがあった場合は errno の例外を発生させる。
+ */
+static VALUE
+extaio_error(VALUE aio)
+{
+    struct extaio *p = extaio_ref(aio);
+    int err = aio_error(&p->aio);
+    switch (err) {
+    case 0:
+        return p->file;
+    case EINPROGRESS:
+        return Qnil;
+    case -1:
+        {
+            VALUE v = rb_inspect(p->file);
+            rb_sys_fail_str(v);
+        }
+        /* fall through */
+    default:
+        {
+            errno = err;
+            VALUE v = rb_inspect(p->file);
+            rb_sys_fail_str(v);
+        }
+        //return LL2NUM(err);
+    }
+}
+
+struct extaio_notify_dequeue_args
+{
+    struct kevent kevent;
+    const struct timespec *timeout;
+    //int status;
+};
+
+static int
+extaio_notify_dequeue_ungvl(struct extaio_notify_dequeue_args *args)
+{
+    return kevent(extaio_kqueue, NULL, 0, &args->kevent, 1, args->timeout);
+}
+
+static inline struct extaio *
+extaio_notify_dequeue(const struct timespec *timeout)
+{
+    struct extaio_notify_dequeue_args args = {
+        .timeout = timeout,
+    };
+    int s = (int)rb_thread_call_without_gvl((void *(*)(void *))extaio_notify_dequeue_ungvl,
+                                            &args, RUBY_UBF_PROCESS, NULL);
+    if (s == 0) {
+        return NULL;
+    } else if (s > 0) {
+        return (struct extaio *)args.kevent.ident;
+    } else {
+        rb_sys_fail("kevent failed (signaled event)");
+    }
+}
+
+static void *
+extaio_notify_cond_broadcast_ungvl(void *unused__)
+{
+    (void)unused__;
+
+    if (pthread_mutex_lock(&extaio_mutex) == 0) {
+        pthread_cond_broadcast(&extaio_cond);
+        pthread_mutex_unlock(&extaio_mutex);
+    }
+
+    return NULL;
+}
+
+static inline void
+extaio_notify_cond_broadcast(void)
+{
+    rb_thread_call_without_gvl(extaio_notify_cond_broadcast_ungvl,
+                               NULL, RUBY_UBF_PROCESS, NULL);
+}
+
+static VALUE
+extaio_notify_main(VALUE unused__)
+{
+    (void)unused__;
+
+    struct timespec timeout = { 1, 0 };
+    struct extaio *aiop = extaio_notify_dequeue(&timeout);
+
+    if (aiop) {
+        VALUE aio = aiop->self;
+        rb_str_unlocktmp(aiop->buffer);
+        rb_ary_delete(extio_lives, aio);
+
+        int s = aio_return(&aiop->aio);
+        if (s < 0) {
+            aiop->status = rb_obj_class(rb_syserr_new_str(errno, Qnil));
+            if (aiop->operation == EXTAIO_READ) {
+                rb_str_set_len(aiop->buffer, 0);
+            }
+        } else {
+            aiop->status = INT2FIX(s);
+            if (aiop->operation == EXTAIO_READ) {
+                rb_str_set_len(aiop->buffer, s);
+            }
+        }
+
+        VALUE notify_block = aiop->notify_block;
+        if (!NIL_P(notify_block)) {
+            // rb_proc_call は array オブジェクトを生成する必要があるため
+            // rb_proc_call_with_block に置き換えている
+            rb_proc_call_with_block(notify_block, 1, &aio, Qnil);
+        }
+
+        extaio_notify_cond_broadcast();
+    }
+
+    return 0;
+}
+
+static VALUE
+extaio_notify(VALUE unused__)
+{
+    (void)unused__;
+
+    int state;
+    for (;;) {
+        rb_set_errinfo(Qnil);
+        rb_protect(extaio_notify_main, 0, &state);
+        if (state != 0) {
+            //fprintf(stderr, "%s:%d:%s: rb_protect was returned state=%d (0x%08x)\n",
+            //        __FILE__, __LINE__, __func__, state, state);
+            VALUE e = rb_errinfo();
+            if (!NIL_P(e)) {
+                if (TYPE(e) == RUBY_T_FIXNUM) {
+                    rb_jump_tag(state);
+                }
+                VALUE v = rb_inspect(e);
+                //fprintf(stderr, "%s:%d:%s: %s\n",
+                //        __FILE__, __LINE__, __func__, StringValueCStr(v));
+                rb_funcall(rb_thread_main(), rb_intern("raise"), 1, e);
+                rb_set_errinfo(Qnil);
+            }
+            //rb_jump_tag(state);
+        }
+    }
+}
+
+void
+Init_ioplus(void)
+{
+#if EXTIO_HAVE_KEVENT
+    extaio_kqueue = kqueue();
+#else
+#   error NOT IMPLEMENTED WITHOUT EXTIO_HAVE_KEVENT
+#endif
+
+    IDto_time = rb_intern_const("to_time");
+
+    mIOPlus = rb_define_module("IOPlus");
+
+    extio_lives = rb_ary_new();
+    rb_gc_register_address(&extio_lives);
+
+    VALUE notify_thread = rb_thread_create(extaio_notify, 0);
+
+    /*
+     * This is extension module for IO.
+     */
+    mIO = rb_define_module_under(mIOPlus, "IO");
+    rb_include_module(rb_cIO, mIO);
+    rb_define_method(mIO, "aio_cancel", RUBY_METHOD_FUNC(extio_aio_cancel), 0);
+    rb_define_method(mIO, "aio_read", RUBY_METHOD_FUNC(extio_aio_read), -1);
+    rb_define_method(mIO, "aio_write", RUBY_METHOD_FUNC(extio_aio_write), 2);
+    rb_define_alias(mIO, "aread", "aio_read");
+    rb_define_alias(mIO, "awrite", "aio_write");
+
+    /*
+     * This is extension module for IO class.
+     */
+    mIOClass = rb_define_module_under(mIOPlus, "IOClass");
+    rb_extend_object(rb_cIO, mIOClass);
+
+    /*
+     * This is the request context of asynchronous I/O for <tt>IO#aio_read</tt> and <tt>IO#aio_write</tt>.
+     *
+     * The instance of this class can not directly created by <tt>IOPlus::AIO.new</tt>.
+     */
+    cAIO = rb_define_class_under(mIOPlus, "AIO", rb_cObject);
+    rb_undef_alloc_func(cAIO);
+    rb_define_method(cAIO, "to_s", RUBY_METHOD_FUNC(extaio_to_s), 0);
+    rb_define_method(cAIO, "inspect", RUBY_METHOD_FUNC(extaio_inspect), 0);
+    rb_define_method(cAIO, "validate", RUBY_METHOD_FUNC(extaio_validate), 0);
+    rb_define_method(cAIO, "file", RUBY_METHOD_FUNC(extaio_file), 0);
+    rb_define_method(cAIO, "operation", RUBY_METHOD_FUNC(extaio_operation), 0);
+    rb_define_method(cAIO, "buffer", RUBY_METHOD_FUNC(extaio_buffer), 0);
+    rb_define_method(cAIO, "offset", RUBY_METHOD_FUNC(extaio_offset), 0);
+    rb_define_method(cAIO, "suspend", RUBY_METHOD_FUNC(extaio_suspend), -1);
+    rb_define_method(cAIO, "fsync", RUBY_METHOD_FUNC(extaio_fsync), 0);
+#if 0
+    rb_define_method(cAIO, "fdatasync", RUBY_METHOD_FUNC(extaio_fdatasync), 0);
+#endif
+    rb_define_method(cAIO, "status", RUBY_METHOD_FUNC(extaio_status), 0);
+    rb_define_method(cAIO, "cancel", RUBY_METHOD_FUNC(extaio_cancel), 0);
+    rb_define_method(cAIO, "error", RUBY_METHOD_FUNC(extaio_error), 0);
+}

data/gemstub.rb

@@ -0,0 +1,18 @@
+GEMSTUB = Gem::Specification.new do |s|
+  s.name = "ioplus"
+  s.version = "0.0.1.PROTOTYPE"
+  s.summary = "Append IO#aio_read/aio_write methods. These provide similar functionality to aio_read(2)/aio_write(2)."
+  s.description = <<EOS
+"ioplus" is appended IO#aio_read/aio_write methods. These provide similar functionality to aio_read(2)/aio_write(2).
+
+This library need posix aio(4) and kqueue(2). Tested on FreeBSD 10.1 only.
+EOS
+  s.license = "2-clause BSD License"
+  s.author = "dearblue"
+  s.email = "dearblue@users.sourceforge.jp"
+  s.homepage = "http://sourceforge.jp/projects/rutsubo/"
+
+  s.required_ruby_version = ">= 2.0"
+  s.add_development_dependency "rspec", "~> 2.14"
+  s.add_development_dependency "rake", "~> 10.0"
+end

data/lib/ioplus.rb

@@ -0,0 +1,47 @@
+
+require "rbconfig"
+
+ver = RbConfig::CONFIG["ruby_version"]
+soname = File.basename(__FILE__, ".rb") << ".so"
+lib = File.join(File.dirname(__FILE__), ver, soname)
+if File.file?(lib)
+  require_relative File.join(ver, soname)
+else
+  require_relative soname
+end
+
+module IOPlus
+  module IOClass
+    def aio_suspend(*aio, timeout: nil)
+      aio.each { |x| x.suspend(timeout) }
+      nil
+    end
+  end
+
+  class AIO
+    def pretty_print(q)
+      return q.text("#<#{to_s} **INVALID-REFERENCE**>") unless validate
+
+      q.group(2, "#<#{to_s}") do
+        q.breakable " "
+        q.text "operation=#{operation},"
+        q.breakable " "
+        q.text "file="
+        q.pp file
+        q.text ","
+        q.breakable " "
+        q.text "offset="
+        q.pp offset
+        q.text ","
+        q.breakable " "
+        q.text "buffer.bytesize="
+        q.pp buffer.bytesize
+        q.text ","
+        q.breakable " "
+        q.text "status="
+        q.pp status
+        q.text ">"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: ioplus
+version: !ruby/object:Gem::Version
+  version: 0.0.1.PROTOTYPE
+platform: ruby
+authors:
+- dearblue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: |
+  "ioplus" is appended IO#aio_read/aio_write methods. These provide similar functionality to aio_read(2)/aio_write(2).
+
+  This library need posix aio(4) and kqueue(2). Tested on FreeBSD 10.1 only.
+email: dearblue@users.sourceforge.jp
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- LICENSE.md
+- README.ja.md
+- README.md
+- ext/extio.c
+- lib/ioplus.rb
+files:
+- LICENSE.md
+- README.ja.md
+- README.md
+- Rakefile
+- examples/aio_read.rb
+- ext/extconf.rb
+- ext/extio.c
+- gemstub.rb
+- lib/ioplus.rb
+homepage: http://sourceforge.jp/projects/rutsubo/
+licenses:
+- 2-clause BSD License
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Append IO#aio_read/aio_write methods. These provide similar functionality
+  to aio_read(2)/aio_write(2).
+test_files: []