Now Reading
A Lisp Interpreter Carried out in Conway’s Sport of Life

A Lisp Interpreter Carried out in Conway’s Sport of Life

2023-01-05 14:42:06

A screenshot of the Lisp in Life architecture.

Lisp in Life is a Lisp interpreter applied in Conway’s Sport of Life.

All the sample is viewable on the browser here.

To the perfect of my data, that is the primary time a high-level programming language was interpreted in Conway’s Sport of Life.

Operating Lisp on the Sport of Life

Lisp is a language with a easy and stylish design, having an intensive capacity to specific refined concepts as easy applications. Notably, the highly effective function of macros might be used to switch the language’s syntax to put in writing applications in a extremely versatile method. For instance, macros can be utilized to introduce new programming paradigms to the language, as demonstrated in object-oriented-like.lisp (which may truly be evaluated by the interpreter, though complicated applications take fairly a very long time to complete working), the place a construction and syntax much like courses in Object Oriented Programming is constructed. Regardless of the expressibility of Lisp, it’s the world’s second oldest high-level programming language launched in 1958, solely to be preceded by Fortran.

Conway’s Sport of Life is a mobile automaton proposed in 1970. Regardless of it having a quite simple algorithm, it’s identified to be Turing Full. Lisp in Life demonstrates this truth in a fairly easy method.

How can easy techniques permit human ideas to be articulated and be expanded? With the expressibility of Lisp and the idea of Conway’s Sport of Life, Lisp in Life gives a solution to this query.

Enter and Output

The Lisp program is offered by enhancing sure cells throughout the sample to symbolize the ASCII-encoding of the Lisp program. The sample instantly reads this textual content and evaluates the outcomes. You may as well load your individual Lisp program into the sample and run it.
The usual output is written on the backside finish of the RAM module, which may be simply positioned and instantly examined in a Sport of Life viewer.
The Lisp implementation helps lexical closures and macros, permitting one to put in writing Lisp applications in a Lisp-like style, so far as the reminiscence restrict means that you can.

The Lisp interpreter is written in C. Utilizing the construct system for this challenge, you may as well compile your individual C11-compatible C code and run in on Conway’s Sport of Life.

Earlier Work

As beforehand talked about,
to the perfect of my data, that is the primary time a high-level programming language was interpreted in Conway’s Sport of Life.

The entry that includes Universal Computers in LifeWiki has a listing of computer systems created within the Sport of Life.
Two vital cases not talked about on this entry are the Quest For Tetris (QFT) Mission
created by the authors of the QFT challenge, and APGsembly created by Adam P. Goucher.
All of those work are designed to run an meeting language and will not be designed to interpret a high-level language per se.

An instance of a compiled high-level language focused for the Sport of Life is Cogol by the QFT challenge.
Cogol is compiled to the meeting language QFTASM, focused for the QFT structure.
Though Cogol is focused for the QFT structure, it requires compilation to QFTASM for the code to be run within the QFT structure.

In Lisp in Life, a modified model of the QFT structure is first created for enhancing the sample’s runtime.
Modifications embrace introducing a brand new cascaded storage structure for the ROM, new opcodes, extending the ROM and RAM deal with house, and so on.
The Lisp supply code is then written into the pc’s RAM module as its uncooked binary ASCII format.
The Conway’s Sport of Life sample instantly reads, parses, and evaluates this Lisp supply code to supply its output.
This function of permitting a Conway’s Sport of Life sample to guage a high-level programming language expressed as a string of textual content
is a novel function that was newly achieved on this challenge.


Here’s a YouTube video exhibiting Lisp in Life in motion:

YouTube video of Lisp in Life.


An overview of the entire architecture.

An summary of the whole structure.

An overview of the CPU and its surrounding units.

An summary of the CPU and its surrounding modules. On the highest are the ROM modules, with the lookup module on the suitable, and the worth modules on the left. On the underside left is the CPU. On the underside proper is the RAM module.

This sample is the VarLife model of the structure. VarLife is an 8-state mobile automaton outlined within the Quest For Tetris (QFT) Mission, which is used as an intermediate layer to create the ultimate Conway’s Sport of Life sample. The colours of the cells point out the 8 distinct states of the VarLife rule.

The structure relies on within the original QFT repository. Varied modifications have been made to make the sample compact, akin to introducing a brand new lookup desk structure for the ROM, eradicating and including new opcodes, increasing the ROM and RAM deal with house, and so on.

The Conway's Game of Life version of the architecture, converted from the VarLife pattern.

The Conway’s Sport of Life model of the structure, transformed from the VarLife sample.
What seems to be a single cell on this picture is definitely an OTCA metapixel zoomed away to be proven 2048 instances smaller.

A close-up view of a part of the ROM module in the Conway's Game of Life version.

