fairy 0.6.0 → 0.6.5

data/ext/simple-hash.c

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2007-2010 Rakuten, Inc.
+ */
+
+#include <ruby.h>
+
+#include "fairy.h"
+
+#define MULTIPLIER  137
+
+VALUE rb_mFairySimpleHash;
+
+VALUE
+rb_fairy_simple_hash(VALUE self, VALUE vstr)
+{
+  return INT2FIX(rb_fairy_simple_hash_uint(self, vstr));
+}
+
+inline unsigned int
+rb_fairy_simple_hash_uint(VALUE self, VALUE vstr)
+{
+  VALUE vh;
+  char *str;
+  int len;
+  char *p;
+  unsigned int h = 0;
+
+  str = StringValuePtr(vstr);
+  len = RSTRING_LEN(vstr);
+
+  for (p = str; p - str < len; p++) {
+    h = h * MULTIPLIER + *p;
+  }
+  return h;
+}
+
+
+void Init_simple_hash(void) {
+  rb_mFairySimpleHash = rb_define_module_under(rb_mFairy, "SimpleHash");
+    
+  rb_define_module_function(rb_mFairySimpleHash, "hash", rb_fairy_simple_hash, 1);
+}
+
+

data/ext/string-buffer.c

@@ -0,0 +1,286 @@
+/**********************************************************************
+
+  string-buffer.c -
+  Copyright (C) 2007-2011 Rakuten, Inc.
+
+**********************************************************************/
+
+#include "ruby.h"
+
+#include "fairy.h"
+
+#define STRING_BUFFER_CAPA 10240
+
+VALUE rb_cFairyStringBuffer;
+
+typedef struct rb_fairy_string_buffer_struct
+{
+  long size;
+  VALUE string_sizes;
+  VALUE buffer;
+} fairy_string_buffer_t;
+
+#define GetFairyStringBufferPtr(obj, tobj) \
+  TypedData_Get_Struct((obj), fairy_string_buffer_t, &fairy_string_buffer_data_type, (tobj))
+
+static void
+fairy_string_buffer_mark(void *ptr)
+{
+  fairy_string_buffer_t *sb = (fairy_string_buffer_t*)ptr;
+  
+  rb_gc_mark(sb->string_sizes);
+  rb_gc_mark(sb->buffer);
+}
+
+static void
+fairy_string_buffer_free(void *ptr)
+{
+  ruby_xfree(ptr);
+}
+
+static size_t
+fairy_string_buffer_memsize(const void *ptr)
+{
+  return ptr ? sizeof(fairy_string_buffer_t) : 0;
+}
+
+#ifdef HAVE_RB_DATA_TYPE_T_FUNCTION
+static const rb_data_type_t fairy_string_buffer_data_type = {
+    "fairy_string_buffer",
+    {fairy_string_buffer_mark, fairy_string_buffer_free, fairy_string_buffer_memsize,},
+};
+#else
+static const rb_data_type_t fairy_string_buffer_data_type = {
+    "fairy_string_buffer",
+    fairy_string_buffer_mark,
+    fairy_string_buffer_free,
+    fairy_string_buffer_memsize,
+};
+#endif
+
+static VALUE
+fairy_string_buffer_alloc(VALUE klass)
+{
+  VALUE volatile obj;
+  fairy_string_buffer_t *sb;
+
+  obj = TypedData_Make_Struct(klass, fairy_string_buffer_t, &fairy_string_buffer_data_type, sb);
+
+  sb->size = 0;
+  sb->string_sizes = Qnil;
+  sb->buffer = Qnil;
+
+  return obj;
+}
+
+static VALUE
+rb_fairy_string_buffer_initialize(VALUE self)
+{
+  fairy_string_buffer_t *sb;
+  
+  GetFairyStringBufferPtr(self, sb);
+  sb->string_sizes = rb_fairy_fixnum_buffer_new();
+  sb->buffer = rb_str_buf_new(STRING_BUFFER_CAPA);
+  return self;
+}
+
+static VALUE
+fairy_string_buffer_initialize(int argc, VALUE *argv, VALUE self)
+{
+  rb_fairy_string_buffer_initialize(self);
+  if (argc == 0) {
+    /* do nothing */
+  }
+  else if (argc == 1 && CLASS_OF(argv[0]) == rb_cArray) {
+    VALUE ary = argv[0];
+    long i;
+      
+    for (i = 0; i < RARRAY_LEN(ary); i++) {
+      rb_fairy_string_buffer_push(self, RARRAY_PTR(ary)[i]);
+    }
+  }
+  else {
+    int i;
+    for (i = 0; i < argc; i++) {
+      rb_fairy_string_buffer_push(self, argv[i]);
+    }
+  }
+  return self;
+}
+
+
+VALUE
+rb_fairy_string_buffer_new(void)
+{
+  VALUE sb;
+  sb = fairy_string_buffer_alloc(rb_cFairyStringBuffer);
+  rb_fairy_string_buffer_initialize(sb);
+  return sb;
+}
+
+VALUE
+rb_fairy_string_buffer_new2(VALUE ary)
+{
+  VALUE sb;
+  long i;
+  sb = rb_fairy_string_buffer_new();
+
+  for (i = 0; i < RARRAY_LEN(ary); i++) {
+    rb_fairy_string_buffer_push(sb, RARRAY_PTR(ary)[i]);
+  }
+  
+  return sb;
+}
+
+VALUE
+rb_fairy_string_buffer_clear(VALUE self)
+{
+  fairy_string_buffer_t *sb;
+  GetFairyStringBufferPtr(self, sb);
+
+  sb->size = 0;
+  rb_fairy_fixnum_buffer_clear(sb->string_sizes);
+  rb_str_replace(sb->buffer, rb_str_new2(""));
+
+  return self;
+  
+}
+
+VALUE
+rb_fairy_string_buffer_size(VALUE self)
+{
+  fairy_string_buffer_t *sb;
+  GetFairyStringBufferPtr(self, sb);
+
+  return LONG2NUM(sb->size);
+}
+
+VALUE
+rb_fairy_string_buffer_push(VALUE self, VALUE str)
+{
+  fairy_string_buffer_t *sb;
+  GetFairyStringBufferPtr(self, sb);
+
+  if (!RB_TYPE_P(str, T_STRING)) 
+    rb_raise(rb_eTypeError, "wrong argument type (expected String)");
+  rb_fairy_fixnum_buffer_push_long(sb->string_sizes, RSTRING_LEN(str));
+  rb_str_buf_cat(sb->buffer, RSTRING_PTR(str), RSTRING_LEN(str));
+  sb->size++;
+  return self;
+}
+
+struct each_arg {
+  char *current;
+};
+
+static VALUE
+each_proc(long str_size, VALUE v)
+{
+  struct each_arg *arg = (struct each_arg *)v;
+  VALUE str;
+  VALUE ret;
+  
+  str = rb_str_new(arg->current, str_size);
+  ret = rb_yield(str);
+  arg->current += str_size;
+  return ret;
+}
+
+
+VALUE
+rb_fairy_string_buffer_each(VALUE self)
+{
+  fairy_string_buffer_t *sb;
+  struct each_arg arg;
+    
+  GetFairyStringBufferPtr(self, sb);
+
+  arg.current = RSTRING_PTR(sb->buffer);
+  rb_fairy_fixnum_buffer_each_callback(sb->string_sizes,
+				       each_proc, (VALUE)&arg);
+  return self;
+}
+
+struct to_a_arg {
+  char *current;
+  VALUE ary;
+};
+
+
+static VALUE
+to_a_proc(long str_size, VALUE v)
+{
+  struct to_a_arg *arg = (struct to_a_arg *)v;
+  VALUE ret;
+  
+  rb_ary_push(arg->ary, rb_str_new(arg->current, str_size));
+  arg->current += str_size;
+  return arg->ary;
+}
+
+VALUE
+rb_fairy_string_buffer_to_a(VALUE self)
+{
+  fairy_string_buffer_t *sb;
+  struct to_a_arg arg;
+    
+  GetFairyStringBufferPtr(self, sb);
+
+  arg.current = RSTRING_PTR(sb->buffer);
+  arg.ary = rb_ary_new2(sb->size);
+  
+  rb_fairy_fixnum_buffer_each_callback(sb->string_sizes,
+				       to_a_proc, (VALUE)&arg);
+  return arg.ary;
+}
+
+VALUE
+rb_fairy_string_buffer_marshal_dump(VALUE self)
+{
+  fairy_string_buffer_t *sb;
+  GetFairyStringBufferPtr(self, sb);
+
+  return rb_ary_new3(3, LONG2NUM(sb->size), sb->string_sizes, sb->buffer);
+}
+
+
+VALUE
+rb_fairy_string_buffer_marshal_load(VALUE self, VALUE obj)
+{
+  fairy_string_buffer_t *sb;
+  GetFairyStringBufferPtr(self, sb);
+  sb->size = NUM2LONG(rb_ary_entry(obj, 0));
+  sb->string_sizes = rb_ary_entry(obj, 1);
+  sb->buffer = rb_ary_entry(obj, 2);
+  return self;
+}
+
+VALUE
+rb_fairy_string_buffer_inspect(VALUE self)
+{
+  fairy_string_buffer_t *sb;
+  VALUE str;
+  
+  GetFairyStringBufferPtr(self, sb);
+  
+  str = rb_sprintf("<%s:%x size=%d>", rb_obj_classname(self), (void*)self, sb->size);
+  return str;
+}
+
+
+Init_string_buffer()
+{
+  VALUE fsb;
+  rb_cFairyStringBuffer = rb_define_class_under(rb_mFairy, "StringBuffer", rb_cObject);
+
+  fsb = rb_cFairyStringBuffer;
+  rb_define_alloc_func(fsb, fairy_string_buffer_alloc);
+  rb_define_method(fsb, "initialize", fairy_string_buffer_initialize, -1);
+  rb_define_method(fsb, "size", rb_fairy_string_buffer_size, 0);
+  rb_define_method(fsb, "push", rb_fairy_string_buffer_push, 1);
+  rb_define_method(fsb, "each", rb_fairy_string_buffer_each, 0);
+  rb_define_method(fsb, "to_a", rb_fairy_string_buffer_to_a, 0);
+  rb_define_method(fsb, "marshal_dump", rb_fairy_string_buffer_marshal_dump, 0);
+  rb_define_method(fsb, "marshal_load", rb_fairy_string_buffer_marshal_load, 1);
+  rb_define_method(fsb, "inspect", rb_fairy_string_buffer_inspect, 0);
+}

