From 5504eb4714442f36687b38c021df08f49b50675b Mon Sep 17 00:00:00 2001 From: Torsten Ruger Date: Tue, 20 Mar 2018 15:40:22 +0530 Subject: [PATCH] update readme --- README.md | 107 +++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 89 insertions(+), 18 deletions(-) diff --git a/README.md b/README.md index aec0564f..db2c77e2 100644 --- a/README.md +++ b/README.md @@ -5,33 +5,106 @@ # RubyX RubyX is about native code generation in and of ruby. +In other words, compiling ruby to binary, in ruby. X can be read as 10 times faster, or a decade away, depending on mindset. -The current (fourth) rewrite adds a typed intermediate representation layer (bit like c, -but not as a language). The idea is to compile ruby to that typed representation. +The current (fourth) rewrite adds aims at clarifying the roles of the different layers +of the system, see below. The overhaul is almost done. -We use whitequarks parser to parse ruby. - -Processing is roughly: Ruby --> Vm --> Risc --> Arm --> binary . +Processing goes through layers: Ruby --> Vool --> Mom --> Risc --> Arm --> binary . -## Done -Some things that are finished, look below for current status / work +## Layers -### Typed representation +### Ruby -The fully typed syntax representation and compiler to the Risc level is done. -It is remodeled after last years system language, which proved the concept and -surprised with speed. +Ruby is input layer, we use whitequarks parser to parse ruby and transform it to +Vool. -Completely object oriented, including calling convention. Not much slower than c. +### Vool -### A runtime: Parfait +Vool is a Virtual Object Oriented Language. Virtual in that is has no own syntax. But +it has semantics, and those are substantially simpler than ruby. -In a dynamic system the distinction between compile-time and run-time is blurs. But a minimum -of support is needed to get the system up, and that is [Parfait](http://ruby-x.org/soml/parfait.html) +Vool is Ruby without the fluff. No unless, no reverse if/while, no splats. Just simple +oo. (Without this level the step down to the next layer was just too big) + +Also Vool has a typed syntax tree, unlike the AST from the parser gem. This is easier when +writing conversion code: the code goes with the specific class (more oo than the visitor +pattern, imho) + +### Mom + +The Minimal Object Machine layer is the first machine layer. This means it has instructions +rather than statements. Instructions (in all machine layers) are a linked list. + +Mom has no concept of memory yet, only objects. Data is transferred directly from object +to object with one of Mom's main instructions, the SlotLoad. + +Mainly Mom is an easy to understand step on the way down. A mix of oo and machine. In +practise it means that the amount of instructions that need to be generated in vool +is much smaller (easier to understand) and the mapping down to risc is quite straightforward. + +### RISC + +The risc cpu architecture approach was a simplification of the cpu instruction set to a +minimum. Arm, our main target is a risc architecture, and the next level down. + +The Risc layer here abstract the Arm in a minimal and independent way. It does not model +any real RISC cpu instruction set, but rather implements what is needed to for rubyx. + +Instructions are derived from a base class, so the instruction set is extensible. This +way aditional functionality may be added by external code. + +Risc knows memory and has a small set of registers. It allows memory to register transfer +and back and inter register transfer. But has no memory to memory transfer like Mom. + +### Arm + +There is a minimal Arm assembler that transforms Risc instructions to Arm instructions. +This is mostly a one to one mapping, though it does introduce the quirks that ARM has +and that were left out of the Risc layer. + +### Elf + +Arm instructions assemble themselves into binary code. A minimal Elf implementation is +able to create executable binaries from the assembled code and Parfait objects. + +### Parfait + +Generating code (by descending above layers) is only half the story in an oo system. +The other half is classes, types, constant objects and a minimal run-time. This is +what is Parfait is. + +## Types and classes, static vs dynamic + +Classes in dynamic languages are open. They can change at any time, meaning you can add/remove +methods and use any instance variable. This is the reason dynamic languages are interpreted. + +For Types to make any sense, they have to be static, immutable. + +Some people have equated Classes with Types, this is a basic mistake in dynamic languages. + +In rubyx a Type implements a Class (at a certain time of that classes lifetime). It +defines the methods and instance variables available. This is key to generating +efficient code that uses type information to access instance variables. + +When a class changes, say a new method is added that uses a new instance variable, a +**new** Type is generated to describe the class at that point. **New** code is generated +for this new Type. + +In essence the Class always **has a** current Type and **many** Types implement (different +versions of) a Class. + +All Objects have a Type (as their first member). The Type points to the Class that the +object has in oo terms. + +Classes are defined by ruby code, but the methods of a Type (that are executed) are defined +by Mom and Risc only. + +## Other ### Interpreter @@ -46,9 +119,7 @@ what is going on, and in finding bugs. ## Status -Most work on the statically typed layer should be done (and produces working binaries!). - -Next up: compiling ruby and typing it :-) +Just finishing the rewrite (above architecture) and about to get to binaries again. ### Stary sky