An in depth-up view of part of the ROM module within the Conway’s Sport of Life model.
Every pixel within the earlier picture is definitely this square-shaped construction proven on this picture.
These buildings are OTCA metapixels, which may be seen to be within the On and Off meta-states on this picture.
The OTCA Metapixel is a particular Conway’s Sport of Life sample that may emulate mobile automatons with personalized guidelines.
The unique VarLife sample is simulated this manner in order that it may possibly run in Conway’s Sport of Life.

The OTCA Metapixel simulating Life in Life may be seen on this great video by Phillip Bradbury:

A video of the RAM module of the computer in the VarLife rule in action.

A video of the RAM module within the VarLife rule in motion.

The computer showing the results of the computation of `(print (* 3 14))`.

The pc exhibiting the outcomes of the next Lisp program:

(outline mult (lambda (m n)
  (* m n)))

(print (mult 3 14))

The result’s 42, proven in binary ascii format (0b110100, 0b110010), learn in bottom-to-up order.

As proven on this picture, the usual output of the Lisp program will get written on the backside finish of the RAM module, and may be instantly seen in a Sport of Life viewer.
This repository additionally accommodates scripts that run on Golly to decode and look at the contents of the output as strings.

How is it Performed?

The build flow of Lisp in Life.

The Lisp interpreter, written in C, is compiled to an meeting language for a CPU structure applied within the Sport of Life, which is a modification of the pc used within the Quest For Tetris (QFT) challenge. The compilation is finished utilizing an prolonged model of ELVM (the Esoteric Language Digital Machine). The Sport of Life backend for ELVM was applied on my own.

Producing a sufficiently small sample that runs in an inexpensive period of time required loads of effort.
This required optimizations and enhancements in each layer of the challenge; a quick abstract can be:

  • The C Compiler layer – including the computed goto function to the C compiler, preserving variable symbols for use after compilation, and so on.
  • The C layer (the Lisp interpreter) – utilizing a string hashtable and binary seek for Lisp image lookup, minimization of stack area utilization with union reminiscence buildings, cautious reminiscence area map design, and so on.
  • The QFTASM layer – writing a compiler optimizer to optimize the size of the meeting code
  • The VarLife layer (the CPU structure) – making a lookup desk structure for quicker ROM entry, increasing the dimensions and size of the RAM module, including new opcodes, and so on.
  • The Sport of Life layer – Hashlife-specific optimization

A extra detailed description of the optimizations executed on this challenge is on the market within the Implementation Details part.

Conversion from VarLife to Conway’s Sport of Life

VarLife is an 8-state mobile automaton outlined within the Quest For Tetris (QFT) Mission.
It’s used as an intermediate layer to generate the ultimate Conway’s Sport of Life sample; the pc is first created in VarLife, after which transformed to a Sport of Life sample.

When changing VarLife to Conway’s Sport of Life, every VarLife cell is mapped to an OTCA Metapixel (OTCAMP). The conversion from VarLife to the Sport of Life is finished in a method in order that the conduct of the states of the VarLife sample matches precisely with the meta-states of the OTCA Metapixels within the transformed Sport of Life sample.
Subsequently, it is sufficient to confirm the conduct of the VarLife sample to confirm the conduct of the Sport of Life sample.

As a result of the usage of OTCA Metapixels, every VarLife cell turns into prolonged to a 2048×2048 Sport of Life cell, and 1 VarLife era requires 35328 Sport of Life generations. Subsequently, the VarLife patterns run considerably quicker than the Sport of Life (GoL) model.

Further particulars on VarLife can be found within the Miscellaneous part.

Sample Information

Sample recordsdata preloaded with varied Lisp applications can be found right here.
Detailed statistics such because the working time and the reminiscence consumption can be found within the Running Times and Statistics part.

The patterns may be simulated on the Sport of Life simulator Golly.

The VarLife patterns may be simulated on Golly as effectively.
To run the VarLife patterns, open Golly and see File -> Preferences -> Management, and Examine the “Your Guidelines” listing.
Open the listing, and replica to the listing.

Descriptions of the Lisp Packages

  • object-oriented-like.lisp:
    This instance creates a construction much like courses in Object-Oriented Programming, utilizing closures.

    • The category has strategies and subject variables, the place every occasion carries distinct and protracted reminiscence places of their very own.
      The instance instantiates two counters and concurrently modifies the worth held by every occasion.
    • New syntaxes for instantiation and methodology entry, (new classname) and (. occasion methodname), are launched utilizing macros and capabilities.

    The Lisp interpreter’s variable scope and the macro function is highly effective sufficient to handle complicated reminiscence administration,
    and even offering a brand new syntax to assist the goal paradigm.

  • printquote.lisp: A easy demonstration of macros.

  • factorial.lisp: A easy demonstration of recursion with the factorial perform.

  • z-combinator.lisp:
    Demonstration of the Z Combinator to implement a factorial perform
    utilizing anonymous recursion.

  • backquote-splice.lisp:
    Implements the backquote macro used generally in Lisp to assemble macros.
    It additionally helps the unquote and unquote-splice operations, every written as ~ and ~@.

  • primes.lisp: Prints a listing of prime numbers as much as 20. This instance highlights the usage of the whereas syntax.

