1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* vm.c: refactoring Proc/Env related code.

Browse Source 
* vm_core.h: remove blockprocval field from rb_proc_t and rb_binding_t.
  Instead of this field, mark given block in Proc at rb_env_t::env.
* vm.c (vm_make_env_each): make an Env object with this layout.
  And also simplify parameters.
* proc.c: catch up this fix.
* vm_core.h: remove rb_env_t::local_size because it is not used.
* vm_dump.c (rb_vmdebug_env_dump_raw): catch up this fix.
* vm_core.h (rb_vm_make_env_object): remove rb_vm_make_env_object()
  because it is only refered from vm.c.
* vm_eval.c (eval_string_with_cref): catch up this fix.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@51243 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
ko1 2015-07-14 16:23:17 +00:00
parent 50ae750646
commit a82ce7c556
6 changed files with 117 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
ChangeLog
View File

@ -1,3 +1,24 @@
Wed Jul 15 01:09:09 2015 Koichi Sasada <ko1@atdot.net>
* vm.c: refactoring Proc/Env related code.
* vm_core.h: remove blockprocval field from rb_proc_t and rb_binding_t.
Instead of this field, mark given block in Proc at rb_env_t::env.
* vm.c (vm_make_env_each): make an Env object with this layout.
And also simplify parameters.
* proc.c: catch up this fix.
* vm_core.h: remove rb_env_t::local_size because it is not used.
* vm_dump.c (rb_vmdebug_env_dump_raw): catch up this fix.
* vm_core.h (rb_vm_make_env_object): remove rb_vm_make_env_object()
because it is only refered from vm.c.
* vm_eval.c (eval_string_with_cref): catch up this fix.
Wed Jul 15 00:03:36 2015 Kazuhiro NISHIYAMA <zn@mbf.nifty.com> Wed Jul 15 00:03:36 2015 Kazuhiro NISHIYAMA <zn@mbf.nifty.com>
* gc.c (__has_feature): move into internal.h. * gc.c (__has_feature): move into internal.h.

6
proc.c
View File

