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. |