The contents of print.lisp is kind of easy – it calculates and prints the results of 3 * 14.
backquote.lisp and primes-print.lisp are much like backquote-splice.lisp and primes.lisp, primarily included for efficiency comparisons.
backquote.lisp doesn’t implement the unquote-splice operation, and demonstrates some extra examples.
primes-print.lisp reduces the variety of record operations to avoid wasting reminiscence utilization.

Particulars of the Lisp Interpreter

Particular Kinds and Builtin Capabilities

  • outline
  • if
  • quote
  • automobile, cdr
  • cons
  • record
  • atom
  • print
  • progn
  • whereas
  • lambda, macro
  • eval
  • eq
  • +, -, *, /, mod, <, >

Lexical Closures

This Lisp interpreter helps lexical closures.
The implementation of lexical closures is highly effective sufficient to put in writing an object-oriented-like code as proven in object-oriented-like.lisp,
the place courses are represented as lexical closures over the sector variables and the category strategies.


This Lisp interpreter helps macros. Lisp macros may be thought as a perform that receives code and returns code.
Following this design, macros are handled exacly the identical as lambdas, besides that it takes the arguments as uncooked S-expressions,
and evaluates the end result twice (the primary time to construct the expression, and the second time to truly consider the builded expression).

Operating Instances and Statistics

VarLife Patterns

Lisp Program and Sample (VarLife) #Halting Generations (VarLife) Operating Time (VarLife) Reminiscence Utilization (VarLife)
print.lisp [pattern] 105,413,068 (precise) 1.159 minutes 5.0 GiB
lambda.lisp [pattern] 700,000,000 2.966 minutes 12.5 GiB
printquote.lisp [pattern] 800,000,000 3.424 minutes 12.5 GiB
factorial.lisp [pattern] 1,000,000,000 5.200 minutes 17.9 GiB
z-combinator.lisp [pattern] 1,700,000,000 9.823 minutes 23.4 GiB
backquote-splice.lisp [pattern] 4,100,000,000 20.467 minutes 27.5 GiB (max.)
backquote.lisp [pattern] 4,100,000,000 21.663 minutes 27.5 GiB (max.)
object-oriented-like.lisp [pattern] 4,673,000,000 22.363 minutes 27.5 GiB (max.)
primes-print.lisp [pattern] 8,880,000,000 27.543 minutes 27.5 GiB (max.)
primes.lisp [pattern] 9,607,100,000 38.334 minutes 27.5 GiB (max.)

Conway’s Sport of Life (GoL) Patterns

Lisp Program and Sample (GoL) #Halting Generations (GoL) Operating Time (GoL) Reminiscence Utilization (GoL)
print.lisp [pattern] 3,724,032,866,304 382.415 minutes 27.5 GiB (max.)
lambda.lisp [pattern] 24,729,600,000,000 1372.985 minutes 27.5 GiB (max.)
printquote.lisp [pattern] 28,262,400,000,000 1938.455 minutes 27.5 GiB (max.)
factorial.lisp [pattern] 35,328,000,000,000 3395.371 minutes 27.5 GiB (max.)
z-combinator.lisp [pattern] 60,057,600,000,000
backquote-splice.lisp [pattern] 144,844,800,000,000
backquote.lisp [pattern] 144,844,800,000,000
object-oriented-like.lisp [pattern] 165,087,744,000,000
primes-print.lisp [pattern] 313,712,640,000,000
primes.lisp [pattern] 339,399,628,800,000

Widespread Statistics

Lisp Program #QFT CPU Cycles QFT RAM Utilization (Phrases)
print.lisp 4,425 92
lambda.lisp 13,814 227
printquote.lisp 18,730 271
factorial.lisp 28,623 371
z-combinator.lisp 58,883 544
backquote-splice.lisp 142,353 869
backquote.lisp 142,742 876
object-oriented-like.lisp 161,843 838
primes-print.lisp 281,883 527
primes.lisp 304,964 943

The working instances for every program are proven above. The Hashlife algorithm used for the simulation requires loads of reminiscence in change of speedups.
The simulations have been run on a 32GB-RAM laptop, with Golly’s reminiscence utilization restrict set to 28000 MB, and the default base step to 2 (configurable from the preferences).
The reminiscence utilization was measured by Ubuntu’s exercise monitor. “(max.)” exhibits the place the utmost permitted reminiscence was used.
The variety of CPU cycles and the QFT reminiscence utilization was obtained by working the QFTASM interpreter on the host PC.
The QFT reminiscence utilization exhibits the variety of RAM addresses that have been written no less than as soon as.
The reminiscence utilization is measured in phrases, which is 16 bits on this structure.

The entire VarLife patterns can truly be run on a pc. The shortest working time is about 1 minute for print.lisp.
A complicated program akin to object-oriented-like.lisp may even run in about 22 minutes.