@ -48,7 +48,6 @@ proc_mark(void *ptr)
rb_proc_t *proc = ptr; rb_proc_t *proc = ptr;
RUBY_MARK_ENTER("proc"); RUBY_MARK_ENTER("proc");
RUBY_MARK_UNLESS_NULL(proc->envval); RUBY_MARK_UNLESS_NULL(proc->envval);
RUBY_MARK_UNLESS_NULL(proc->blockprocval);
RUBY_MARK_UNLESS_NULL(proc->block.proc); RUBY_MARK_UNLESS_NULL(proc->block.proc);
RUBY_MARK_UNLESS_NULL(proc->block.self); RUBY_MARK_UNLESS_NULL(proc->block.self);
if (proc->block.iseq && RUBY_VM_IFUNC_P(proc->block.iseq)) { if (proc->block.iseq && RUBY_VM_IFUNC_P(proc->block.iseq)) {
@ -251,7 +250,6 @@ binding_mark(void *ptr)
bind = ptr; bind = ptr;
RUBY_MARK_UNLESS_NULL(bind->env); RUBY_MARK_UNLESS_NULL(bind->env);
RUBY_MARK_UNLESS_NULL(bind->path); RUBY_MARK_UNLESS_NULL(bind->path);
RUBY_MARK_UNLESS_NULL(bind->blockprocval);
} }
RUBY_MARK_LEAVE("binding"); RUBY_MARK_LEAVE("binding");
} }
@ -291,7 +289,6 @@ binding_dup(VALUE self)
GetBindingPtr(bindval, dst); GetBindingPtr(bindval, dst);
dst->env = src->env; dst->env = src->env;
dst->path = src->path; dst->path = src->path;
dst->blockprocval = src->blockprocval;
dst->first_lineno = src->first_lineno; dst->first_lineno = src->first_lineno;
return bindval; return bindval;
} }
@ -2500,7 +2497,7 @@ env_clone(VALUE envval, VALUE receiver, const rb_cref_t *cref)
} }
GetEnvPtr(envval, env); GetEnvPtr(envval, env);
envsize = sizeof(rb_env_t) + (env->local_size + 1) * sizeof(VALUE); envsize = sizeof(rb_env_t) + (env->env_size - 1) * sizeof(VALUE);
newenv = xmalloc(envsize); newenv = xmalloc(envsize);
memcpy(newenv, env, envsize); memcpy(newenv, env, envsize);
RTYPEDDATA_DATA(newenvval) = newenv; RTYPEDDATA_DATA(newenvval) = newenv;
@ -2548,7 +2545,6 @@ proc_binding(VALUE self)
bindval = rb_binding_alloc(rb_cBinding); bindval = rb_binding_alloc(rb_cBinding);
GetBindingPtr(bindval, bind); GetBindingPtr(bindval, bind);
bind->env = envval; bind->env = envval;
bind->blockprocval = proc->blockprocval;
if (!RUBY_VM_NORMAL_ISEQ_P(iseq)) { if (!RUBY_VM_NORMAL_ISEQ_P(iseq)) {
if (RUBY_VM_IFUNC_P(iseq) && IS_METHOD_PROC_ISEQ(iseq)) { if (RUBY_VM_IFUNC_P(iseq) && IS_METHOD_PROC_ISEQ(iseq)) {

207
vm.c
View File

@ -129,6 +129,8 @@ static void vm_collect_usage_insn(int insn);
static void vm_collect_usage_register(int reg, int isset); static void vm_collect_usage_register(int reg, int isset);
#endif #endif
static VALUE vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp);
static VALUE static VALUE
vm_invoke_bmethod(rb_thread_t *th, rb_proc_t *proc, VALUE self, vm_invoke_bmethod(rb_thread_t *th, rb_proc_t *proc, VALUE self,
int argc, const VALUE *argv, const rb_block_t *blockptr); int argc, const VALUE *argv, const rb_block_t *blockptr);
@ -289,7 +291,7 @@ vm_set_main_stack(rb_thread_t *th, VALUE iseqval)
/* save binding */ /* save binding */
GetISeqPtr(iseqval, iseq); GetISeqPtr(iseqval, iseq);
if (bind && iseq->local_size > 0) { if (bind && iseq->local_size > 0) {
bind->env = rb_vm_make_env_object(th, th->cfp); bind->env = vm_make_env_object(th, th->cfp);
} }
} }
@ -481,60 +483,83 @@ check_env_value(VALUE envval)
return Qnil; /* unreachable */ return Qnil; /* unreachable */
} }
/* return Qfalse if proc was already created */
static VALUE static VALUE
vm_make_env_each(const rb_thread_t *const th, rb_control_frame_t *const cfp, vm_make_proc_from_block(rb_thread_t *th, rb_block_t *block)
VALUE *envptr, const VALUE *const endptr)
{ {
VALUE envval, penvval = 0; if (!block->proc) {
rb_env_t *env; block->proc = rb_vm_make_proc(th, block, rb_cProc);
VALUE *nenvptr; return block->proc;
int i, local_size;
if (ENV_IN_HEAP_P(th, envptr)) {
return ENV_VAL(envptr);
}
if (envptr != endptr) {
VALUE *penvptr = GC_GUARDED_PTR_REF(*envptr);
rb_control_frame_t *pcfp = cfp;
if (ENV_IN_HEAP_P(th, penvptr)) {
penvval = ENV_VAL(penvptr);
} }
else { else {
while (pcfp->ep != penvptr) { return Qfalse;
pcfp++;
if (pcfp->ep == 0) {
SDR();
rb_bug("invalid ep");
} }
} }
penvval = vm_make_env_each(th, pcfp, penvptr, endptr);
*envptr = VM_ENVVAL_PREV_EP_PTR(pcfp->ep); static VALUE
vm_make_env_each(rb_thread_t *const th, rb_control_frame_t *const cfp)
{
VALUE envval, penvval = 0, blockprocval = 0;
VALUE * const ep = cfp->ep;
rb_env_t *env;
VALUE *new_ep;
int i, local_size, env_size;
if (ENV_IN_HEAP_P(th, ep)) {
return ENV_VAL(ep);
}
if (!VM_EP_LEP_P(ep)) {
VALUE *prev_ep = VM_EP_PREV_EP(ep);
if (ENV_IN_HEAP_P(th, prev_ep)) {
penvval = ENV_VAL(prev_ep);
}
else {
rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
while (prev_cfp->ep != prev_ep) {
prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(prev_cfp);
if (VM_CHECK_MODE > 0 && prev_cfp->ep == 0) rb_bug("invalid ep");
}
penvval = vm_make_env_each(th, prev_cfp);
*ep = VM_ENVVAL_PREV_EP_PTR(prev_cfp->ep);
}
}
else {
rb_block_t *block = VM_EP_BLOCK_PTR(ep);
if (block && (blockprocval = vm_make_proc_from_block(th, block)) != Qfalse) {
rb_proc_t *p;
GetProcPtr(blockprocval, p);
*ep = VM_ENVVAL_BLOCK_PTR(&p->block);
} }
} }
if (!RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) { if (!RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
local_size = 2; /* specva + cref/me */ local_size = 1; /* cref/me */
} }
else { else {
local_size = cfp->iseq->local_size; local_size = cfp->iseq->local_size;
} }
envval = TypedData_Wrap_Struct(rb_cEnv, &env_data_type, 0); env_size = local_size +
/* allocate env */ 1 /* specval */ +
env = xmalloc(sizeof(rb_env_t) + ((local_size + 1) * sizeof(VALUE))); 1 /* envval */ +
env->env_size = local_size + 1 + 1; (blockprocval ? 1 : 0) /* blockprocval */;
env->local_size = local_size;
i = local_size + 1; envval = TypedData_Wrap_Struct(rb_cEnv, &env_data_type, 0);
MEMCPY(env->env, envptr - local_size, VALUE, i); env = xmalloc(sizeof(rb_env_t) + (env_size - 1 /* rb_env_t::env[1] */) * sizeof(VALUE));
env->env_size = env_size;
i = local_size + 1 /* specval */;
MEMCPY(env->env, ep - local_size, VALUE, i);
#if 0 #if 0
for (i = 0; i <= local_size; i++) { for (i = 0; i <= local_size; i++) {
fprintf(stderr, "%2d ", &envptr[-local_size + i] - th->stack); dp(env->env[i]);
if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) { if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)) {
/* clear value stack for GC */ /* clear value stack for GC */
envptr[-local_size + i] = 0; ep[-local_size + i] = 0;
} }
} }
#endif #endif
@ -548,16 +573,14 @@ vm_make_env_each(const rb_thread_t *const th, rb_control_frame_t *const cfp,
*/ */
env->prev_envval = penvval; env->prev_envval = penvval;
*envptr = envval; /* GC mark */ *ep = envval; /* GC mark */
nenvptr = &env->env[i - 1]; new_ep = &env->env[i - 1];
nenvptr[1] = envval; /* frame self */ new_ep[1] = envval;
if (blockprocval) new_ep[2] = blockprocval;
/* reset ep in cfp */
cfp->ep = nenvptr;
/* as Binding */ /* as Binding */
env->block.self = cfp->self; env->block.self = cfp->self;
env->block.ep = cfp->ep; env->block.ep = cfp->ep = new_ep;
env->block.iseq = cfp->iseq; env->block.iseq = cfp->iseq;
env->block.proc = 0; env->block.proc = 0;
@ -565,9 +588,32 @@ vm_make_env_each(const rb_thread_t *const th, rb_control_frame_t *const cfp,
/* TODO */ /* TODO */
env->block.iseq = 0; env->block.iseq = 0;
} }
return envval; return envval;
} }
static VALUE
vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp)
{
VALUE envval = vm_make_env_each(th, cfp);
if (PROCDEBUG) {
check_env_value(envval);
}
return envval;
}
void
rb_vm_stack_to_heap(rb_thread_t *th)
{
rb_control_frame_t *cfp = th->cfp;
while ((cfp = rb_vm_get_binding_creatable_next_cfp(th, cfp)) != 0) {
vm_make_env_object(th, cfp);
cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
}
}
static int static int
collect_local_variables_in_iseq(const rb_iseq_t *iseq, const struct local_var_list *vars) collect_local_variables_in_iseq(const rb_iseq_t *iseq, const struct local_var_list *vars)
{ {
@ -615,65 +661,11 @@ rb_vm_env_local_variables(VALUE envval)
return local_var_list_finish(&vars); return local_var_list_finish(&vars);
} }
static VALUE vm_make_proc_from_block(rb_thread_t *th, rb_block_t *block);
static VALUE vm_make_env_object(rb_thread_t * th, rb_control_frame_t *cfp, VALUE *blockprocptr);
VALUE
rb_vm_make_env_object(rb_thread_t * th, rb_control_frame_t *cfp)
{
VALUE blockprocval;
return vm_make_env_object(th, cfp, &blockprocval);
}
static VALUE
vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp, VALUE *blockprocptr)
{
VALUE envval;
VALUE *lep = VM_CF_LEP(cfp);
rb_block_t *blockptr = VM_EP_BLOCK_PTR(lep);
if (blockptr) {
VALUE blockprocval = vm_make_proc_from_block(th, blockptr);
rb_proc_t *p;
GetProcPtr(blockprocval, p);
lep[0] = VM_ENVVAL_BLOCK_PTR(&p->block);
*blockprocptr = blockprocval;
}
envval = vm_make_env_each(th, cfp, cfp->ep, lep);
if (PROCDEBUG) {
check_env_value(envval);
}
return envval;
}
void
rb_vm_stack_to_heap(rb_thread_t *th)
{
rb_control_frame_t *cfp = th->cfp;
while ((cfp = rb_vm_get_binding_creatable_next_cfp(th, cfp)) != 0) {
rb_vm_make_env_object(th, cfp);
cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
}
}
/* Proc */ /* Proc */
static VALUE
vm_make_proc_from_block(rb_thread_t *th, rb_block_t *block)
{
if (!block->proc) {
block->proc = rb_vm_make_proc(th, block, rb_cProc);
}
return block->proc;
}
static inline VALUE static inline VALUE
rb_proc_create(VALUE klass, const rb_block_t *block, rb_proc_create(VALUE klass, const rb_block_t *block,
VALUE envval, VALUE blockprocval, VALUE envval, int8_t safe_level, int8_t is_from_method, int8_t is_lambda)
int8_t safe_level, int8_t is_from_method, int8_t is_lambda)
{ {
VALUE procval = rb_proc_alloc(klass); VALUE procval = rb_proc_alloc(klass);
rb_proc_t *proc = RTYPEDDATA_DATA(procval); rb_proc_t *proc = RTYPEDDATA_DATA(procval);
@ -684,7 +676,6 @@ rb_proc_create(VALUE klass, const rb_block_t *block,
proc->is_from_method = is_from_method; proc->is_from_method = is_from_method;
proc->is_lambda = is_lambda; proc->is_lambda = is_lambda;
proc->envval = envval; proc->envval = envval;
proc->blockprocval = blockprocval;
return procval; return procval;
} }
@ -698,21 +689,15 @@ rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass)
VALUE VALUE
rb_vm_make_proc_lambda(rb_thread_t *th, const rb_block_t *block, VALUE klass, int8_t is_lambda) rb_vm_make_proc_lambda(rb_thread_t *th, const rb_block_t *block, VALUE klass, int8_t is_lambda)
{ {
VALUE procval, envval, blockprocval = 0; VALUE procval, envval;
rb_control_frame_t *cfp = RUBY_VM_GET_CFP_FROM_BLOCK_PTR(block); rb_control_frame_t *cfp = RUBY_VM_GET_CFP_FROM_BLOCK_PTR(block);
if (block->proc) { if (block->proc) {
rb_bug("rb_vm_make_proc: Proc value is already created."); rb_bug("rb_vm_make_proc: Proc value is already created.");
} }
envval = vm_make_env_object(th, cfp, &blockprocval); envval = vm_make_env_object(th, cfp);
procval = rb_proc_create(klass, block, envval, (int8_t)th->safe_level, 0, is_lambda);
if (PROCDEBUG) {
check_env_value(envval);
}
procval = rb_proc_create(klass, block, envval, blockprocval,
(int8_t)th->safe_level, 0, is_lambda);
if (VMDEBUG) { if (VMDEBUG) {
if (th->stack < block->ep && block->ep < th->stack + th->stack_size) { if (th->stack < block->ep && block->ep < th->stack + th->stack_size) {
@ -732,14 +717,13 @@ rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp)
rb_control_frame_t *ruby_level_cfp = rb_vm_get_ruby_level_next_cfp(th, src_cfp); rb_control_frame_t *ruby_level_cfp = rb_vm_get_ruby_level_next_cfp(th, src_cfp);
VALUE bindval, envval; VALUE bindval, envval;
rb_binding_t *bind; rb_binding_t *bind;
VALUE blockprocval = 0;
if (cfp == 0 || ruby_level_cfp == 0) { if (cfp == 0 || ruby_level_cfp == 0) {
rb_raise(rb_eRuntimeError, "Can't create Binding Object on top of Fiber."); rb_raise(rb_eRuntimeError, "Can't create Binding Object on top of Fiber.");
} }
while (1) { while (1) {
envval = vm_make_env_object(th, cfp, &blockprocval); envval = vm_make_env_object(th, cfp);
if (cfp == ruby_level_cfp) { if (cfp == ruby_level_cfp) {
break; break;
} }
@ -750,7 +734,6 @@ rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp)
GetBindingPtr(bindval, bind); GetBindingPtr(bindval, bind);
bind->env = envval; bind->env = envval;
bind->path = ruby_level_cfp->iseq->location.path; bind->path = ruby_level_cfp->iseq->location.path;
bind->blockprocval = blockprocval;
bind->first_lineno = rb_vm_get_sourceline(ruby_level_cfp); bind->first_lineno = rb_vm_get_sourceline(ruby_level_cfp);
return bindval; return bindval;
@ -767,7 +750,6 @@ rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars)
NODE *node = 0; NODE *node = 0;
ID minibuf[4], *dyns = minibuf; ID minibuf[4], *dyns = minibuf;
VALUE idtmp = 0; VALUE idtmp = 0;
VALUE blockprocval = 0;
if (dyncount < 0) return 0; if (dyncount < 0) return 0;
@ -794,8 +776,7 @@ rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars)
ALLOCV_END(idtmp); ALLOCV_END(idtmp);
vm_set_eval_stack(th, iseqval, 0, base_block); vm_set_eval_stack(th, iseqval, 0, base_block);
bind->env = vm_make_env_object(th, th->cfp, &blockprocval); bind->env = vm_make_env_object(th, th->cfp);
bind->blockprocval = blockprocval;
vm_pop_frame(th); vm_pop_frame(th);
GetEnvPtr(bind->env, env); GetEnvPtr(bind->env, env);

4
vm_core.h
View File

@ -786,7 +786,6 @@ typedef struct {
rb_block_t block; rb_block_t block;
VALUE envval; /* for GC mark */ VALUE envval; /* for GC mark */
VALUE blockprocval;
int8_t safe_level; /* 0..1 */ int8_t safe_level; /* 0..1 */
int8_t is_from_method; /* bool */ int8_t is_from_method; /* bool */
int8_t is_lambda; /* bool */ int8_t is_lambda; /* bool */
@ -797,7 +796,6 @@ typedef struct {
typedef struct { typedef struct {
int env_size; int env_size;
int local_size;
VALUE prev_envval; /* for GC mark */ VALUE prev_envval; /* for GC mark */
rb_block_t block; rb_block_t block;
VALUE env[1]; /* flexible array */ VALUE env[1]; /* flexible array */
@ -811,7 +809,6 @@ extern const rb_data_type_t ruby_binding_data_type;
typedef struct { typedef struct {
VALUE env; VALUE env;
VALUE path; VALUE path;
VALUE blockprocval; /* for GC mark */
unsigned short first_lineno; unsigned short first_lineno;
} rb_binding_t; } rb_binding_t;
@ -961,7 +958,6 @@ VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc,
VALUE rb_vm_make_proc_lambda(rb_thread_t *th, const rb_block_t *block, VALUE klass, int8_t is_lambda); VALUE rb_vm_make_proc_lambda(rb_thread_t *th, const rb_block_t *block, VALUE klass, int8_t is_lambda);
VALUE rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass); VALUE rb_vm_make_proc(rb_thread_t *th, const rb_block_t *block, VALUE klass);
VALUE rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp); VALUE rb_vm_make_binding(rb_thread_t *th, const rb_control_frame_t *src_cfp);
VALUE rb_vm_make_env_object(rb_thread_t *th, rb_control_frame_t *cfp);
VALUE rb_vm_env_local_variables(VALUE envval); VALUE rb_vm_env_local_variables(VALUE envval);
VALUE *rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars); VALUE *rb_binding_add_dynavars(rb_binding_t *bind, int dyncount, const ID *dynvars);
void rb_vm_inc_const_missing_count(void); void rb_vm_inc_const_missing_count(void);

6
vm_dump.c
View File

@ -187,10 +187,8 @@ rb_vmdebug_env_dump_raw(rb_env_t *env, VALUE *ep)
while (env) { while (env) {
fprintf(stderr, "--\n"); fprintf(stderr, "--\n");
for (i = 0; i < env->env_size; i++) { for (i = 0; i < env->env_size; i++) {
fprintf(stderr, "%04d: %08"PRIxVALUE" (%p)", -env->local_size + i, env->env[i], fprintf(stderr, "%04d: %08"PRIxVALUE" (%p)", i, env->env[i], (void *)&env->env[i]);
(void *)&env->env[i]); if (&env->env[i] == ep) fprintf(stderr, " <- ep");
if (&env->env[i] == ep)
fprintf(stderr, " <- ep");
fprintf(stderr, "\n"); fprintf(stderr, "\n");
} }

2
vm_eval.c
View File

@ -1308,7 +1308,7 @@ eval_string_with_cref(VALUE self, VALUE src, VALUE scope, rb_cref_t *const cref_
/* save new env */ /* save new env */
GetISeqPtr(iseqval, iseq); GetISeqPtr(iseqval, iseq);
if (bind && iseq->local_table_size > 0) { if (bind && iseq->local_table_size > 0) {
bind->env = rb_vm_make_env_object(th, th->cfp); bind->env = vm_make_env_object(th, th->cfp);
} }
/* kick */ /* kick */