debase-ruby_core_source 3.2.2 → 3.2.3

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-preview3}/shape.h

@@ -4,42 +4,42 @@
 #include "internal/gc.h"
 
 #if (SIZEOF_UINT64_T <= SIZEOF_VALUE)
+
 #define SIZEOF_SHAPE_T 4
 #define SHAPE_IN_BASIC_FLAGS 1
 typedef uint32_t attr_index_t;
+typedef uint32_t shape_id_t;
+typedef uint32_t redblack_id_t;
+# define SHAPE_ID_NUM_BITS 32
+
 #else
+
 #define SIZEOF_SHAPE_T 2
 #define SHAPE_IN_BASIC_FLAGS 0
 typedef uint16_t attr_index_t;
-#endif
-
-#define MAX_IVARS (attr_index_t)(-1)
-
-#if SIZEOF_SHAPE_T == 4
-typedef uint32_t shape_id_t;
-# define SHAPE_ID_NUM_BITS 32
-# define SHAPE_BUFFER_SIZE 0x80000
-#else
 typedef uint16_t shape_id_t;
+typedef uint16_t redblack_id_t;
 # define SHAPE_ID_NUM_BITS 16
-# define SHAPE_BUFFER_SIZE 0x8000
+
 #endif
 
+#define MAX_IVARS (attr_index_t)(-1)
+
 # define SHAPE_MASK (((uintptr_t)1 << SHAPE_ID_NUM_BITS) - 1)
 # define SHAPE_FLAG_MASK (((VALUE)-1) >> SHAPE_ID_NUM_BITS)
 
 # define SHAPE_FLAG_SHIFT ((SIZEOF_VALUE * 8) - SHAPE_ID_NUM_BITS)
 
 # define SHAPE_MAX_VARIATIONS 8
-# define SHAPE_MAX_NUM_IVS 80
 
-# define MAX_SHAPE_ID SHAPE_BUFFER_SIZE
 # define INVALID_SHAPE_ID SHAPE_MASK
 # define ROOT_SHAPE_ID 0x0
 
 # define SPECIAL_CONST_SHAPE_ID (SIZE_POOL_COUNT * 2)
 # define OBJ_TOO_COMPLEX_SHAPE_ID (SPECIAL_CONST_SHAPE_ID + 1)
 