However, the Sport of Life patterns take considerably extra time than the VarLife patterns, however for brief applications it may be run in a reasonably affordable period of time.
For instance, print.lisp finishes working in about 6 hours within the Sport of Life sample.
As talked about within the “Conversion from VarLife to Conway’s Sport of Life” part, for the reason that Sport of Life sample emulates the conduct of the VarLife sample utilizing OTCA Metapixels,
the conduct of the Sport of Life patterns may be verified by working the VarLife patterns.


There are assessments to examine the conduct of the Lisp interpreter.
There’s a take a look at for checking the QFTASM-compiled Lisp interpreter utilizing the QFTASM interpreter, and a take a look at for checking the GCC-compiled Lisp interpreter on the host computer.
To run these assessments, use the next instructions:

git submodule replace --init --recursive # Required for constructing the supply

make take a look at             # Run the assessments for the QFTASM-compiled Lisp interpreter, utilizing the QFTASM interpreter
make test_executable  # Run the assessments for the executable compiled by GCC

Operating make take a look at requires Hy, a Clojure-like Lisp applied in Python out there by way of pip set up hy.
A few of the assessments examine the output outcomes of Hy and the output of the QFTASM Lisp interpreter.

The assessments have been run on Ubuntu and Mac.

Constructing from Supply

This part explains learn how to load the Lisp interpreter (written in C) to the Sport of Life sample, and in addition learn how to load a customized Lisp program into the sample to run it on Sport of Life.

Please see from the GitHub repository.

Implementation Particulars

This part describes the implementation particulars for the varied optimizations for the QFT meeting and the ensuing Sport of Life sample.

The C Compiler layer

  • Added the computed goto function to ELVM
    • This was merged into the unique ELVM challenge.
  • Modified the compiler to protect and output reminiscence deal with symbols and program deal with symbols, for his or her utilization within the compiler optimization instrument within the QFTASM layer
    • This enables to make use of memheader.eir, in order that symbols used within the C supply may be referenced within the ELVM meeting layer utilizing the identical variable symbols.

The ELVM Meeting layer

  • Wrote the QFTASM backend for ELVM
    • This was merged into the unique ELVM challenge.
  • Added additional enhancements to the QFTASM backend:
    • Let the ELVM meeting’s reminiscence deal with house match QFT’s native reminiscence deal with house
      • Initially, the ELVM meeting needed to convert its reminiscence deal with each time when a reminiscence entry happens.
    • Assist new opcodes added within the improved QFT structure

The C layer (the implementation of the Lisp interpreter)

Utilization of binary search and hashtables for string representations and comparisons

By profiling the GCC-compiled model of the Lisp interpreter, it was discovered that the string desk lookup course of was a big efficiency bottleneck. This was a big room for optimization.

The optimized string lookup course of is as follows.
First, when the Lisp parser accepts an emblem token, it creates a 4-bit hash of the string with the checksum of the ASCII illustration of the string. The hash factors to a hashtable that holds the basis of a binary search tree for string comparability. Every node within the tree holds the string of the image token, and two nodes which can be earlier than and after the token in alphabetical order. When a question image token arrives within the parsing part, a node with an identical token is returned, or a brand new node for the token is added into this binary tree if the token doesn’t exist but. This enables for every distinct image within the S-expression to have a definite reminiscence deal with.

Within the interpretation part, since every distinct image has a definite reminiscence deal with, and each string required for the Lisp program has already been parsed, string comparability may be executed by merely evaluating the reminiscence deal with of the tokens. For the reason that interpreter solely makes use of string equality operations for string comparability, merely checking for integer equality suffices for string comparability, rushing up the interpretation part. For the reason that hash secret’s 4 bits lengthy, this enables for decreasing 4 searches within the binary tree in comparison with utilizing a single binary tree.

Utilization of bounce hash tables for the particular kind analysis process searches

There are 17 distinct procedures for evaluating the particular types within the Lisp interpreter,
outline, if, quote, automobile, cdr, cons, atom, print, progn, whereas, {lambda, macro}, eval, eq, {+, -, *, /, mod}, {<, >}, record, and lambda/macro invocations (when if the token will not be a particular kind). Utilizing an if assertion to seek out the corresponding process for a given token turns into a linear seek for the token comparisons. To hurry up this search course of, a hash desk is created for leaping to the corresponding procedures. For the reason that reminiscence addresses for the particular types may be decided earlier than parsing the Lisp program, the entire symbols for the particular types have a hard and fast reminiscence deal with. Subsequently, the hash key may be created by subtracting an offset to the image’s reminiscence deal with, to level to a hashtable that’s created close to the register places. This hashtable is offered in memheader.eir. When the hash secret’s bigger than the areas of this hashtable, it implies that the image will not be a particular kind, so the analysis jumps to the lambda/macro invocation process.

