Preface#
Recently, I have become obsessed with starknet and the Cairo language, and I have made some notes while learning, so I am sharing them here.
Cairo Program Execution Flow#
In Cairo, the execution flow of a program can be summarized in the following steps:
- Write Cairo source code: Programmers use the Cairo programming language to write the source code of the program.
- Compile the source code: Use the cairo-compile command to compile the Cairo source code into an equivalent bytecode representation.
- Load the bytecode: Use Cairo Runner to load the bytecode and convert it into an executable sequence of instructions.
- Execute the instruction sequence: Execute each instruction in the sequence according to the order in the sequence and determine the operation to be performed and the next state based on the flags of each instruction.
- Output the result: When the program finishes executing, output the result and end the program.
In this process, determinism and non-determinism are widely applied. Some instructions are deterministic, and their behavior can be fully predicted by their inputs and rules. Other instructions are non-deterministic, and they may produce different results and need to be carefully handled to ensure correct handling of all possible results.
In summary, in Cairo, programmers write source code and compile it into bytecode using the cairo-compile command. Then, Cairo Runner loads and executes the bytecode, and outputs the result. Determinism and non-determinism are widely applied to different types of problems and algorithms in this process.
What is Cairo Runner#
Cairo Runner is a computer program used to execute compiled Cairo programs. In Cairo, executing a program is different from executing a regular computer program. This is mainly because Cairo allows the existence of non-deterministic code. Therefore, Cairo Runner needs to support this non-determinism and be able to correctly execute Cairo programs.
In addition, Cairo Runner also supports the concept of relocatable memory segments to leverage Cairo's non-determinism to mitigate continuity requirements. A relocatable memory segment is a continuous memory region used to store data and instructions, and it can be moved to different positions at runtime. This allows Cairo to better handle dynamic memory allocation and garbage collection issues.
Difference between Determinism and Non-determinism#
Determinism and non-determinism are two important concepts in computer science. In Cairo, these concepts are also important.
Determinism refers to the behavior of a system or process that can be fully predicted by its inputs and rules. This means that if given the same inputs and rules, the system or process will always produce the same output. In Cairo, deterministic code can only execute one possible sequence of operations and will produce the same result every time it is executed.
Non-determinism refers to the behavior of a system or process that cannot be fully predicted by its inputs and rules. This means that even if given the same inputs and rules, the system or process may produce different outputs. In Cairo, non-deterministic code can execute multiple possible sequences of operations, and each execution may produce different results.
Cairo allows the use of non-deterministic code to solve certain problems, such as random number generation and search algorithms. However, when using non-deterministic code, it is important to handle it carefully and ensure correct handling of all possible results.
More information about the difference between determinism and non-determinism in Cairo can be found on page 28 of the PDF file.
How Cairo Uses Determinism and Non-determinism#
In Cairo, determinism and non-determinism are widely applied. Cairo's instruction set includes instructions for performing deterministic operations, such as addition, subtraction, multiplication, etc. The behavior of these instructions can be fully predicted by their inputs and rules, and each execution will produce the same result.
On the other hand, Cairo also includes instructions for performing non-deterministic operations, such as random number generation and search algorithms. The behavior of these instructions cannot be fully predicted by their inputs and rules, and each execution may produce different results.
When using non-deterministic code, it is important to handle it carefully and ensure correct handling of all possible results. To support this non-determinism, Cairo Runner needs to be able to correctly handle relocatable memory segments and support garbage collection.
In summary, determinism and non-determinism are important concepts in Cairo, and they are widely applied to different types of problems and algorithms.
More information about how Cairo uses determinism and non-determinism can be found on page 28 of the PDF file.