Sitemap | Search || Zen Spider Website / Satori / The Satori Project / System Architecture

System Architecture

Low Level Core

The low level core includes all the little pieces of Satori: debugging and tracing utilities, exception handling, collection classes (vector, dynamic arrays, trees, and diction arrays), string classes, etc.

Wrappers

Our wrappers are 'safe' classes. Included in this code section is unsigned integers, signed integers, blocks, dynamic blocks, lists, stacks, queues, and others. These classes were designed with safety in mind to alleviate possible coding problems later in the Satori project. For example, unsigned integers checks for the possibilities of under-flow and overflow. If either of these errors are found, and error will occur.

Debugging Utilities

The debugging utilities were created to help catch errors that escaped the rigorous code reviews. Currently, it is possible to have various 'levels' of debugging. This means that we are able to test certain areas or specific cases of the Satori project. Our debugging libraries also include tracing. Tracing is where we are able to output what calls have been made.

Medium Level Core

This section contains the interface to the various areas of the garbage collector and garbage collected objects.

Garbage Collector

Currently, we are using the Bakers Semi-space algorithm. This algorithm creates two pools of memory. Only one pool is active at a time. When memory is requested, and the active pool is full, the garbage collector collects. It does this by finding all the active objects, via smart pointers, transfers the active objects to the second memory pool, and updates the pointers. Next, it wipes or cleans the old pool and sets the second pool active.

Object Model

We have a unified object model. It consists of class, the number of slots, the number of bytes, the actual slots, and the actual bytes. Class is a pointer to the object that is a Smalltalk/Satori class. The number of slots and the number of bytes tell the computer how big the slots and bytes are. The slots are pointers to other objects. The bytes contain the data.

Object Pointers (SmartPointers)

Object pointers provide specialized interfaces to the object model like naming the slots controlling the class.

Compiler

The compiler will automatically be generated with PCCTS. Each grammar rule will generate a parser method. In turn, the parsing will generate bytecodes and output to the file.

Lexer

The lexer parses the input stream into tokens for the parser. This is implemented in PCCTS.

Parser

The parser parses the tokens, from the lexer, directly into behavior or syntax trees. This is also implemented in PCCTS.

Code Generator

The code generator will take the results of the parsed Smalltalk source code and output the bytecodes.

Interpreter

The interpreter includes the bytecodes and the primitives.

Driver

The driver is the controller for the main() function. It initializes, runs, and cleans up after it is done.

Bytecodes

The bytecodes interpreter parses bytecodes into behavior. Basically, this is a virtual CPU machine language. This will involve executing the actions of the machine language (basically stack machine instructions) as well as call primitives. Specification After studying the GNU bytecode specification, we realized that we would much rather write our specs for simplicity, understanding, and ease of maintenance than for speed. Simplicity has been a concern for us from the start of the project, so it made sens e to apply it here. There are 26 bytecodes.

Primitives

The primitives do all the real work of Smalltalk. Their methods will provide arithmetic, storage, control, and I/O functions. There are 103 primitive methods in all.

Sitemap | Search || Zen Spider Website / Satori / The Satori Project / System Architecture