The Lisp implementation has 3 distinct worth varieties, ATOM, INT, and LAMBDA. Every worth solely consumes one QFT byte of reminiscence; the ATOM worth holds the pointer to the image’s string hashtable, the INT worth holds the signed integer worth, and LAMBDA holds a pointer to the Lambda struct, in addition to its subtype data, of both LAMBDA, MACRO, TEMPLAMBDA and TEMPMACRO. (The TEMPLAMBDA and TEMPMACRO subtypes are lambda and macro varieties that recycles its argument worth reminiscence house each time it’s known as, however is unused within the ultimate lisp applications.) For the reason that RAM’s deal with house is simply 10 bits, there are 6 free bits that can be utilized for addresses holding pointers. Subsequently, the worth kind and subtype data is held in these free bits. This makes the integer within the Lisp implementation to be a 14-bit signed integer, starting from -8192 to 8191.

Minimization of Stack Area Utilization

For the reason that C compiler used on this challenge doesn’t have reminiscence optimization options, this must be executed manually throughout the C supply code. This led to the most important motive why the interpreter’s supply code appears to be obfuscated.

One of many largest bottlenecks for reminiscence entry was stack area utilization. Each time a stack area reminiscence entry happens, the meeting code performs reminiscence deal with offset operations to entry the stack area. This doesn’t occur when accessing the heap reminiscence, since there is just one heap area utilized in the whole program, so the pointers for international variables may be hard-coded by the assembler. Subsequently, it’s favorable optimization-wise to make use of the heap reminiscence as a lot as potential.

One solution to make use of this truth is to make use of as a lot international variables as potential. Since registers and customary RAM reminiscence share the identical reminiscence house, international variables may be accessed with a pace corresponding to registers (Nevertheless, for the reason that bodily location of the RAM reminiscence slot throughout the sample impacts the I/O sign arrival time, and the registers have probably the most smallest RAM addresses, i.e. they’re the closest to the CPU unit, the registers have the quickest reminiscence entry time).

One other methodology of saving reminiscence was to make use of union reminiscence buildings to attenuate the stack area utilization. Within the C compiler used on this challenge, each time a brand new variable is launched in a perform, the perform’s stack area utilization (used per name) is elevated to suit the entire variables. This occurs even when two variables by no means seem on the similar time. Subsequently, utilizing the truth that some variables by no means seem concurrently, unions are used for each occurence of such variables, in order that they’ll use a shared area throughout the stack house. This led to minimization of the stack area utilization. For the reason that stack area is simply 233 hextets (1 byte within the QFT RAM is 16 bits) massive, this allowed to extend the variety of nested perform calls, particularly the nested calls of eval which evaluates the S-expressions. For the reason that S-expressions have a listing construction, and eval turns into nested when lambdas are known as within the Lisp program, this optimization was vital for permitting extra refined Lisp applications to be run within the structure.

The QFTASM layer

The QFT meeting generated by the C compiler has loads of room for optimization. I due to this fact created a compiler optimization instrument to scale back the QFTASM meeting dimension.

Fixed folding

Quick fixed expressions akin to ADD 1 2 vacation spot is folded to a MOV operation.

MOV folding

The QFT meeting code may be splitted into subregions by bounce operations, such that:

See Also

  • Every subregion doesn’t include any bounce operations
  • Every subregion ends with a bounce operation
  • Each bounce operation within the meeting is assured to leap to the start of a subregion, and by no means to the center of any subregion

The final assure the place jumps by no means happen in the course of a subregion is offered by the C compiler. The ELVM meeting’s program counter is designed in order that it will increase solely when a bounce instruction seems. This makes an ELVM program counter to level to a sequence of a number of directions, as a substitute of a single instruction. For the reason that ELVM meeting makes use of the ELVM program counter for its bounce directions, it’s assured that the bounce directions within the QFT meeting by no means bounce to the center of any subregion, and all the time jumps to a starting of a subregion.

In every subregion, the dependency graph for the reminiscence deal with is created. If a reminiscence deal with turns into written however is later overwritten with out turning into utilized in that subregion in any respect, the instruction to put in writing to that reminiscence deal with is eliminated. Since it’s assured that bounce operations by no means bounce to the center of any subregion, it’s assured that the overwritten values may be safely eliminated with out affecting the result of this system. The MOV folding optimization makes use of this truth to take away pointless directions.

This folding course of can be executed with dereferences; if a dereferenced reminiscence deal with is written, and the deal with is overwritten with out getting used in any respect, and the dereference supply is unoverwritten in any respect throughout this course of, the instruction for writingto the dereferenced reminiscence deal with is eliminated.

Leap folding

If the vacation spot of a conditional or fixed-destination bounce instruction factors to a different bounce instruction with a hard and fast vacation spot, the bounce vacation spot is folded to the latter bounce instruction’s vacation spot.

An analogous folding is finished when a hard and fast bounce instruction factors to a conditional bounce instruction, the place the mounted bounce instruction is changed by the latter conditional bounce instruction.

The Varlife layer (the pc structure)

Created the with a lookup desk construction for the ROM module