+typedef struct redblack_node redblack_node_t;
+
 struct rb_shape {
     struct rb_id_table * edges; // id_table from ID (ivar) to next shape
     ID edge_name; // ID (ivar) for transition from parent to rb_shape
@@ -48,16 +48,23 @@ struct rb_shape {
     uint8_t type;
     uint8_t size_pool_index;
     shape_id_t parent_id;
+    redblack_node_t * ancestor_index;
 };
 
 typedef struct rb_shape rb_shape_t;
 
+struct redblack_node {
+    ID key;
+    rb_shape_t * value;
+    redblack_id_t l;
+    redblack_id_t r;
+};
+
 enum shape_type {
     SHAPE_ROOT,
     SHAPE_IVAR,
     SHAPE_FROZEN,
     SHAPE_CAPACITY_CHANGE,
-    SHAPE_INITIAL_CAPACITY,
     SHAPE_T_OBJECT,
     SHAPE_OBJ_TOO_COMPLEX,
 };
@@ -67,6 +74,9 @@ typedef struct {
     rb_shape_t *shape_list;
     rb_shape_t *root_shape;
     shape_id_t next_shape_id;
+
+    redblack_node_t *shape_cache;
+    unsigned int cache_size;
 } rb_shape_tree_t;
 RUBY_EXTERN rb_shape_tree_t *rb_shape_tree_ptr;
 
@@ -145,14 +155,14 @@ rb_shape_t* rb_shape_get_shape_by_id(shape_id_t shape_id);
 shape_id_t rb_shape_get_shape_id(VALUE obj);
 rb_shape_t * rb_shape_get_next_iv_shape(rb_shape_t * shape, ID id);
 bool rb_shape_get_iv_index(rb_shape_t * shape, ID id, attr_index_t * value);
+bool rb_shape_get_iv_index_with_hint(shape_id_t shape_id, ID id, attr_index_t * value, shape_id_t *shape_id_hint);
 bool rb_shape_obj_too_complex(VALUE obj);
 
 void rb_shape_set_shape(VALUE obj, rb_shape_t* shape);
 rb_shape_t* rb_shape_get_shape(VALUE obj);
 int rb_shape_frozen_shape_p(rb_shape_t* shape);
-void rb_shape_transition_shape_frozen(VALUE obj);
-void rb_shape_transition_shape_remove_ivar(VALUE obj, ID id, rb_shape_t *shape, VALUE * removed);
-rb_shape_t * rb_shape_transition_shape_capa(rb_shape_t * shape, uint32_t new_capacity);
+rb_shape_t* rb_shape_transition_shape_frozen(VALUE obj);
+bool rb_shape_transition_shape_remove_ivar(VALUE obj, ID id, rb_shape_t *shape, VALUE * removed);
 rb_shape_t* rb_shape_get_next(rb_shape_t* shape, VALUE obj, ID id);
 
 rb_shape_t * rb_shape_rebuild_shape(rb_shape_t * initial_shape, rb_shape_t * dest_shape);
@@ -163,7 +173,7 @@ ROBJECT_IV_CAPACITY(VALUE obj)
     RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
     // Asking for capacity doesn't make sense when the object is using
     // a hash table for storing instance variables
-    RUBY_ASSERT(ROBJECT_SHAPE_ID(obj) != OBJ_TOO_COMPLEX_SHAPE_ID);
+    RUBY_ASSERT(!rb_shape_obj_too_complex(obj));
     return rb_shape_get_shape_by_id(ROBJECT_SHAPE_ID(obj))->capacity;
 }
 
@@ -171,15 +181,15 @@ static inline st_table *
 ROBJECT_IV_HASH(VALUE obj)
 {
     RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
-    RUBY_ASSERT(ROBJECT_SHAPE_ID(obj) == OBJ_TOO_COMPLEX_SHAPE_ID);
+    RUBY_ASSERT(rb_shape_obj_too_complex(obj));
     return (st_table *)ROBJECT(obj)->as.heap.ivptr;
 }
 
 static inline void
-ROBJECT_SET_IV_HASH(VALUE obj, const struct rb_id_table *tbl)
+ROBJECT_SET_IV_HASH(VALUE obj, const st_table *tbl)
 {
     RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
-    RUBY_ASSERT(ROBJECT_SHAPE_ID(obj) == OBJ_TOO_COMPLEX_SHAPE_ID);
+    RUBY_ASSERT(rb_shape_obj_too_complex(obj));
     ROBJECT(obj)->as.heap.ivptr = (VALUE *)tbl;
 }
 
@@ -188,12 +198,12 @@ size_t rb_id_table_size(const struct rb_id_table *tbl);
 static inline uint32_t
 ROBJECT_IV_COUNT(VALUE obj)
 {
-    if (ROBJECT_SHAPE_ID(obj) == OBJ_TOO_COMPLEX_SHAPE_ID) {
+    if (rb_shape_obj_too_complex(obj)) {
         return (uint32_t)rb_st_table_size(ROBJECT_IV_HASH(obj));
     }
     else {
         RBIMPL_ASSERT_TYPE(obj, RUBY_T_OBJECT);
-        RUBY_ASSERT(ROBJECT_SHAPE_ID(obj) != OBJ_TOO_COMPLEX_SHAPE_ID);
+        RUBY_ASSERT(!rb_shape_obj_too_complex(obj));
         return rb_shape_get_shape_by_id(ROBJECT_SHAPE_ID(obj))->next_iv_index;
     }
 }

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-preview3}/symbol.h

