ytljit 0.0.8 → 0.0.9

data/ext/code_alloc.c

@@ -175,11 +175,11 @@ search_free_chunk(CodeSpaceArena *arena)
   while (arena) {
     for (i = 0;(cbitmap = arena->bitmap[i]) == 0; i++);
     if (i < alocarea_off) {
-      arena_search_tab[logsize] = arena;
-
       /* found free chunk */
       int bitpos = ffs64(cbitmap);
 
+      arena_search_tab[logsize] = arena;
+
       /* bitmap free -> used */
       // fprintf(stderr, "%x %x\n", bitpos, arena->bitmap[i]);
       arena->bitmap[i] = cbitmap & (cbitmap - 1);

data/ext/memory.c

@@ -26,7 +26,7 @@ ytl_arena_mark(struct ArenaHeader *arenah)
       start = arenah->lastptr;
       appear = 1;
     } 
-    else if (appear)  {
+    else if (appear) {
       start = bodyptr->body;
     }
     else {
@@ -47,8 +47,6 @@ ytl_arena_mark(struct ArenaHeader *arenah)
 void
 ytl_arena_free(struct ArenaHeader *arenah)
 {
-  VALUE *base;
-  VALUE *start;
   struct ArenaBody *curptr;
   struct ArenaBody *curptr_next;
   
@@ -169,7 +167,6 @@ ytl_arena_emit(VALUE self, VALUE offset, VALUE src)
   struct ArenaHeader *arenah;
 
   int raw_offset;
-  int newsize;
   VALUE *newlastptr;
 
   Data_Get_Struct(self, struct ArenaHeader, arenah);
@@ -228,7 +225,7 @@ ytl_arena_to_s(VALUE self)
 
   Data_Get_Struct(self, struct ArenaHeader, arenah);
 
-  return rb_sprintf("#<Arena %p size=%d body=%p last=%p>", 
+  return rb_sprintf("#<Arena %p size=%lu body=%p last=%p>", 
 		    (void *)self, 
 		    ytl_arena_size(self) / 2,
 		    (void *)arenah->body->body,

data/ext/thread.c

@@ -0,0 +1,144 @@
+#include <stdlib.h>
+#include <pthread.h>
+#include "ruby.h"
+
+#include "ytljit.h"
+#include "thread.h"
+
+VALUE ytl_cThread;
+
+static void
+ytl_thread_mark(struct ytl_thread *th)
+{
+  rb_gc_mark(th->pself);
+  rb_gc_mark(th->cself);
+}
+
+/* You may think arguments order is wrong. But it is correct.
+  This is for efficient code. See SendThreadNewNode#compile in 
+  github#ytl/lib/ytl/thread.rb 
+*/
+VALUE
+ytl_thread_create(void *argv, void *(*entry)(void *))
+{
+  struct ytl_thread *th;
+
+  th = malloc(sizeof(struct ytl_thread));
+  th->pself = ((VALUE *)argv)[4];
+  th->cself = ((VALUE *)argv)[3];
+  pthread_attr_init(&th->attr);
+  pthread_attr_setstacksize(&th->attr, 64 * 1024);
+  pthread_create(&th->thread, &th->attr, entry, argv);
+
+  //printf("%x %x \n", th->pself, th->cself);
+
+  return Data_Wrap_Struct(ytl_cThread, ytl_thread_mark, NULL, (void *)th);
+}
+
+static void
+ytl_obj_copy(VALUE dest, VALUE obj)
+{
+  rb_copy_generic_ivar(dest, obj);
+  rb_gc_copy_finalizer(dest, obj);
+  rb_copy_generic_ivar(dest, obj);
+  rb_gc_copy_finalizer(dest, obj);
+  switch (TYPE(obj)) {
+  case T_OBJECT:
+    if (!(RBASIC(dest)->flags & ROBJECT_EMBED) && ROBJECT_IVPTR(dest)) {
+      xfree(ROBJECT_IVPTR(dest));
+      ROBJECT(dest)->as.heap.ivptr = 0;
+      ROBJECT(dest)->as.heap.numiv = 0;
+      ROBJECT(dest)->as.heap.iv_index_tbl = 0;
+    }
+    if (RBASIC(obj)->flags & ROBJECT_EMBED) {
+      MEMCPY(ROBJECT(dest)->as.ary, ROBJECT(obj)->as.ary, VALUE, ROBJECT_EMBED_LEN_MAX);
+      RBASIC(dest)->flags |= ROBJECT_EMBED;
+    }
+    else {
+      long len = ROBJECT(obj)->as.heap.numiv;
+      VALUE *ptr = ALLOC_N(VALUE, len);
+      MEMCPY(ptr, ROBJECT(obj)->as.heap.ivptr, VALUE, len);
+      ROBJECT(dest)->as.heap.ivptr = ptr;
+      ROBJECT(dest)->as.heap.numiv = len;
+      ROBJECT(dest)->as.heap.iv_index_tbl = ROBJECT(obj)->as.heap.iv_index_tbl;
+      RBASIC(dest)->flags &= ~ROBJECT_EMBED;
+    }
+    break;
+
+#if 0    
+  case T_CLASS:
+  case T_MODULE:
+    if (RCLASS_IV_TBL(dest)) {
+      st_free_table(RCLASS_IV_TBL(dest));
+      RCLASS_IV_TBL(dest) = 0;
+    }
+    if (RCLASS_CONST_TBL(dest)) {
+      rb_free_const_table(RCLASS_CONST_TBL(dest));
+      RCLASS_CONST_TBL(dest) = 0;
+    }
+    if (RCLASS_IV_TBL(obj)) {
+      RCLASS_IV_TBL(dest) = st_copy(RCLASS_IV_TBL(obj));
+    }
+    break;
+#endif
+  }
+}
+
+void
+ytl_thread_exit(VALUE val)
+{
+  pthread_exit((void *)val);
+}
+
+VALUE
+ytl_thread_join(VALUE self)
+{
+  struct ytl_thread *th;
+
+  Data_Get_Struct(self, struct ytl_thread, th);
+  pthread_join(th->thread, NULL);
+  pthread_attr_destroy(&th->attr);
+
+  return self;
+}
+
+VALUE
+ytl_thread_merge(VALUE self, VALUE newself)
+{
+  struct ytl_thread *th;
+  Data_Get_Struct(self, struct ytl_thread, th);
+
+  if (th->pself != newself) {
+    ytl_obj_copy(th->pself, newself);
+  }
+
+  return self;
+}
+
+VALUE
+ytl_thread_pself(VALUE self)
+{
+  struct ytl_thread *th;
+
+  Data_Get_Struct(self, struct ytl_thread, th);
+  return th->pself;
+}
+
+VALUE
+ytl_thread_set_pself(VALUE self, VALUE val)
+{
+  struct ytl_thread *th;
+
+  Data_Get_Struct(self, struct ytl_thread, th);
+  th->pself = val;
+  return val;
+}
+
+VALUE
+ytl_thread_cself(VALUE self)
+{
+  struct ytl_thread *th;
+
+  Data_Get_Struct(self, struct ytl_thread, th);
+  return th->cself;
+}

data/ext/thread.h

@@ -0,0 +1,24 @@
+enum ytl_thread_status {
+  YTL_RUN = 0,
+  YTL_SLEEP = 1,
+  YTL_ABORTING = 2,
+  YTL_DEAD = 3,
+};
+
+struct ytl_thread {
+  enum ytl_thread_status status;
+  pthread_t thread;
+  pthread_attr_t attr;
+  VALUE pself;			/* thread creater's self  */
+  VALUE cself;			/* child thread's self */
+};
+
+extern VALUE ytl_thread_create(void *, void *(*)(void *));
+extern void ytl_thread_exit(VALUE);
+extern VALUE ytl_thread_join(VALUE);
+extern VALUE ytl_thread_merge(VALUE, VALUE);
+extern VALUE ytl_thread_pself(VALUE);
+extern VALUE ytl_thread_set_pself(VALUE, VALUE);
+extern VALUE ytl_thread_cself(VALUE);
+extern VALUE ytl_cThread;
+

data/ext/ytljit.c

@@ -6,6 +6,7 @@
 #include "ruby/st.h"
 
 #include "ytljit.h"
+#include "thread.h"
 
 VALUE ytl_mYTLJit;
 VALUE ytl_cCodeSpace;
@@ -106,7 +107,6 @@ ytl_method_address_of_raw(VALUE klass, VALUE mname)
 VALUE
 ytl_binding_to_a(VALUE self)
 {
-  rb_proc_t *proc;
   rb_binding_t *bptr;
   rb_env_t *env;
   VALUE resary;
@@ -337,9 +337,23 @@ ytl_code_call(int argc, VALUE *argv, VALUE self)
   raddr = (void *)NUM2ULONG(addr);
 
 #ifdef __x86_64__
-  asm("mov %1, %%rax;"
+  asm("push %%rbx;"
+      "push %%rdi;"
+      "push %%rsi;"
+      "push %%r12;"
+      "push %%r13;"
+      "push %%r14;"
+      "push %%r15;"
+      "mov %1, %%rax;"
       "call *%2;"
       "mov %%rax, %0;"
+      "pop  %%r15;"
+      "pop  %%r14;"
+      "pop  %%r13;"
+      "pop  %%r12;"
+      "pop  %%rsi;"
+      "pop  %%rdi;"
+      "pop  %%rbx;"
       : "=r"(rc) 
       : "r"(args), "r"(raddr) 
       : "%rax", "%rbx");
@@ -427,13 +441,15 @@ body(uintptr_t *regbuf)
 void
 ytl_backtrace(VALUE rip, 
 	      VALUE rax, VALUE rcx, VALUE rdx, VALUE rbx, 
-	      VALUE rbp, VALUE rsp, VALUE rdi, VALUE rsi, 
-	      VALUE r8, VALUE r9, VALUE r10, VALUE r11, 
-	      VALUE r12, VALUE r13, VALUE r14, VALUE r15) 
+	      VALUE rbp, VALUE rsp, VALUE rdi, VALUE rsi
+#ifdef __x86_64__
+	      , VALUE r8, VALUE r9, VALUE r10, VALUE r11, 
+	      VALUE r12, VALUE r13, VALUE r14, VALUE r15
+#endif
+	      ) 
 {
   VALUE *argv;
   uintptr_t sp;
-  int i;
 
   argv = ALLOCA_N(VALUE, NUMREGS + 1);
 
@@ -445,6 +461,7 @@ ytl_backtrace(VALUE rip,
   argv[5] = ULONG2NUM(rbp);
   argv[6] = ULONG2NUM(rdi);
   argv[7] = ULONG2NUM(rsi);
+#ifdef __x86_64__
   argv[8] = ULONG2NUM(r8); 
   argv[9] = ULONG2NUM(r9); 
   argv[10] = ULONG2NUM(r10); 
@@ -453,6 +470,7 @@ ytl_backtrace(VALUE rip,
   argv[13] = ULONG2NUM(r13); 
   argv[14] = ULONG2NUM(r14); 
   argv[15] = ULONG2NUM(r15); 
+#endif
   sp = (uintptr_t)rsp;
   sp += NUMREGS * sizeof(uintptr_t); /* reg save area */
   sp += sizeof(uintptr_t); 	/* stored pc by call instruction */
@@ -613,6 +631,8 @@ ytl_ivar_set_boxing(VALUE slf, int off, VALUE val)
     }
   }
   ROBJECT_IVPTR(slf)[off] = val;
+
+  return val;
 }
 
 void 
@@ -670,6 +690,13 @@ Init_ytljit_ext()
   rb_define_method(ytl_cArena, "raw_address", ytl_arena_raw_address, 0);
   rb_define_method(ytl_cArena, "to_s", ytl_arena_to_s, 0);
 
+  ytl_cThread = rb_define_class_under(ytl_mRuntime, "Thread", rb_cObject);
+  rb_define_method(ytl_cThread, "_join", ytl_thread_join, 0);
+  rb_define_method(ytl_cThread, "_merge", ytl_thread_merge, 1);
+  rb_define_method(ytl_cThread, "pself", ytl_thread_pself, 0);
+  rb_define_method(ytl_cThread, "pself=", ytl_thread_set_pself, 1);
+  rb_define_method(ytl_cThread, "cself", ytl_thread_cself, 0);
+
   /* Open Handles */
 #ifdef __CYGWIN__
   OPEN_CHECK(dl_handles[used_dl_handles] = dlopen("cygwin1.dll", RTLD_LAZY));

data/ext/ytljit.h

@@ -316,3 +316,36 @@ typedef struct {
 } rb_binding_t;
 
 rb_iseq_t *rb_method_get_iseq(VALUE method);
+
+#ifndef RCLASS_M_TBL
+#define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
+#endif
+
+#ifndef RCLASS_SUPER
+#define RCLASS_SUPER(c) (RCLASS(c)->ptr->super)
+#endif
+
+#ifndef RCLASS_IV_INDEX_TBL
+#define RCLASS_IV_INDEX_TBL(c) (RCLASS(c)->iv_index_tbl)
+#endif
+
+#ifndef ROBJECT_NUMIV
+#define ROBJECT_NUMIV(o) \
+    ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
+     ROBJECT_EMBED_LEN_MAX : \
+     ROBJECT(o)->as.heap.numiv)
+#endif
+
+#ifndef ROBJECT_IVPTR
+#define ROBJECT_IVPTR(o) \
+    ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
+     ROBJECT(o)->as.ary : \
+     ROBJECT(o)->as.heap.ivptr)
+#endif
+
+#ifndef ROBJECT_IV_INDEX_TBL
+#define ROBJECT_IV_INDEX_TBL(o) \
+    ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
+     RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \
+     ROBJECT(o)->as.heap.iv_index_tbl)
+#endif

data/lib/ytljit.rb

@@ -55,6 +55,6 @@ require 'runtime/object.rb'
 require 'runtime/gc.rb'
 
 module YTLJit
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end
 

data/lib/ytljit/asm.rb

@@ -24,6 +24,7 @@ module YTLJit
       if frame_struct_tab[pc] then
         STDERR.print frame_struct_tab[pc][0].class, "\n"
         STDERR.print frame_struct_tab[pc][0].debug_info, "\n"
+        STDERR.print frame_struct_tab[pc][3], "\n"
         STDERR.print frame_struct_tab[pc][2].map {|n| n.class}, "\n"
         bp = memref(bp)
         backtrace(bp)
@@ -36,6 +37,7 @@ module YTLJit
       frame_struct_tab = VM::Node::TopTopNode.get_frame_struct_tab
       STDERR.print frame_struct_tab[regval[1]][0].debug_info, "\n"
       STDERR.print frame_struct_tab[regval[1]][2].map {|n| n.class}, "\n"
+      STDERR.print frame_struct_tab[regval[1]][3], "\n"
       REGS.each do |rname, no|
         STDERR.print rname
         STDERR.print ": 0x"
@@ -177,16 +179,21 @@ module YTLJit
       @retry_mode = org_retry_mode
     end
 
+    def get_value_table_entity
+      @@value_table_entity
+    end
+
     def add_value_entry(val)
       off= nil
       unless off = @@value_table_cache[val] then
         off = @@value_table_entity.current_pos
         @@value_table_entity.emit([val.value].pack("Q"))
         stfunc = lambda {
-          oldpos = @@value_table_entity.current_pos
-          @@value_table_entity.current_pos = off
-          @@value_table_entity.emit([val.value].pack("Q"))
-          @@value_table_entity.current_pos = oldpos
+          value_table_entity = get_value_table_entity
+          oldpos = value_table_entity.current_pos
+          value_table_entity.current_pos = off
+          value_table_entity.emit([val.value].pack("Q"))
+          value_table_entity.current_pos = oldpos
         }
         val.add_refer(stfunc)
         @@value_table_cache[val] = off

data/lib/ytljit/asmext_x64.rb

@@ -134,7 +134,7 @@ module YTLJit
         offset = 8 + spos * 8
         code += asm.update_state(gen.mov(TMPR, OpIndirect.new(SPR, offset)))
       end
-      code += asm.update_state(gen.send(inst, src, TMPR))
+      code += asm.update_state(gen.send(inst, dst, TMPR))
       code
     end
   end

data/lib/ytljit/asmext_x86.rb

@@ -61,7 +61,7 @@ module YTLJit
       fainfo = gen.funcarg_info
       code = ""
       code += asm.update_state(gen.mov(TMPR, src_opecode))
-      code += asm.update_state(gen.send(inst, src, TMPR))
+      code += asm.update_state(gen.send(inst, dst, TMPR))
       code
     end
   end

data/lib/ytljit/dyna_method.rb

@@ -0,0 +1,136 @@
+require '../../ext/ytljit_ext.so'
+module YTLJit
+  
+=begin
+     Dynamic Method Search 
+     using cuckoo hashing
+=end
+  
+  class CuckooHash
+    PRIMES =  [ 
+               3,
+               5,
+               7,
+               8 + 3,
+               17,
+               16 + 3,
+               32 + 5,
+               64 + 3,
+               128 + 3,
+               256 + 27,
+               512 + 9,
+               1024 + 9,
+               2048 + 5,
+               4096 + 3,
+               8192 + 27,
+               16384 + 43,
+               32768 + 3,
+               65536 + 45,
+               131072 + 29,
+               262144 + 3,
+               524288 + 21,
+               1048576 + 7,
+               2097152 + 17,
+               4194304 + 15,
+               8388608 + 9,
+               16777216 + 43,
+               33554432 + 35,
+               67108864 + 15,
+               134217728 + 29,
+               268435456 + 3,
+               536870912 + 11,
+               1073741824 + 85,
+               0
+              ]
+    
+    def initialize(elements)
+      es = elements.size
+      @plimepos = 0
+      PRIMES.each_with_index do |n, i|
+        if es / 2 < n then
+          @primepos = i
+          break
+        end
+      end
+      @tabsizea = PRIMES[@primepos]
+      @tabsizeb = PRIMES[@primepos - 1]
+      
+      @value = [Array.new(@tabsizea), Array.new(@tabsizeb)]
+      @key = [Array.new(@tabsizea), Array.new(@tabsizeb)]
+      @hfunc = [gen_hash_function_a(@tabsizea), gen_hash_function_b(@tabsizeb)]
+      fill(elements)
+    end
+    
+    def fill(elements)
+      elements.each do |key, value|
+        keyadd = ((key.__id__ >> 1) << 2)
+        insert(keyadd, value)
+      end
+    end
+    def insert(keyadd, value)
+      while true
+        @tabsizea.times do 
+          hv = @hfunc[0].call(keyadd)
+          
+          vala = @value[0][hv]
+          keyadda = @key[0][hv]
+          @value[0][hv] = value
+          @key[0][hv] = keyadd
+          if vala == nil then
+            return true
+          end
+          keyadd = keyadda
+          
+          hv = @hfunc[1].call(keyadd)
+          valb = @value[1][hv]
+          keyaddb = @key[1][hv]
+          @value[1][hv] = vala
+          @key[1][hv] = keyadd
+          if valb == nil then
+            return true
+          end
+          keyadd = keyaddb
+          value = valb
+        end
+        
+        rehash
+      end
+    end
+    
+    def rehash
+      ovalue = @value
+      okey = @key
+      if @tabsizea == @tabsizeb then
+        @primepos += 1
+        @tabsizea = PRIMES[@primepos]
+      else
+        @tabsizeb = PRIMES[@primepos]
+      end
+      @value = [Array.new(@tabsizea), Array.new(@tabsizeb)]
+      @key = [Array.new(@tabsizea), Array.new(@tabsizeb)]
+      @hfunc = [gen_hash_function_a(@tabsizea), gen_hash_function_b(@tabsizeb)]
+      [0, 1].each do |n|
+        okey[n].each_with_index do |ele, i|
+          if ele then
+            insert(ele, ovalue[n][i])
+          end
+        end
+      end
+    end
+    
+    def gen_hash_function_a(size)
+      lambda {|v|
+        (v / 20 + v) % size
+      }
+    end
+    
+    def gen_hash_function_b(size)
+      lambda {|v|
+        ((v / 21) + v * 31) % size
+      }
+    end
+  end
+end
+
+a = YTLJit::CuckooHash.new({})
+p a.gen_hash_function_b(100).to_iseq.to_a