In this image of the CPU and its surrounding modules, the 2 modules on the highest are the ROM modules. The unique ROM module had one desk, with the reminiscence deal with as the important thing and the instruction as the worth. I recreated the ROM module so as to add a lookup desk layer, the place every distinct instruction (not the opcodes, however the whole instruction together with the values used inside) holds a definite serial integer key. The ROM module on the suitable accepts a program counter deal with and returns the instruction key for this system counter. The module on the left accepts the instruction key and returns the precise bits of the instruction because the output. This enables for dictionary compression to be carried out to the ROM knowledge, saving loads of house. For the reason that directions are 45 bits and the instruction keys are solely 10 bits, the instruction key desk is 1/4 the dimensions of the unique ROM module. Though the ROM dimension is 3223 for the whole Lisp interpreter, there have been solely 616 distinct directions within the Lisp interpreter, making the dimensions of the instruction desk be 616 ROM models excessive, successfully decreasing the ROM module dimension altogether.

The ROM module options one other type of compression, the place absence of cells are used to symbolize 0-valued bits throughout the instruction. Beneath is a close-up look of the ROM worth module:

The ROM value module

Discover that some cells on the left are absent, regardless of the desk being anticipated to be an oblong form. It’s because absent cells don’t emit any indicators, therefore successfully emitting 0-valued bits because the output. To make use of this truth, the entire directions are first alphabetically ordered at desk creation time, in order that directions that begin with trailing zeroes develop into positioned larger within the desk (farther from the sign supply). This enables for a most variety of cells to get replaced with absent models to symbolize 0-valued bits. In actual fact, the instruction for no-ops is represented as all zeroes, so the entire models within the worth module are changed by absent cells. The no-op instruction seems loads of instances instantly after the bounce operation, as a consequence of the truth that the QFT structure has a department delay when invoking a bounce instruction, requiring a no-op instruction to be current to compensate for the delay.

Added new optimized directions to the ALU, and eliminated unused ones

I eliminated the AND, OR, SL (shift left), SRL (shift proper logical), and the SRA (shift proper arithmetical) opcodes, and added the SRU (shift proper unit) and SRE (shift proper eight) opcodes to the structure. Since there already have been opcodes for XOR (bitwise-xor) and ANT (bitwise-and-not), AND and OR, which weren’t used a lot within the interpreter, might be changed by these opcodes. The bitshift operations had considerably bigger patterns than the opposite opcodes, being greater than 10 instances bigger than the opposite opcodes. These have been lowered to a fixed-size shift operations which might be applied in the identical sizes as the opposite opcodes. For the reason that shift left opcode may be changed by consecutively including its personal worth, successfully multiplying by powers of two, the opcode was safely eliminated. The principle motive for the unique bitshift models being massive was as a result of shift quantities being depending on the values of the RAM. Changing a binary worth to a bodily (in-pattern) shift quantity required a big sample. However, shifting a hard and fast worth might be applied by a considerably extra easier sample. The shift proper eight instruction is principally used for studying out the usual enter, the place every ASCII character within the enter string is packed into one 16-bit RAM reminiscence deal with.

This resulted in a complete of precisely 8 opcodes, ANT, XOR, SRE, SRU, SUB, ADD, MLZ, and MNZ. Since this may slot in 3 bits, the opcode area for the instruction worth was lowered by 1 bit. For the reason that RAM module is 10 bits, and the third worth of the instruction is all the time the writing vacation spot of the RAM, and the primary instruction will also be made in order that it turns into the studying supply deal with of the RAM, this enables for an extra 6*2=12 bits to be lowered from the instruction size. These altogether has lowered the ROM phrase dimension from 58 to 45 bits, decreasing practically 1/4 of the unique instruction dimension.

Prolonged the ROM and RAM deal with house from 9,7-bit to 12,10-bit

The unique QFT structure had a ROM and RAM deal with house of 9 and seven bits. I prolonged the ROM and RAM deal with house to 12 and 10 bits, respectively. This was not a simple job because it first appeared, for the reason that sign arrival timings between the modules needed to be fastidiously adjusted to ensure that the indicators to line up appropriately. This concerned reverse-engineering and experimenting undocumented VarLife sample models used within the unique QFT structure. The identical held for when redesigning different elements of the structure.

Decreasing the Commonplace Enter Measurement

Since every byte of the RAM module may be ordered arbitrarily within the CPU’s structure, the RAM is organized in order that the usual output is written on the very backside of the RAM module, and proceeds upwards. Subsequently, the contents of the RAM can simply be noticed in a Sport of Life viewer by instantly inspecting the underside of the RAM module.

Since RAM has 16 bits of reminiscence per reminiscence deal with, it permits to suit two ASCII-encoded characters per one deal with. Subsequently, the usual enter is learn out by studying two characters per deal with. For the usual output, one character is written to at least one deal with for aesthetic causes, in order that the characters may be instantly noticed in a Sport of Life viewer the sample extra simply. Additionally, for the usual output to proceed upwards throughout the RAM module sample, the reminiscence pointer for the usual output proceeds backwards within the reminiscence house, whereas the pointer for the usual enter proceeds forwards within the reminiscence house.