@@ -109,10 +109,9 @@ is_global_name_punct(const int c)
     return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
 }
 
-int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset);
-
 RUBY_SYMBOL_EXPORT_BEGIN
 
+int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset);
 size_t rb_sym_immortal_count(void);
 
 RUBY_SYMBOL_EXPORT_END

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-preview3}/thread_none.h

@@ -16,5 +16,6 @@ struct rb_thread_sched_item {};
 struct rb_thread_sched {};
 
 RUBY_EXTERN struct rb_execution_context_struct *ruby_current_ec;
+NOINLINE(struct rb_execution_context_struct *rb_current_ec_noinline(void)); // for assertions
 
 #endif /* RUBY_THREAD_NONE_H */

data/lib/debase/ruby_core_source/ruby-3.3.0-preview3/thread_pthread.h

@@ -0,0 +1,166 @@
+#ifndef RUBY_THREAD_PTHREAD_H
+#define RUBY_THREAD_PTHREAD_H
+/**********************************************************************
+
+  thread_pthread.h -
+
+  $Author$
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifdef HAVE_PTHREAD_NP_H
+#include <pthread_np.h>
+#endif
+
+#define RB_NATIVETHREAD_LOCK_INIT PTHREAD_MUTEX_INITIALIZER
+#define RB_NATIVETHREAD_COND_INIT PTHREAD_COND_INITIALIZER
+
+// per-Thead scheduler helper data
+struct rb_thread_sched_item {
+    struct {
+        struct ccan_list_node ubf;
+
+        // connected to ractor->threads.sched.reqdyq
+        // locked by ractor->threads.sched.lock
+        struct ccan_list_node readyq;
+
+        // connected to vm->ractor.sched.timeslice_threads
+        // locked by vm->ractor.sched.lock
+        struct ccan_list_node timeslice_threads;
+
+        // connected to vm->ractor.sched.running_threads
+        // locked by vm->ractor.sched.lock
+        struct ccan_list_node running_threads;
+
+        // connected to vm->ractor.sched.zombie_threads
+        struct ccan_list_node zombie_threads;
+    } node;
+
+    // this data should be protected by timer_th.waiting_lock
+    struct {
+        enum thread_sched_waiting_flag {
+            thread_sched_waiting_none     = 0x00,
+            thread_sched_waiting_timeout  = 0x01,
+            thread_sched_waiting_io_read  = 0x02,
+            thread_sched_waiting_io_write = 0x08,
+            thread_sched_waiting_io_force = 0x40, // ignore readable
+        } flags;
+
+        struct {
+            // should be compat with hrtime.h
+#ifdef MY_RUBY_BUILD_MAY_TIME_TRAVEL
+            int128_t timeout;
+#else
+            uint64_t timeout;
+#endif
+            int fd; // -1 for timeout only
+            int result;
+        } data;
+
+        // connected to timer_th.waiting
+        struct ccan_list_node node;
+    } waiting_reason;
+
+    bool finished;
+    bool malloc_stack;
+    void *context_stack;
+    struct coroutine_context *context;
+};
+
+struct rb_native_thread {
+    rb_atomic_t serial;
+    struct rb_vm_struct *vm;
+
+    rb_nativethread_id_t thread_id;
+
+#ifdef RB_THREAD_T_HAS_NATIVE_ID
+    int tid;
+#endif
+
+    struct rb_thread_struct *running_thread;
+
+    // to control native thread
+#if defined(__GLIBC__) || defined(__FreeBSD__)
+    union
+#else
+    /*
+     * assume the platform condvars are badly implemented and have a
+     * "memory" of which mutex they're associated with
+     */
+    struct
+#endif
+      {
+        rb_nativethread_cond_t intr; /* th->interrupt_lock */
+        rb_nativethread_cond_t readyq; /* use sched->lock */
+    } cond;
+
+#ifdef USE_SIGALTSTACK
+    void *altstack;
+#endif
+
+    struct coroutine_context *nt_context;
+    int dedicated;
+
+    size_t machine_stack_maxsize;
+};
+
+#undef except
+#undef try
+#undef leave
+#undef finally
+
+// per-Ractor
+struct rb_thread_sched {
+    rb_nativethread_lock_t lock_;
+#if VM_CHECK_MODE
+    struct rb_thread_struct *lock_owner;
+#endif
+    struct rb_thread_struct *running; // running thread or NULL
+    bool is_running;
+    bool is_running_timeslice;
+    bool enable_mn_threads;
+
+    struct ccan_list_head readyq;
+    int readyq_cnt;
+    // ractor scheduling
+    struct ccan_list_node grq_node;
+};
+
+#ifdef RB_THREAD_LOCAL_SPECIFIER
+  NOINLINE(void rb_current_ec_set(struct rb_execution_context_struct *));
+  NOINLINE(struct rb_execution_context_struct *rb_current_ec_noinline(void));
+
+  # ifdef __APPLE__
+    // on Darwin, TLS can not be accessed across .so
+    struct rb_execution_context_struct *rb_current_ec(void);
+  # else
+    RUBY_EXTERN RB_THREAD_LOCAL_SPECIFIER struct rb_execution_context_struct *ruby_current_ec;
+
+    // for RUBY_DEBUG_LOG()
+    RUBY_EXTERN RB_THREAD_LOCAL_SPECIFIER rb_atomic_t ruby_nt_serial;
+    #define RUBY_NT_SERIAL 1
+  # endif
+#else
+typedef pthread_key_t native_tls_key_t;
+
+static inline void *
+native_tls_get(native_tls_key_t key)
+{
+    // return value should be checked by caller
+    return pthread_getspecific(key);
+}
+
+static inline void
+native_tls_set(native_tls_key_t key, void *ptr)
+{
+    if (UNLIKELY(pthread_setspecific(key, ptr) != 0)) {
+        rb_bug("pthread_setspecific error");
+    }
+}
+
+RUBY_EXTERN native_tls_key_t ruby_current_ec_key;
+#endif
+
+#endif /* RUBY_THREAD_PTHREAD_H */

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-preview3}/thread_win32.h

