doc: iteration overview and base

Author: Integer-Ctrl

docs_sphinx/chapters/assembly.rst

@@ -1,14 +1,21 @@
 Assembly
 ========
 
+Before we begin implementing the individual components of the project, we will start with a brief review of assembly language.
+This short chapter is intended as a refresher on the basic knowledge required for the project.
+
 Hello Assembly
 --------------
 
+First, we will look at a simple assembly function, compile it, and examine the generated assembly code.
+
 1. Compile
 ^^^^^^^^^^
 
 **Task**: Use the GCC and Clang compilers to compile the function and generate assembly code.
 
+The following commands will generate assembly code for the file ``hello_assembly.c``:
+
 - gcc: ``gcc -S hello_assembly.c -o hello_assembly.s``
 - clang: ``clang -S hello_assembly.c -o hello_assembly_clang.s``
 
@@ -134,6 +141,23 @@ Hello Assembly
 
 **Task**: Write a C++ driver that calls the ``hello_assembly`` function and test your implementation.
 
+The driver code can be found in the file ``hello_assembly.cpp``:
+
+.. code-block:: cpp
+
+  extern "C"
+  {
+    void hello_assembly();
+  }
+
+  int main()
+  {
+    hello_assembly();
+    return 0;
+  }
+
+Commands to generate an executable and run it:
+
 - ``gcc -c hello_assembly.c -o hello_assembly.o``
 - ``g++ -o hello_assembly.exe hello_assembly.cpp hello_assembly.o``
 - .. image:: ../_static/images/report_25_04_17/hello_assembly_example.png
@@ -143,6 +167,8 @@ Hello Assembly
 Assembly Function
 -----------------
 
+Next we have a look at the assembly file ``add_values.s`` which contains a function that adds two values together.
+
 1. Assemble
 ^^^^^^^^^^^
 
@@ -208,6 +234,8 @@ Size of ``.text``: 0x20 byte or equal 32 bytes. ``.text`` corresponds to the siz
 
 **Task**: Write a C++ driver that calls the ``add_values`` function and illustrate it with an example.
 
+The driver code can be found in the file ``add_values.cpp``:
+
 - ``g++ -o add_values.exe add_values.cpp add_values.o``
 - .. image:: ../_static/images/report_25_04_17/add_values_example.png
     :align: center

docs_sphinx/chapters/overview.rst

@@ -1,4 +1,32 @@
 Overview
 ========
 
-This documentation provides an overview of the Machine Learning Compilers project, which aims to develop a highly effective just-in-time (JIT) compiler for machine learning applications.
+In this project, we will develop a domain-specific compiler for tensor expressions from scratch. Tensor compilers are used to translate
+high-level tensor operations into efficient, low-level code that can be executed on various hardware platforms.
+
+Tensor expressions are mathematical representations of operations on multi-dimensional arrays (tensors). They are widely used in machine
+learning, scientific computing, and data analysis. The goal of this project is to create a compiler that efficiently translates these
+expressions into machine code, enabling high-performance execution on modern hardware.
+
+The compiler developed in this project is designed with the following goals in mind:
+
+- **High Throughput**: Efficient execution of repeated evaluations of the same expression.
+- **Low Latency**: Fast response time for single expression evaluations.
+- **Short Compile Times**: Rapid compilation from expression to executable code.
+- **Flexibility**: Support for a wide range of tensor expressions.
+
+To meet these goals, the compiler will be primitive-based, meaning that complex tensor operations are built from a set of manually tuned
+low-level primitives. These primitives are handcrafted during development and enable just-in-time (*JIT*) compilation of tensor
+expressions to machine code. In this project, the primitives are optimized for the **ARM64** architecture.
+
+Documentation
+-------------
+
+This overview chapter will guide you through the key components of the project. The documentation is structured into several chapters,
+each focusing on a specific aspect of the project.
+
+Assembly
+--------
+
+In the first chapter, :doc:`assembly`, we revisit the basics of assembly language as an essential requirement before diving into implementing
+the compiler. This chapter is intended as a refresher and is not directly part of the project's goal.