Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

* gc.h (STACK_UPPER): moved from gc.c

* thread.c, thread_{pthread,win32}.c (ruby_init_stack,
  ruby_thread_init_stack): moved stack initialization from gc.c.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17155 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
  • Loading branch information...
commit fc3c60f6081d85f6274986a7a08b59db1515fcb5 1 parent 436b02b
@nobu nobu authored
View
14 ChangeLog
@@ -1,3 +1,17 @@
+Sat Jun 14 11:59:17 2008 Nobuyoshi Nakada <nobu@ruby-lang.org>
+
+ * gc.h (STACK_UPPER): moved from gc.c
+
+ * thread.c, thread_{pthread,win32}.c (ruby_init_stack,
+ ruby_thread_init_stack): moved stack initialization from gc.c.
+
+Sat Jun 14 11:57:53 2008 Nobuyoshi Nakada <nobu@ruby-lang.org>
+
+ * gc.h (STACK_UPPER): moved from gc.c
+
+ * thread.c, thread_{pthread,win32}.c (ruby_init_stack,
+ ruby_thread_init_stack): moved stack initialization from gc.c.
+
Sat Jun 14 07:52:53 2008 Tanaka Akira <akr@fsij.org>
* gc.c (ruby_initial_gc_stress): defined.
View
90 gc.c
@@ -244,25 +244,9 @@ rb_objspace_alloc(void)
#define HEAP_OBJ_LIMIT (HEAP_SIZE / sizeof(struct RVALUE))
extern st_table *rb_class_tbl;
-VALUE *rb_gc_stack_start = 0;
-#ifdef __ia64
-VALUE *rb_gc_register_stack_start = 0;
-#endif
int ruby_disable_gc_stress = 0;
-
-#ifdef DJGPP
-/* set stack size (http://www.delorie.com/djgpp/v2faq/faq15_9.html) */
-unsigned int _stklen = 0x180000; /* 1.5 kB */
-#endif
-
-#if defined(DJGPP) || defined(_WIN32_WCE)
-size_t rb_gc_stack_maxsize = 65535*sizeof(VALUE);
-#else
-size_t rb_gc_stack_maxsize = 655300*sizeof(VALUE);
-#endif
-
static void run_final(rb_objspace_t *objspace, VALUE obj);
static int garbage_collect(rb_objspace_t *objspace);
@@ -790,23 +774,17 @@ rb_data_object_alloc(VALUE klass, void *datap, RUBY_DATA_FUNC dmark, RUBY_DATA_F
# define STACK_LENGTH ((STACK_END < STACK_START) ? STACK_START - STACK_END\
: STACK_END - STACK_START + 1)
#endif
-#if STACK_GROW_DIRECTION > 0
-# define STACK_UPPER(x, a, b) a
-#elif STACK_GROW_DIRECTION < 0
-# define STACK_UPPER(x, a, b) b
-#else
-static int grow_direction;
-static int
-stack_grow_direction(VALUE *addr)
+#if !STACK_GROW_DIRECTION
+int ruby_stack_grow_direction;
+int
+ruby_get_stack_grow_direction(VALUE *addr)
{
rb_thread_t *th = GET_THREAD();
SET_STACK_END;
- if (STACK_END > addr) return grow_direction = 1;
- return grow_direction = -1;
+ if (STACK_END > addr) return ruby_stack_grow_direction = 1;
+ return ruby_stack_grow_direction = -1;
}
-# define stack_growup_p(x) ((grow_direction ? grow_direction : stack_grow_direction(x)) > 0)
-# define STACK_UPPER(x, a, b) (stack_growup_p(x) ? a : b)
#endif
#define GC_WATER_MARK 512
@@ -1786,12 +1764,6 @@ rb_gc_start(void)
return Qnil;
}
-void
-ruby_set_stack_size(size_t size)
-{
- rb_gc_stack_maxsize = size;
-}
-
#undef Init_stack
void
@@ -1800,53 +1772,6 @@ Init_stack(VALUE *addr)
ruby_init_stack(addr);
}
-#undef ruby_init_stack
-void
-ruby_init_stack(VALUE *addr
-#ifdef __ia64
- , void *bsp
-#endif
- )
-{
- if (!rb_gc_stack_start ||
- STACK_UPPER(&addr,
- rb_gc_stack_start > addr,
- rb_gc_stack_start < addr)) {
- rb_gc_stack_start = addr;
- }
-#ifdef __ia64
- if (!rb_gc_register_stack_start ||
- (VALUE*)bsp < rb_gc_register_stack_start) {
- rb_gc_register_stack_start = (VALUE*)bsp;
- }
-#endif
-#ifdef HAVE_GETRLIMIT
- {
- struct rlimit rlim;
-
- if (getrlimit(RLIMIT_STACK, &rlim) == 0) {
- unsigned int space = rlim.rlim_cur/5;
-
- if (space > 1024*1024) space = 1024*1024;
- rb_gc_stack_maxsize = rlim.rlim_cur - space;
- }
- }
-#elif defined _WIN32
- {
- MEMORY_BASIC_INFORMATION mi;
- DWORD size;
- DWORD space;
-
- if (VirtualQuery(&mi, &mi, sizeof(mi))) {
- size = (char *)mi.BaseAddress - (char *)mi.AllocationBase;
- space = size / 5;
- if (space > 1024*1024) space = 1024*1024;
- rb_gc_stack_maxsize = size - space;
- }
- }
-#endif
-}
-
/*
* Document-class: ObjectSpace
*
@@ -1881,9 +1806,6 @@ ruby_init_stack(VALUE *addr
void
Init_heap(void)
{
- if (!rb_gc_stack_start) {
- Init_stack(0);
- }
init_heap(&rb_objspace);
}
View
16 gc.h
@@ -57,5 +57,19 @@ rb_gc_debug_body(char *mode, char *msg, int st, void *ptr)
#define RUBY_MARK_UNLESS_NULL(ptr) if(RTEST(ptr)){rb_gc_mark(ptr);}
#define RUBY_FREE_UNLESS_NULL(ptr) if(ptr){ruby_xfree(ptr);}
-#endif /* RUBY_GC_H */
+#if STACK_GROW_DIRECTION > 0
+# define STACK_UPPER(x, a, b) a
+#elif STACK_GROW_DIRECTION < 0
+# define STACK_UPPER(x, a, b) b
+#else
+RUBY_EXTERN int ruby_stack_grow_direction;
+int ruby_get_stack_grow_direction(VALUE *addr);
+# define stack_growup_p(x) ( \
+ (ruby_stack_grow_direction ? \
+ ruby_stack_grow_direction : \
+ ruby_get_stack_grow_direction(x)) > 0)
+# define STACK_UPPER(x, a, b) (stack_growup_p(x) ? a : b)
+#endif
+
+#endif /* RUBY_GC_H */
View
6 thread.c
@@ -309,6 +309,12 @@ extern void ruby_error_print(void);
static VALUE rb_thread_raise(int, VALUE *, rb_thread_t *);
void rb_thread_recycle_stack_release(VALUE *);
+void
+ruby_thread_init_stack(rb_thread_t *th)
+{
+ native_thread_init_stack(th);
+}
+
static int
thread_start_func_2(rb_thread_t *th, VALUE *stack_start, VALUE *register_stack_start)
{
View
87 thread_pthread.c
@@ -11,6 +11,12 @@
#ifdef THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION
+#include "gc.h"
+
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+
static void native_mutex_lock(pthread_mutex_t *lock);
static void native_mutex_unlock(pthread_mutex_t *lock);
static int native_mutex_trylock(pthread_mutex_t *lock);
@@ -164,6 +170,84 @@ native_thread_destroy(rb_thread_t *th)
#define USE_THREAD_CACHE 0
+static struct {
+ rb_thread_id_t id;
+ size_t stack_maxsize;
+ VALUE *stack_start;
+#ifdef __ia64
+ VALUE *register_stack_start;
+#endif
+} native_main_thread;
+
+#undef ruby_init_stack
+void
+ruby_init_stack(VALUE *addr
+#ifdef __ia64
+ , void *bsp
+#endif
+ )
+{
+ native_main_thread.id = pthread_self();
+ if (!native_main_thread.stack_start ||
+ STACK_UPPER(&addr,
+ native_main_thread.stack_start > addr,
+ native_main_thread.stack_start < addr)) {
+ native_main_thread.stack_start = addr;
+ }
+#ifdef __ia64
+ if (!native_main_thread.register_stack_start ||
+ (VALUE*)bsp < native_main_thread.register_stack_start) {
+ native_main_thread.register_stack_start = (VALUE*)bsp;
+ }
+#endif
+#ifdef HAVE_GETRLIMIT
+ {
+ struct rlimit rlim;
+
+ if (getrlimit(RLIMIT_STACK, &rlim) == 0) {
+ unsigned int space = rlim.rlim_cur/5;
+
+ if (space > 1024*1024) space = 1024*1024;
+ native_main_thread.stack_maxsize = rlim.rlim_cur - space;
+ }
+ }
+#endif
+}
+
+#define CHECK_ERR(expr) \
+ {int err = (expr); if (err) {rb_bug("err: %d - %s", err, #expr);}}
+
+static int
+native_thread_init_stack(rb_thread_t *th)
+{
+ rb_thread_id_t curr = pthread_self();
+
+ if (pthread_equal(curr, native_main_thread.id)) {
+ th->machine_stack_start = native_main_thread.stack_start;
+ th->machine_stack_maxsize = native_main_thread.stack_maxsize;
+ }
+ else {
+#ifdef HAVE_PTHREAD_GETATTR_NP
+ pthread_attr_t attr;
+ CHECK_ERR(pthread_getattr_np(curr, &attr));
+# if defined HAVE_PTHREAD_ATTR_GETSTACK
+ CHECK_ERR(pthread_attr_getstack(&attr, &th->machine_stack_start, &th->machine_stack_maxsize));
+# elif defined HAVE_PTHREAD_ATTR_GETSTACKSIZE && defined HAVE_PTHREAD_ATTR_GETSTACKADDR
+ CHECK_ERR(pthread_attr_getstackaddr(&attr, &th->machine_stack_start));
+ CHECK_ERR(pthread_attr_getstacksize(&attr, &th->machine_stack_maxsize));
+# endif
+#else
+ rb_raise(rb_eNotImpError, "ruby engine can initialize only in the main thread");
+#endif
+ }
+#ifdef __ia64
+ th->machine_register_stack_start = native_main_thread.register_stack_start;
+ th->machine_stack_maxsize /= 2;
+ th->machine_register_stack_maxsize = th->machine_stack_maxsize;
+#endif
+ return 0;
+}
+
static void *
thread_start_func_1(void *th_ptr)
{
@@ -282,9 +366,6 @@ use_cached_thread(rb_thread_t *th)
return result;
}
-#define CHECK_ERR(expr) \
- { int err; if ((err = (expr)) != 0) { rb_bug("err: %d - %s", err, #expr); }}
-
static int
native_thread_create(rb_thread_t *th)
{
View
31 thread_win32.c
@@ -424,6 +424,32 @@ native_cond_destroy(rb_thread_cond_t *cond)
/* */
}
+void
+ruby_init_stack(VALUE *addr)
+{
+}
+
+#define CHECK_ERR(expr) \
+ {if (!(expr)) {rb_bug("err: %lu - %s", GetLastError(), #expr);}}
+
+static void
+native_thread_init_stack(rb_thread_t *th)
+{
+ MEMORY_BASIC_INFORMATION mi;
+ char *base, *end;
+ DWORD size, space;
+
+ CHECK_ERR(VirtualQuery(&mi, &mi, sizeof(mi)));
+ base = mi.AllocationBase;
+ end = mi.BaseAddress;
+ end += mi.RegionSize;
+ size = end - base;
+ space = size / 5;
+ if (space > 1024*1024) space = 1024*1024;
+ th->machine_stack_start = (VALUE *)end - 1;
+ th->machine_stack_maxsize = size - space;
+}
+
static void
native_thread_destroy(rb_thread_t *th)
{
@@ -441,6 +467,7 @@ thread_start_func_1(void *th_ptr)
VALUE stack_start;
volatile HANDLE thread_id = th->thread_id;
+ native_thread_init_stack(th);
th->native_thread_data.interrupt_event = CreateEvent(0, TRUE, FALSE, 0);
/* run */
@@ -453,16 +480,12 @@ thread_start_func_1(void *th_ptr)
return 0;
}
-extern size_t rb_gc_stack_maxsize;
-
static int
native_thread_create(rb_thread_t *th)
{
size_t stack_size = 4 * 1024; /* 4KB */
th->thread_id = w32_create_thread(stack_size, thread_start_func_1, th);
- th->machine_stack_maxsize = rb_gc_stack_maxsize; /* not tested. */
-
if ((th->thread_id) == 0) {
st_delete_wrap(th->vm->living_threads, th->self);
rb_raise(rb_eThreadError, "can't create Thread (%d)", errno);
View
25 vm.c
@@ -1576,8 +1576,10 @@ thread_alloc(VALUE klass)
}
static void
-th_init2(rb_thread_t *th)
+th_init2(rb_thread_t *th, VALUE self)
{
+ th->self = self;
+
/* allocate thread stack */
th->stack_size = RUBY_VM_THREAD_STACK_SIZE;
th->stack = thread_recycle_stack(th->stack_size);
@@ -1596,9 +1598,9 @@ th_init2(rb_thread_t *th)
}
static void
-th_init(rb_thread_t *th)
+th_init(rb_thread_t *th, VALUE self)
{
- th_init2(th);
+ th_init2(th, self);
}
static VALUE
@@ -1608,8 +1610,7 @@ ruby_thread_init(VALUE self)
rb_vm_t *vm = GET_THREAD()->vm;
GetThreadPtr(self, th);
- th_init(th);
- th->self = self;
+ th_init(th, self);
th->vm = vm;
th->top_wrapper = 0;
@@ -1763,6 +1764,7 @@ Init_VM(void)
#if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE
struct rb_objspace *rb_objspace_alloc(void);
#endif
+void ruby_thread_init_stack(rb_thread_t *th);
void
Init_BareVM(void)
@@ -1780,15 +1782,9 @@ Init_BareVM(void)
#endif
ruby_current_vm = vm;
- th_init2(th);
+ th_init2(th, 0);
th->vm = vm;
- th->machine_stack_start = rb_gc_stack_start;
- th->machine_stack_maxsize = rb_gc_stack_maxsize;
-#ifdef __ia64
- th->machine_register_stack_start = rb_gc_register_stack_start;
- th->machine_stack_maxsize /= 2;
- th->machine_register_stack_maxsize = th->machine_stack_maxsize;
-#endif
+ ruby_thread_init_stack(th);
}
/* top self */
@@ -1832,7 +1828,8 @@ rb_ruby_verbose_ptr(void)
return ruby_vm_verbose_ptr(GET_VM());
}
-VALUE *rb_ruby_debug_ptr(void)
+VALUE *
+rb_ruby_debug_ptr(void)
{
return ruby_vm_debug_ptr(GET_VM());
}
Please sign in to comment.
Something went wrong with that request. Please try again.