@@ -27,7 +27,7 @@ struct rb_native_thread {
 };
 
 struct rb_thread_sched_item {
-    char dmy;
+    void *vm_stack;
 };
 
 struct rb_thread_sched {

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-preview3}/variable.h

@@ -16,8 +16,15 @@ struct gen_ivtbl {
 #if !SHAPE_IN_BASIC_FLAGS
     uint16_t shape_id;
 #endif
-    uint32_t numiv;
-    VALUE ivptr[FLEX_ARY_LEN];
+    union {
+        struct {
+            uint32_t numiv;
+            VALUE ivptr[1];
+        } shape;
+        struct {
+            st_table *table;
+        } complex;
+    } as;
 };
 
 int rb_ivar_generic_ivtbl_lookup(VALUE obj, struct gen_ivtbl **);

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-preview3}/version.h

@@ -55,11 +55,15 @@
 #endif
 
 #if RUBY_PATCHLEVEL == -1
-#define RUBY_PATCHLEVEL_STR "preview2"
+# ifdef RUBY_PATCHLEVEL_NAME
+#  define RUBY_PATCHLEVEL_STR STRINGIZE(RUBY_PATCHLEVEL_NAME)
+# else
+#  define RUBY_PATCHLEVEL_STR "dev"
+# endif
 #elif defined RUBY_ABI_VERSION
-#error RUBY_ABI_VERSION is defined in non-development branch
+# error RUBY_ABI_VERSION is defined in non-development branch
 #else
-#define RUBY_PATCHLEVEL_STR ""
+# define RUBY_PATCHLEVEL_STR ""
 #endif
 
 #endif /* RUBY_TOPLEVEL_VERSION_H */