Ruby Internals Glossary¶ ↑
Just a list of acronyms I’ve run across in the Ruby source code and their meanings.
| Term | Definition | | — | ———–| | BIN
| Basic Instruction Name. Used as a macro to reference the YARV instruction. Converts pop into YARVINSN_pop. | | bop
| Basic Operator. Relates to methods like Integer
plus and minus which can be optimized as long as they haven’t been redefined. | | cc
| Call Cache. An inline cache structure for the call site. Stored in the cd
| | cd
| Call Data
. A data structure that points at the ci
and the cc
. iseq
objects points at the cd
, and access call information and call caches via this structure | | cfp
| Control Frame Pointer. Represents a Ruby stack frame. Calling a method pushes a new frame (cfp), returning pops a frame. Points at the pc
, sp
, ep
, and the corresponding iseq
| | ci
| Call Information. Refers to an rb_callinfo
struct. Contains call information about the call site, including number of parameters to be passed, whether it they are keyword arguments or not, etc. Used in conjunction with the cc
and cd
. | | cref
| Class
reference. A structure pointing to the class reference where klass_or_self
, visibility scope, and refinements are stored. It also stores a pointer to the next class in the hierarchy referenced by rb_cref_struct * next
. The Class
reference is lexically scoped. | | CRuby | Implementation of Ruby written in C | | cvar
| Class
Variable. Refers to a Ruby class variable like @@foo
| | dvar
| Dynamic Variable. Used by the parser to refer to local variables that are defined outside of the current lexical scope. For example def foo; bar = 1; -> { p bar }; end
the “bar” inside the block is a dvar
| | ec
| Execution Context. The top level VM context, points at the current cfp
| | ep
| Environment Pointer. Local variables, including method parameters are stored in the ep
array. The ep
is pointed to by the cfp
| | GC
| Garbage Collector | | gvar
| Global Variable. Refers to a Ruby global variable like $$
, etc | | ICLASS
| Internal Class
. When a module is included, the target class gets a new superclass which is an instance of an ICLASS
. The ICLASS
represents the module in the inheritance chain. | | ifunc
| Internal FUNCtion. A block implemented in C. | | iseq
| Instruction Sequence. Usually “iseq” in the C code will refer to an rb_iseq_t
object that holds a reference to the actual instruction sequences which are executed by the VM. The object also holds information about the code, like the method name associated with the code. | | insn
| Instruction. Refers to a YARV instruction. | | insns
| Instructions. Usually an array of YARV instructions. | | ivar
| Instance Variable. Refers to a Ruby instance variable like @foo
| | imemo
| Internal Memo. A tagged struct whose memory is managed by Ruby’s GC
, but contains internal information and isn’t meant to be exposed to Ruby programs. Contains various information depending on the type. See the imemo_type
enum for different types. | | JIT | Just In Time
compiler | | lep
| Local Environment Pointer. An ep
which is tagged VM_ENV_FLAG_LOCAL
. Usually this is the ep
of a method (rather than a block, whose ep
isn’t “local”) | | local
| Local. Refers to a local variable. | | me
| Method
Entry. Refers to an rb_method_entry_t
struct, the internal representation of a Ruby method. | MRI | Matz’s Ruby Implementation | | pc
| Program Counter. Usually the instruction that will be executed next by the VM. Pointed to by the cfp
and incremented by the VM | | sp
| Stack Pointer. The top of the stack. The VM executes instructions in the iseq
and instructions will push and pop values on the stack. The VM updates the sp
on the cfp
to point at the top of the stack| | svar
| Special Variable. Refers to special local variables like $~
and $_
. See the getspecial
instruction in insns.def
| | VALUE
| VALUE is a pointer to a ruby object from the Ruby C code. | | VM | Virtual Machine. In MRI’s case YARV (Yet Another Ruby VM) | WB | Write Barrier. To do with GC
write barriers | | WC | Wild Card. As seen in instructions like getlocal_WC_0
. It means this instruction takes a “wild card” for the parameter (in this case an index for a local) | | YARV | Yet Another Ruby VM. The virtual machine that CRuby uses | | ZOMBIE | A zombie object. An object that has a finalizer which hasn’t been executed yet. The object has been collected, so is “dead”, but the finalizer hasn’t run yet so it’s still somewhat alive. |