The Sport of Life layer

Optimizing the Sport of Life layer primarily revolved round understanding the Macrocell format for representing and saving Sport of Life patterns, and the Hashlife algorithm. The Macrocell format makes use of quadtrees and memoization for compressing repeated patterns. For the reason that ultimate Sport of Life sample is an array of OTCA metapixels that are 2048×2048 massive, and even has repeated patterns within the VarLife layer (which means that there are repeated configurations of OTCA metapixels), this compression reduces the file dimension for the QFT sample considerably. The most effective instance that permit me perceive the Macrocell format was an instance offered by Adam P. Goucher in this thread in Golly’s mailing record.

The Hashlife algorithm additionally makes use of quadtrees and memoization to hurry up the Sport of Life simulations. This algorithm makes use of the truth that the identical sample in a similar time-frame influences solely a hard and fast extent of its surrounding areas, therefore permitting for memoization.

As for optimization, I first seen that the QFT sample had a 1-pixel excessive sample concatenated to the whole sample. The unique QFT sample within the unique QFT repository was fastidiously designed in order that it’s composed of 8×8-sized sample models. Subsequently, many of the patterns may be represented by 8×8 tiles. Nevertheless, for the reason that 1-pixel excessive sample on the prime creates an offset that shifts away the sample from this 8×8 grid, it causes the sample to have fewer repeated patterns if interpreted from the nook of its bounding field, inflicting the memoization to work inefficiently. I due to this fact tried placing a redundant cell (which doesn’t intervene with the remainder of the sample) to realign the whole sample to its 8×8 grid, which truly barely lowered the ensuing Macrocell file dimension from the unique one. Though I didn’t examine the working instances, for the reason that Hashlife algorithm makes use of memoization over repeated patterns as effectively, I anticipate this optimization to no less than barely contribute to the efficiency of the simulation.