data/ext/xmarshaled-queue.c

@@ -0,0 +1,699 @@
+/**********************************************************************
+
+  xmarshaled_queue.c -
+  Copyright (C) 2007-2011 Rakuten, Inc.
+
+**********************************************************************/
+
+#include "ruby.h"
+
+#include "xthread.h"
+#include "fiber_mon.h"
+
+#include "fairy.h"
+
+extern VALUE rb_cXThreadMonitor;
+extern VALUE rb_cFiberMon;
+
+static VALUE rb_cFairyFastTempfile;
+
+static VALUE SET_NO_IMPORT;
+
+VALUE rb_cFairyXMarshaledQueue;
+
+static ID id_io;
+static ID id_open;
+static ID id_read;
+static ID id_write;
+static ID id_close;
+static ID id_close_bang;
+
+typedef struct rb_fairy_xmarshaled_queue_struct
+{
+  long chunk_size;
+  long min_chunk_no;
+  long buffers_cache_limit;
+
+  char use_string_buffer_p;
+  char log_mstore_p;
+  
+  VALUE push_queue;
+  
+  VALUE buffers;
+  VALUE buffers_mon;
+  VALUE buffers_cv;
+  long buffers_cache_no;
+
+  VALUE pop_queue;
+
+  VALUE buffer_dir;
+
+  VALUE (*queue_push)(VALUE, VALUE);
+
+  VALUE (*mon_synchronize)();
+  VALUE (*cv_wait)();
+  VALUE (*cv_broadcast)();
+  
+} fairy_xmarshaled_queue_t;
+
+#define GetFairyXMarshaledQueuePtr(obj, tobj) \
+  TypedData_Get_Struct((obj), fairy_xmarshaled_queue_t, &fairy_xmarshaled_queue_data_type, (tobj))
+
+static void
+fairy_xmarshaled_queue_mark(void *ptr)
+{
+  fairy_xmarshaled_queue_t *mq = (fairy_xmarshaled_queue_t*)ptr;
+  
+  rb_gc_mark(mq->push_queue);
+  rb_gc_mark(mq->buffers);
+  rb_gc_mark(mq->buffers_mon);
+  rb_gc_mark(mq->buffers_cv);
+  rb_gc_mark(mq->pop_queue);
+  rb_gc_mark(mq->buffer_dir);
+}
+
+static void
+fairy_xmarshaled_queue_free(void *ptr)
+{
+  ruby_xfree(ptr);
+}
+
+static size_t
+fairy_xmarshaled_queue_memsize(const void *ptr)
+{
+  return ptr ? sizeof(fairy_xmarshaled_queue_t) : 0;
+}
+
+#ifdef HAVE_RB_DATA_TYPE_T_FUNCTION
+static const rb_data_type_t fairy_xmarshaled_queue_data_type = {
+    "fairy_xmarshaled_queue",
+    {fairy_xmarshaled_queue_mark, fairy_xmarshaled_queue_free, fairy_xmarshaled_queue_memsize,},
+};
+#else
+static const rb_data_type_t fairy_xmarshaled_queue_data_type = {
+    "fairy_xmarshaled_queue",
+    fairy_xmarshaled_queue_mark,
+    fairy_xmarshaled_queue_free,
+    fairy_xmarshaled_queue_memsize,
+};
+#endif
+
+static VALUE
+fairy_xmarshaled_queue_alloc(VALUE klass)
+{
+  VALUE volatile obj;
+  fairy_xmarshaled_queue_t *mq;
+
+  obj = TypedData_Make_Struct(klass, fairy_xmarshaled_queue_t, &fairy_xmarshaled_queue_data_type, mq);
+
+  mq->chunk_size = 0;
+  mq->min_chunk_no = 0;
+  mq->buffers_cache_limit = 0;
+  
+  mq->push_queue = Qnil;
+  
+  mq->buffers = Qnil;
+  mq->buffers_mon = Qnil;
+  mq->buffers_cv = Qnil;
+  mq->buffers_cache_no = 0;
+
+  mq->pop_queue = Qnil;
+
+  mq->buffer_dir = Qnil;
+
+  mq->queue_push = NULL;
+
+  mq->mon_synchronize = NULL;
+  mq->cv_wait = NULL;
+  mq->cv_broadcast = NULL;
+  
+  return obj;
+}
+
+static VALUE rb_fairy_xmarshaled_queue_monitor_cond_wait(VALUE);
+static VALUE rb_fairy_xmarshaled_queue_genmon_synchronize(VALUE, VALUE (*)(VALUE), VALUE);
+static VALUE rb_fairy_xmarshaled_queue_gencond_wait(VALUE);
+static VALUE rb_fairy_xmarshaled_queue_gencond_broadcast(VALUE);
+
+static VALUE rb_fairy_xmarshaled_queue_empty_push(VALUE, VALUE);
+static VALUE rb_fairy_xmarshaled_queue_str_push(VALUE, VALUE);
+static VALUE rb_fairy_xmarshaled_queue_obj_push(VALUE, VALUE);
+
+static VALUE
+rb_fairy_xmarshaled_queue_initialize(VALUE self, VALUE policy, VALUE buffers_mon, VALUE buffers_cv)
+{
+  VALUE sz;
+  VALUE flag;
+  VALUE dir;
+  fairy_xmarshaled_queue_t *mq;
+  
+  GetFairyXMarshaledQueuePtr(self, mq);
+  
+  sz = rb_fairy_conf("XMARSHAL_QUEUE_CHUNK_SIZE", policy, "chunk_size");
+  mq->chunk_size = NUM2LONG(sz);
+
+  sz = rb_fairy_conf("XMARSHAL_QUEUE_BUFFERS_CACHE_LIMIT",
+		     policy, "buffers_cache_limit");
+  mq->buffers_cache_limit = NUM2LONG(sz);
+
+  flag = rb_fairy_conf("XMARSHAL_QUEUE_USE_STRING_BUFFER",
+		       policy, "use_string_buffer");
+  mq->use_string_buffer_p = RTEST(flag);
+
+
+  flag = rb_fairy_conf("XMARSHAL_QUEUE_LOG_MSTORE",
+		       policy, "log_mstore");
+  mq->log_mstore_p = RTEST(flag);
+
+  dir = rb_fairy_conf("TMP_DIR", policy, "buffer_dir");
+  mq->buffer_dir = dir;
+
+  mq->push_queue = Qnil;
+  
+  mq->buffers = rb_xthread_fifo_new();
+  if (NIL_P(buffers_mon)) {
+    buffers_mon = rb_xthread_monitor_new();
+  }
+  mq->buffers_mon = buffers_mon;
+  
+  if (NIL_P(buffers_cv)) {
+    buffers_cv = rb_funcall(buffers_mon, rb_intern("new_cond"), 0);
+  }
+  mq->buffers_cv = buffers_cv;
+  
+  mq->pop_queue = Qnil;
+
+  mq->queue_push = rb_fairy_xmarshaled_queue_empty_push;
+
+  if (CLASS_OF(mq->buffers_mon) == rb_cXThreadMonitor) {
+    mq->mon_synchronize = rb_xthread_monitor_synchronize;
+    mq->cv_wait = rb_fairy_xmarshaled_queue_monitor_cond_wait;
+    mq->cv_broadcast = rb_xthread_monitor_cond_broadcast;
+  }
+  else if (CLASS_OF(mq->buffers_mon) == rb_cFiberMonMonitor) {
+    mq->mon_synchronize = rb_fibermon_monitor_synchronize;
+    mq->cv_wait = rb_fibermon_cond_wait;
+    mq->cv_broadcast = rb_fibermon_cond_broadcast;
+  }
+  else {
+    mq->mon_synchronize = rb_fairy_xmarshaled_queue_genmon_synchronize;
+    mq->cv_wait = rb_fairy_xmarshaled_queue_gencond_wait;
+    mq->cv_broadcast = rb_fairy_xmarshaled_queue_gencond_broadcast;
+  }
+
+  return self;
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_monitor_cond_wait(VALUE arg)
+{
+  return rb_xthread_monitor_cond_wait(arg, Qnil);
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_genmon_synchronize(VALUE arg1, VALUE (*arg2)(VALUE), VALUE arg3)
+{
+  static ID id_synchronize;
+  if (!id_synchronize) id_synchronize = rb_intern("synchronize");
+
+  return rb_funcall(arg1, id_synchronize, 2, arg2, arg3);
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_gencond_wait(VALUE arg)
+{
+  static ID id_wait;
+  if (!id_wait) id_wait = rb_intern("wait");
+
+  return rb_funcall(arg, id_wait, 1, Qnil);
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_gencond_broadcast(VALUE arg1)
+{
+  static ID id_broadcast;
+  if (!id_broadcast) id_broadcast = rb_intern("broadcast");
+
+  return rb_funcall(arg1, id_broadcast, 0);
+}
+
+static VALUE
+fairy_xmarshaled_queue_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE policy;
+  VALUE buffers_mon;
+  VALUE buffers_cv;
+  
+  rb_scan_args(argc, argv, "12", &policy, &buffers_mon, &buffers_cv);
+  return rb_fairy_xmarshaled_queue_initialize(self, policy, buffers_mon, buffers_cv);
+}
+
+VALUE
+rb_fairy_xmarshaled_queue_new(VALUE policy, VALUE buffers_mon, VALUE buffers_cv)
+{
+  VALUE self;
+
+  self = fairy_xmarshaled_queue_alloc(rb_cFairyXMarshaledQueue);
+  rb_fairy_xmarshaled_queue_initialize(self, policy, buffers_mon, buffers_cv);
+  return self;
+}
+
+static VALUE rb_fairy_xmarshaled_queue_buffers_push(VALUE, VALUE);
+static VALUE rb_fairy_xmarshaled_queue_broadcast(VALUE);
+static VALUE rb_fairy_xmarshaled_queue_store(VALUE, VALUE);
+static VALUE rb_fairy_xmarshaled_queue_restore(VALUE, VALUE);
+
+#define BUFFERS_PUSH(self, buf) \
+  rb_fairy_xmarshaled_queue_buffers_push(self, buf)
+
+#define BUFFERS_PUSH_PUSH_QUEUE(self, mq, buf)			\
+  if (mq->buffers_cache_limit >= mq->buffers_cache_no) {	\
+    BUFFERS_PUSH(self, rb_marshal_dump(buf, Qnil));		\
+    mq->buffers_cache_no++;					\
+  }								\
+  else {							      \
+    BUFFERS_PUSH(self, rb_fairy_xmarshaled_queue_store(self, buf));   \
+  }
+
+VALUE
+rb_fairy_xmarshaled_queue_push(VALUE self, VALUE e)
+{
+  fairy_xmarshaled_queue_t *mq;
+
+  GetFairyXMarshaledQueuePtr(self, mq);
+  return mq->queue_push(self, e);
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_empty_push(VALUE self, VALUE e)
+{
+  fairy_xmarshaled_queue_t *mq;
+  GetFairyXMarshaledQueuePtr(self, mq);
+
+  if (EOS_P(e)) {
+    BUFFERS_PUSH(self, e);
+    return self;
+  }
+
+  if (mq->use_string_buffer_p && CLASS_OF(e) == rb_cString) {
+    mq->push_queue = rb_fairy_string_buffer_new();
+    mq->queue_push = rb_fairy_xmarshaled_queue_str_push;
+  }
+  else {
+    mq->push_queue = rb_ary_new2(mq->min_chunk_no);
+    mq->queue_push = rb_fairy_xmarshaled_queue_obj_push;
+  }
+  return mq->queue_push(self, e);
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_obj_push(VALUE self, VALUE e)
+{
+  fairy_xmarshaled_queue_t *mq;
+  GetFairyXMarshaledQueuePtr(self, mq);
+
+  if (EOS_P(e)) {
+    BUFFERS_PUSH_PUSH_QUEUE(self, mq, mq->push_queue);
+    mq->push_queue = Qnil;
+    BUFFERS_PUSH(self, e);
+    return self;
+  }
+
+  if (mq->use_string_buffer_p && CLASS_OF(e) == rb_cString) {
+    BUFFERS_PUSH_PUSH_QUEUE(self, mq, mq->push_queue);
+    mq->push_queue = Qnil;
+    mq->queue_push = rb_fairy_xmarshaled_queue_empty_push;
+    /*
+    return mq->queue_push(self, e);
+    */
+  }
+
+  rb_ary_push(mq->push_queue, e);
+  if (RARRAY_LEN(mq->push_queue) >= mq->chunk_size || e == SET_NO_IMPORT) {
+    BUFFERS_PUSH_PUSH_QUEUE(self, mq, mq->push_queue);
+    mq->push_queue = Qnil;
+    mq->queue_push = rb_fairy_xmarshaled_queue_empty_push;
+  }
+  return self;
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_str_push(VALUE self, VALUE e)
+{
+  fairy_xmarshaled_queue_t *mq;
+  
+  GetFairyXMarshaledQueuePtr(self, mq);
+  if (EOS_P(e)) {
+    BUFFERS_PUSH_PUSH_QUEUE(self, mq, mq->push_queue);
+    mq->push_queue = Qnil;
+    BUFFERS_PUSH(self, e);
+    return self;
+  }
+
+  if (CLASS_OF(e) != rb_cString) {
+    BUFFERS_PUSH_PUSH_QUEUE(self, mq, mq->push_queue);
+    rb_fairy_string_buffer_clear(mq->push_queue);
+    mq->push_queue = Qnil;
+    mq->queue_push = rb_fairy_xmarshaled_queue_empty_push;
+  }
+  rb_fairy_string_buffer_push(mq->push_queue, e);
+  if (NUM2LONG(rb_fairy_string_buffer_size(mq->push_queue)) >= mq->chunk_size) {
+    BUFFERS_PUSH_PUSH_QUEUE(self, mq, mq->push_queue);
+    rb_fairy_string_buffer_clear(mq->push_queue);
+    mq->push_queue = Qnil;
+    mq->queue_push = rb_fairy_xmarshaled_queue_empty_push;
+  }
+  return self;
+}
+
+static VALUE rb_fairy_xmarshaled_queue_store_raw(VALUE, VALUE);
+
+static VALUE
+rb_fairy_xmarshaled_queue_push_raw(VALUE self, VALUE raw)
+{
+  fairy_xmarshaled_queue_t *mq;
+  
+  GetFairyXMarshaledQueuePtr(self, mq);
+  
+  if (!NIL_P(mq->push_queue)) {
+    BUFFERS_PUSH_PUSH_QUEUE(self, mq, mq->push_queue);
+    mq->push_queue = Qnil;
+  }
+  if (EOS_P(raw)) {
+    BUFFERS_PUSH(self, raw);
+  }
+  else {
+    if (mq->buffers_cache_limit >= mq->buffers_cache_no) { 
+      BUFFERS_PUSH(self, raw); 
+      mq->buffers_cache_no++; 
+    } 
+    else { 
+      BUFFERS_PUSH(self, rb_fairy_xmarshaled_queue_store_raw(self, raw)); 
+    }
+  }
+  return self;
+}
+
+
+
+struct rb_fairy_xmarshaled_queue_buffers_push_arg 
+{
+  VALUE self;
+  VALUE buf;
+};
+
+static VALUE rb_fairy_xmarshaled_queue_push_sync(struct rb_fairy_xmarshaled_queue_buffers_push_arg *);
+
+
+static VALUE
+rb_fairy_xmarshaled_queue_buffers_push(VALUE self, VALUE buf)
+{
+  fairy_xmarshaled_queue_t *mq;
+  struct rb_fairy_xmarshaled_queue_buffers_push_arg arg;
+
+  GetFairyXMarshaledQueuePtr(self, mq);
+
+  arg.self = self;
+  arg.buf = buf;
+  
+  mq->mon_synchronize(mq->buffers_mon,
+		      rb_fairy_xmarshaled_queue_push_sync, &arg);
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_push_sync(struct rb_fairy_xmarshaled_queue_buffers_push_arg *arg)
+{
+  fairy_xmarshaled_queue_t *mq;
+  GetFairyXMarshaledQueuePtr(arg->self, mq);
+
+  rb_xthread_fifo_push(mq->buffers, arg->buf);
+  mq->cv_broadcast(mq->buffers_cv);
+  return arg->self;
+}
+
+struct rb_fairy_xmarshaled_queue_pop_arg 
+{
+  VALUE self;
+  VALUE buf;
+};
+
+static VALUE rb_fairy_xmarshaled_queue_pop_wait(struct rb_fairy_xmarshaled_queue_pop_arg *arg);
+
+VALUE
+rb_fairy_xmarshaled_queue_pop(VALUE self)
+{
+  fairy_xmarshaled_queue_t *mq;
+  VALUE buf;
+  struct rb_fairy_xmarshaled_queue_pop_arg arg;
+  GetFairyXMarshaledQueuePtr(self, mq);
+
+  while (NIL_P(mq->pop_queue) || RARRAY_LEN(mq->pop_queue) == 0) {
+    buf = rb_xthread_fifo_pop(mq->buffers);
+    if (NIL_P(buf)) {
+      arg.self = self;
+      arg.buf = Qnil;
+      mq->mon_synchronize(mq->buffers_mon,
+			  rb_fairy_xmarshaled_queue_pop_wait, &arg);
+      buf = arg.buf;
+    }
+    if (EOS_P(buf)) {
+      mq->pop_queue = rb_ary_new3(1, buf);
+    }
+    else if (CLASS_OF(buf) == rb_cFairyFastTempfile) {
+      buf = rb_fairy_xmarshaled_queue_restore(self, buf);
+      if (CLASS_OF(buf) == rb_cFairyStringBuffer) {
+	VALUE tmp = buf;
+	buf = rb_fairy_string_buffer_to_a(tmp);
+	rb_fairy_string_buffer_clear(tmp);
+      }
+      mq->pop_queue = buf;
+    }
+    else {
+      buf = rb_marshal_load(buf);
+      if (CLASS_OF(buf) == rb_cFairyStringBuffer) {
+	mq->pop_queue = rb_fairy_string_buffer_to_a(buf);
+	rb_fairy_string_buffer_clear(buf); 
+	mq->buffers_cache_no--;
+      }
+      else {
+	mq->pop_queue = buf;
+	mq->buffers_cache_no--;
+      }
+    }
+  }
+  return rb_ary_shift(mq->pop_queue);
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_pop_wait(struct rb_fairy_xmarshaled_queue_pop_arg *arg)
+{
+  VALUE self = arg->self;
+  fairy_xmarshaled_queue_t *mq;
+  VALUE buf = Qnil;
+
+  GetFairyXMarshaledQueuePtr(self, mq);
+  
+  buf = rb_xthread_fifo_pop(mq->buffers);
+  while (NIL_P(buf)) {
+    mq->cv_wait(mq->buffers_cv);
+    buf = rb_xthread_fifo_pop(mq->buffers);
+  }
+  arg->buf = buf;
+  return arg->self;
+}
+
+static VALUE rb_fairy_xmarshaled_queue_restore_raw(VALUE, VALUE);
+
+VALUE
+rb_fairy_xmarshaled_queue_pop_raw(VALUE self)
+{
+  fairy_xmarshaled_queue_t *mq;
+  VALUE pop_raw = Qnil;
+  VALUE buf;
+  struct rb_fairy_xmarshaled_queue_pop_arg arg;
+  
+  GetFairyXMarshaledQueuePtr(self, mq);
+  buf = rb_xthread_fifo_pop(mq->buffers);
+  if (NIL_P(buf)) {
+    arg.self = self;
+    arg.buf = Qnil;
+    mq->mon_synchronize(mq->buffers_mon,
+			rb_fairy_xmarshaled_queue_pop_wait, &arg);
+    buf = arg.buf;
+  }
+  if (EOS_P(buf)) {
+    pop_raw = buf;
+  }
+  else if (CLASS_OF(buf) == rb_cFairyFastTempfile) {
+    pop_raw = rb_fairy_xmarshaled_queue_restore_raw(self, buf);
+  }
+  else {
+    pop_raw = buf;
+    mq->buffers_cache_no--;
+  }
+  return pop_raw;
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_store(VALUE self, VALUE buffer)
+{
+  VALUE tmpbuf;
+  VALUE io;
+  fairy_xmarshaled_queue_t *mq;
+
+  GetFairyXMarshaledQueuePtr(self, mq);
+
+  if (mq->log_mstore_p) {
+    rb_fairy_debug(self, "START M.STORE");
+  }
+  
+  if (NIL_P(mq->buffer_dir)) {
+    tmpbuf = rb_funcall(rb_cFairyFastTempfile, id_open, 1,
+			rb_str_new2("port-buffer-"));
+  }
+  else {
+    tmpbuf = rb_funcall(rb_cFairyFastTempfile, id_open, 2,
+			rb_str_new2("port-buffer-"),
+			mq->buffer_dir);
+  }
+ 
+  io = rb_funcall(tmpbuf, id_io, 0);
+  rb_marshal_dump(buffer, io);
+  rb_funcall(tmpbuf, id_close, 0);
+  
+  if (mq->log_mstore_p) {
+    rb_fairy_debug(self, "FINISH M.STORE");
+  }
+  return tmpbuf;
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_store_raw(VALUE self, VALUE raw)
+{
+  VALUE tmpbuf;
+  VALUE io;
+  fairy_xmarshaled_queue_t *mq;
+
+  GetFairyXMarshaledQueuePtr(self, mq);
+
+  if (mq->log_mstore_p) {
+    rb_fairy_debug(self, "START M.STORE");
+  }
+  
+  if (NIL_P(mq->buffer_dir)) {
+    tmpbuf = rb_funcall(rb_cFairyFastTempfile, id_open, 1,
+			rb_str_new2("port-buffer-"));
+  }
+  else {
+    tmpbuf = rb_funcall(rb_cFairyFastTempfile, id_open, 2,
+			rb_str_new2("port-buffer-"),
+			mq->buffer_dir);
+  }
+ 
+  io = rb_funcall(tmpbuf, id_io, 0);
+  rb_io_write(io, raw);
+  rb_funcall(tmpbuf, id_close, 0);
+  
+  if (mq->log_mstore_p) {
+    rb_fairy_debug(self, "FINISH M.STORE");
+  }
+  return tmpbuf;
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_restore(VALUE self, VALUE tmpbuf)
+{
+  VALUE buf;
+  VALUE io;
+  fairy_xmarshaled_queue_t *mq;
+
+  GetFairyXMarshaledQueuePtr(self, mq);
+
+  if (mq->log_mstore_p) {
+    rb_fairy_debug(self, "START M.RESTORE");
+  }
+  
+  io = rb_funcall(tmpbuf, id_open, 0);
+  
+  buf = rb_marshal_load(io);
+  
+  if (mq->log_mstore_p) {
+    rb_fairy_debug(self, "FINISH M.RESTORE");
+  }
+  return buf;
+}
+
+static VALUE
+rb_fairy_xmarshaled_queue_restore_raw(VALUE self, VALUE tmpbuf)
+{
+  VALUE buf;
+  VALUE io;
+  fairy_xmarshaled_queue_t *mq;
+
+  GetFairyXMarshaledQueuePtr(self, mq);
+
+  if (mq->log_mstore_p) {
+    rb_fairy_debug(self, "START M.RESTORE");
+  }
+  
+  io = rb_funcall(tmpbuf, id_open, 0);
+  
+  buf = rb_funcall(io, id_read, 1, Qnil);
+  
+  if (mq->log_mstore_p) {
+    rb_fairy_debug(self, "FINISH M.RESTORE");
+  }
+  return buf;
+}
+
+VALUE
+rb_fairy_xmarshaled_queue_inspect(VALUE self)
+{
+  VALUE str;
+  fairy_xmarshaled_queue_t *mq;
+
+  GetFairyXMarshaledQueuePtr(self, mq);
+
+  str = rb_sprintf("<%s:%p chunk_size=%d, min_chunk_no=%d, mq_bufferes_cache_no=%d use_string_bffer_p=%d buffers_cache_no=%d buffer_dir=",
+		   rb_obj_classname(self),
+		   (void*)self,
+		   mq->chunk_size,
+		   mq->min_chunk_no,
+		   mq->buffers_cache_limit,
+		   mq->use_string_buffer_p,
+		   mq->buffers_cache_no);
+  rb_str_append(str, mq->buffer_dir);
+  rb_str_cat2(str, ">");
+  return str;
+}
+
+
+void
+Init_xmarshaled_queue()
+{
+  VALUE xmq;
+  
+  rb_cFairyFastTempfile = rb_const_get(rb_mFairy, rb_intern("FastTempfile"));
+
+  id_io = rb_intern("io");
+  id_open = rb_intern("open");
+  id_read = rb_intern("read");
+  id_write = rb_intern("write");
+  id_close = rb_intern("close");
+  id_close_bang = rb_intern("close!");
+
+  SET_NO_IMPORT = rb_const_get(rb_cFairyImport, rb_intern("SET_NO_IMPORT"));
+
+  rb_cFairyXMarshaledQueue  = rb_define_class_under(rb_mFairy, "XMarshaledQueue", rb_cObject);
+
+  xmq = rb_cFairyXMarshaledQueue;
+  
+  rb_define_alloc_func(xmq, fairy_xmarshaled_queue_alloc);
+  rb_define_method(xmq, "initialize", fairy_xmarshaled_queue_initialize, -1);
+  rb_define_method(xmq, "push", rb_fairy_xmarshaled_queue_push, 1);
+  rb_define_method(xmq, "push_raw", rb_fairy_xmarshaled_queue_push_raw, 1);
+  rb_define_method(xmq, "pop", rb_fairy_xmarshaled_queue_pop, 0);
+  rb_define_method(xmq, "pop_raw", rb_fairy_xmarshaled_queue_pop_raw, 0);
+  rb_define_method(xmq, "inspect", rb_fairy_xmarshaled_queue_inspect, 0);
+}
+