Garbage Collection in Lox

I added Garbage Collection to Lox, I used Mark and Sweep algorithm to mark all roots and trace all references in the compiler, free objects are swept away for memory reuse. So you don't have to worry about memory management, you can add variables.

I also added Object Oriented Progamming in Lox, it has classes, intances, constructors, supercalls, inherited methods and fields: 

You can define classes within functions and methods with its own methods:

This is the disassembler of the code above, I optimized the calls to methods via super-intructions, these instructions basically make the function of two instructions in once:

If you want to look at the code:

Compiler Code

Closures in Lox

I made closures in Lox to capture local variables outside the functions.

closure() is a closure that captures a variable.

This is the disassembly of the main function:

a variable is closed with OP_CLOSE_VALUE instruction

We can see that it prints 3 two times since a is closed at the end of the for loop and since Lox captures variables and not values both closures globalOne and globalTwo print the same variable reference!

The  Lox Closure system is made in the runtime. I made it in the virtual machine. and the variables are closed in the heap since the stack is gone once the two calls are made.

Programming Language from Scratch

I made my own programming language clox from scratch Lox in C. It is a compiled and interpreted language.

It has dynamic typing. It has expressions and scopes, global variables and local variables.

This gets compiled to bytecode and looks like this:

Then it gets executed by the virtual machine which is a stack based machine, you can see the stack grow (variables in brackets) when constants are pushed into the stack by operation OP_CONSTANT:

Locals are stored in the stack directly and globals are stored in a hash table.

If you want to look at the code:

Lox Programming Language

Binary Analysis of PE Files

I made analysis of Binary Data to find the structure of executables and undestand its content for x86 architectures.

I reversed Engineered the binary files.

There's an MS-DOS 2.0 Compatible EXE Header.

At location 0x3c, the stub has the file offset to the PE signature.

Then it is the PE signature which is: "PE\0\0".

Then it is a standard COFF File Header:

Then it is the optional header and depending on the PE format it can be PE32 or a PE32+:

The standard Fields have the Magic Number and the size of the code section:

Then it is Windows Specific Directories which are more but it can´t be seen here:

Then there are a bunch of Data Directories and after that there are section tables.

You have to find the .text section.

Once I found the code data I disassembled it with the disassembler to find the code.

Disassembler in C

 I made a Disassembler in C that reads Binary Data and converts them into assembly code:

I made the No-SQL Database as well for binary instructions and procedures to query the Database.

If you want to look into the code:

Disassembler Code

ETL to No-SQL Database

I made ETL from an XML Database to a No-SQL Database. 

The Database is Document Oriented.

This is an XML Entry in the Database:

The Data Needed to be classified into groups of processor modes: s, p and e

16 Mode, 32 Mode and 64 Mode.

The Data needed to be grouped into one byte or two bytes:

The Data needed to be divided into two groups opcodes and mnemonics, for the example above the ADD instruction of one byte I made ETL to divide the data into opcode data and mnemonic data.

For each primary opcode there are multiple entries, that is why I need to classify by that as well.

This is a 16 bit Processor Mode Instruction:

Once I classified and cleaned the data I can Insert it into the document-oriented Database:

This is made for all the entries. This is just an example of the pipeline.

MARL Multi Agent Reinforcement Learning

I made MARL (Multi Agent Reinforcement Learning) with DDPG (Deep Deterministic Policy Gradient). 

I made the DDPG with python and Pytorch. I used Unity Machine Learning Agents for the environment. 

This model can be used for robots that need to learn collaboration with continuous action spaces.

Two agents need to learn to interact with each other to play Tennis. They have to pass the ball over the Net and work collaboratively.

I made one DDPG with two Noises.

I solved the environment. This is the learning by episode Score Table:

If you want to look at the code:

DDPG Code