Malleum Knowledge Base

What happens

6 min read

When a Rust program is executed, the process is quite similar to executing any other program, but with some specific nuances due to Rust’s unique runtime characteristics. Here’s what happens when you run a Rust executable:

1. Executable Launch

  • User Action: You might start the Rust program from a command line, a script, or by double-clicking an executable file, depending on the environment.

2. Executable Loading

  • Binary Format: The operating system loads the executable file into memory. Rust typically compiles to a binary in the platform’s native format (e.g., PE on Windows, ELF on Linux).
  • Validation: The OS checks the binary’s header to confirm it’s valid and determines how to map its segments (like text, data, and BSS) into memory.

3. Dependency and Library Loading

  • Dynamic Libraries: If the Rust binary depends on dynamic libraries (e.g., dll files on Windows, so files on Linux), the operating system loads these into the process’s memory space.
  • Rust Runtime: Rust programs that are compiled for standard environments link against libc and potentially other libraries, depending on their dependencies and features used.

4. Process and Thread Initialization

  • Process Control Block: As with any other program, the OS sets up a control block for the new process.
  • Primary Thread: The OS initializes the primary thread of the Rust process, setting up its stack and registers.

5. Rust-Specific Initializations

  • std Crate: If the program uses Rust’s standard library, any global state or objects that need to be initialized will be set up before the main logic starts.
  • Panic Handler: Rust setups up the panic handler; Rust’s way of handling unexpected errors. If the program panics, this handler will take action, which might involve unwinding the stack (default) or aborting the program, depending on how it was configured.

6. Execution of Rust’s main Function

  • Static Constructors: Before main is executed, Rust initializes any static variables that require runtime initialization.
  • main Function: Control is then passed to the Rust program’s main function. This is the entry point for Rust code, similar to main in C/C++ but handled in a way that ensures all Rust-specific runtime prerequisites are met.

7. Runtime Environment Handling

  • Memory Management: Rust’s ownership and borrowing rules, enforced at compile-time, ensure that most memory safety issues are resolved before runtime. However, the runtime still has to deal with allocations and deallocations via Rust’s allocator (which by default uses the system allocator but can be customized).
  • Error Handling: Rust uses Result and Option types for error handling, avoiding exceptions. The handling of these types is weaved into the logic of the Rust code itself.

8. Program Termination

  • Exit: Once main completes, Rust cleans up any remaining used resources, handles the return value of main, and exits cleanly, returning control to the operating system.

Unique Aspects of Rust

  • No Implicit Runtime: Unlike languages like C# or Java, Rust does not have a heavy runtime or a virtual machine. It compiles directly to machine code, with minimal runtime overhead for memory safety checks and handling panics.
  • Minimal Startup Overhead: The startup phase for a Rust program is typically faster and leaner compared to languages that require JIT compilation or have significant runtime initialization phases.

By understanding these steps, you can better grasp how Rust manages both the efficiency and safety of your applications, leveraging both compile-time checks and runtime mechanisms to ensure robust execution.

Certainly! Let’s go through the detailed steps involved in executing a Rust program, using a simple “Hello, World!” program as an example. This will illustrate the lifecycle from code to execution on a typical system, such as a Windows or Linux machine.

Step 1: Writing the Rust Program

Program Code (main.rs):

fn main() {
    println!("Hello, World!");
}

This is the complete source code for a basic Rust program that prints “Hello, World!” to the console.

Step 2: Compilation

When you compile this program using rustc, the Rust compiler:

rustc main.rs

What Happens:

  • Parsing: The source code is parsed into an abstract syntax tree (AST), representing the code in a tree structure.
  • Analysis: The compiler performs static analysis, checking for type errors, borrowing violations, and other potential issues according to Rust’s strict compilation rules.
  • Code Generation: If the code passes all checks, rustc compiles the AST into LLVM intermediate representation (IR). LLVM further optimizes this IR and generates machine code specific to the target platform.
  • Linking: The Rust compiler links the generated object code with the Rust standard library and other dependencies to produce a binary executable. In our simple example, the primary dependency is the standard library, which includes implementations for I/O functions like println!.

Step 3: Loading the Executable

When you execute the compiled binary, the operating system performs several steps:

  • Executable Loading: The OS loader reads the binary file from disk, parses the headers to determine the required resources and memory layout, and maps the executable into memory.
  • Dependency Loading: Dynamically linked libraries, including the Rust runtime components from the standard library, are loaded into memory. On Windows, this involves loading DLLs; on Linux, shared objects (.so files) are loaded.

Step 4: Process Initialization

  • Process Setup: The OS initializes a new process, creating a process control block (PCB) that holds process-specific information like process ID, state, and memory allocations.
  • Primary Thread Creation: The main thread of the process is started. This thread will begin execution at the entry point defined by the Rust runtime, which in turn calls the main function of our program.

Step 5: Execution of main

  • Runtime Setup: Before main is called, the Rust runtime initializes any necessary facilities such as:
    • Panic Handling: Setting up default handlers for panics, which in Rust can either unwind the stack or abort execution, depending on configuration.
    • Memory Management: Initializing any necessary structures for heap memory management used by the allocator.
  • Running main: Control is passed to the main function. The println! macro is called:
    • Macro Expansion: println! expands to calls that involve formatting the string and writing to the standard output. This involves system calls to handle I/O operations.
    • System Interaction: The string “Hello, World!” is sent to the console, which involves interacting with the operating system’s I/O subsystem.

Step 6: Process Termination

  • Completion of main: After println! executes, main returns.
  • Cleanup: The Rust runtime handles any necessary cleanup tasks, such as freeing used memory and closing any open resources.
  • Exit: The main thread exits, and the OS cleans up the process. The exit status is returned to the system, typically indicating successful completion.

Summary

From writing the code to running the binary, each step involves interaction between the Rust program, the compiler, the runtime, and the operating system. Rust’s design ensures that as much error checking as possible is done at compile-time, leading to a minimal runtime footprint and performance overhead. This example highlights Rust’s efficiency and safety features, which are especially evident in how it handles memory management and errors.

Graph View