One other optimization was enhancing the metafier script used to transform VarLife patterns to Sport of Life ( The unique script used a sq. area to suit the whole sample to create the quadtree illustration. Nevertheless, for the reason that Lisp in Life VarLife sample is 968 pixels extensive however 42354 pixels excessive, it tried to allocate a 65536×65536-sized integer array, which was prohibitively massive to run. I modified the script in order that it makes use of an oblong area, the place absent areas of the quadtree are represented as absent cells. Though that is very easy with the data of the Macrocell format, it was troublesome at first till I turned keen on the algorithms surrounding the Sport of Life.

Reminiscence Area Map and the Phases of Operation

The memory region map of Lisp in Life.

The reminiscence area map is fastidiously designed to avoid wasting house. That is finest described with the operation phases of the interpreter.

Part 0: Precalculations

Varied precalculations are executed after the interpreter begins working. The development of the string interning hashtable for reserved atoms akin to outline, quote, and so on. are executed on this part. For the GCC-compiled interpreter, some variables which can be outlined within the QFT reminiscence header are outlined within the C supply.

For the reason that consequence of those precalculations are all the time the identical for any incoming Lisp program, this part is finished on the host PC, and the outcomes are saved as ramdump.csv throughout the QFTASM compile time. The outcomes are then pre-loaded into the RAM when the VarLife and Sport of Life patterns are created. This enables to saves some CPU cycles when working the interpreter.

As defined earlier, the QFT structure holds register values within the RAM. There are 11 registers, that are positioned within the addresses from 0 to 10.

The reserved values within the picture embrace strings akin to reserved atoms and the locations of the bounce hashtable used for analysis. The remainder of the area is used for storing international variables within the interpreter’s C supply code.

Part 1: Parsing

The Lisp program offered from the usual enter is parsed into S-expressions, which is written into the heap area.

Discover that the string interning hashtables are created within the later finish of the stack area. It’s because these hashtables are solely used throughout the parsing part, and may be overwritten throughout the analysis part. For many Lisp applications together with those on this repository, the stack area doesn’t develop far sufficient to overwrite these values. This enables to position 3 rising reminiscence areas throughout the parsing part, the stack area used for nested S-expressions, the heap area which shops the parsed S-expressions, and the string interning hashtables when new strings are detected throughout the Lisp program. Newly detected strings akin to variable names within the Lisp program are additionally written into the heap area.

The heap area can be designed in order that it overwrites the usual enter because it parses this system. Since older elements of this system may be discarded as soon as it’s parsed, this enables to naturally free the usual enter area which save loads of house after parsing. The usual enter additionally will get overwritten by the Commonplace output if the output is lengthy sufficient. Nevertheless, as a consequence of this design, lengthy applications could have bother at parsing, for the reason that enter could also be overwritten too far and get deleted earlier than it’s parsed. A workaround for that is to make use of indentation which locations this system additional forward into the reminiscence, which is able to stop this system from being overwritten from the rising heap area. For the entire applications included on this repository, this isn’t a difficulty and the applications develop into efficiently parsed.

Part 2: Analysis

By this time, the entire contents of the stack area and what’s forward of the top of the heap area may be overwritten within the additional steps. Word {that a} comparable difficulty with the usual enter occurs with the usual output – when too many Lisp objects are created throughout runtime, it might overwrite the present normal output, or could merely exceed the heap area and proceed into the stack area. For the reason that heap area is linked to the later finish of the stack area, this can be secure if the usual output is fastidiously dealt with, however the interpreter will finally begin overwriting values of the stack area if the heap continues to develop.


How can a 2-state OTCA Metapixel emulate the conduct of an 8-state VarLife sample?

This is among the most attention-grabbing concepts within the unique QFT challenge to make the QFT structure potential. As defined in the original QFT post, the 8 states of VarLife are literally a combination of 4 totally different beginning/survival guidelines with binary states. Because of this every VarLife cell can solely transition between two mounted states, and the beginning/survival rule for that cell doesn’t change at any cut-off date. Furthermore, the OTCA Metapixel is designed so that every metapixel can carry its personal beginning/survival guidelines. Subsequently, every VarLife cell may be enoded into an OTCA Metapixel by specifying its beginning/survival rule and the binary state. Because of this the array of OTCA Metapixels within the metafied sample is definitely a combination of metapixels with totally different beginning/survival guidelines, organized in a method in order that it makes the computation potential.

Halting Time

After this system counter is ready to 65535 and this system exits, no extra ROM and RAM I/O indicators develop into obvious in the whole module.
This makes the VarLife sample turns into utterly stationary, the place each sample henceforth turns into utterly equivalent.
Defining this because the halting time for the calculation, the sample for print.lisp halts at precisely 105,413,068 VarLife generations.

The halting time for the Sport of Life patterns are outlined equally for the meta-states of the OTCA Metapixels.
Since OTCA Metapixels by no means develop into stationary, the Sport of Life states don’t develop into stationary after the halting time,
however the meta-states of the OTCA Metapixels will develop into stationary after the halting time.

For the VarLife sample of print.lisp, by era 105,387,540, the worth 65535 will get written to this system counter. At era 105,413,067, the final sign turns into only one step from disappearing, and at era 105,413,068 and onwards, the sample turns into utterly stationary and each sample turns into equivalent to one another.
Within the Sport of Life model, for the reason that OTCA Metapixel continues working indefinitely, the sample doesn’t develop into completly stationary, however the meta-states of the OTCA Metapixels will develop into utterly stationary, since it’s an emulation of the VarLife sample.
Word that the halting instances for applications aside from print.lisp is only a enough variety of generations, and never the precise values.

The required variety of generations per CPU cycle is determined by many components such because the ROM and RAM addresses and the varieties of opcodes, for the reason that arriving instances of the I/O indicators depend upon components akin to these as effectively. This makes the variety of generations required for this system to halt develop into totally different between every program.
For instance, print.lisp has a fee of 23822.16 generations per CPU cycle (GpC), however z-combinator.lisp has a fee of 28870.81 GpC, and primes-print.lisp has 31502.43 GpC. 23822.16 GpC is in actual fact inadequate for z-combinator.lisp to complete working, and 28870.81 can be inadequate for primes-print.lisp to complete working.

Miscellaneous Screenshots

A close-up view of a part of the ROM module in the Conway's Game of Life version.

The ALU unit within the CPU. From the left are the modules for the ANT, XOR, SRE, SRU, SUB, ADD, MLZ, and the MNZ opcodes.

The SRE and the SRU opcodes have been newly added for this challenge.


The CPU structure used on this challenge was initially created by
the members of the Quest For Tetris (QFT) challenge,
and was later optimized and modified by Hikaru Ikuta for the Lisp in Life challenge.
The VarLife mobile automaton rule was additionally outlined by the members of the QFT challenge.
The metafier for changing VarLife patterns to Conway’s Sport of Life patterns was written by the members of the QFT challenge,
and was later modified by Hikaru Ikuta to assist the sample dimension of the Lisp in Life structure.
The meeting language for the QFT structure, QFTASM, was additionally initially designed by the members of the QFT challenge,
and was later modified by Hikaru Ikuta for this challenge for attaining a possible working time.
The Lisp interpreter was written by Hikaru Ikuta.
The compilation of the interpreter’s C supply code to the ELVM meeting is finished utilizing an prolonged model of 8cc
written by Rui Ueyama from Google.
The compilation from the ELVM meeting to QFTASM is finished by an prolonged model of ELVM (the Esoteric Language Digital Machine),
a challenge by Shinichiro Hamaji from Most well-liked Networks, Inc.
The Sport of Life backend for ELVM was written by Hikaru Ikuta, and was later additional prolonged by Hikaru for the Lisp in Life challenge.

Source Link

What's Your Reaction?
In Love
Not Sure
View Comments (0)

Leave a Reply

Your email address will not be published.

2022 Blinking Robots.
WordPress by Doejo

Scroll To Top