Introduction
Address binding is the process of mapping logical addresses to physical addresses in memory. When a program is executed, it does not directly access physical memory; instead, it works with logical addresses that the OS translates into physical addresses.
This translation can occur at different stages of program execution:
- Compile-time binding
- Load-time binding
- Execution-time binding
Types of Addresses in Memory Management
Before understanding address binding, let’s define the types of addresses involved:
- Logical Address (Virtual Address)
- The address generated by the CPU during program execution.
- It is used in the program code and does not directly refer to physical memory.
- The process’s logical address space is independent of actual memory.
- Physical Address
- The actual address in RAM (main memory) where the data or instruction is stored.
- The OS maps logical addresses to physical addresses using address binding mechanisms.
- Mapping Logical to Physical Addresses
- A Memory Management Unit (MMU) translates logical addresses to physical addresses.
- The MMU ensures memory protection and prevents direct access to RAM by processes.
Types of Address Binding
1. Compile-Time Binding
✔ Occurs when: The program is compiled into machine code.
✔ Logical and physical addresses are the same at this stage.
✔ If the starting memory location changes, the program must be recompiled.
📌 Example:
- If a variable X is stored at address 1000 during compilation, it remains fixed at 1000 when loaded into memory.
- No flexibility → If memory address changes, recompilation is needed.
2. Load-Time Binding
✔ Occurs when: The program is loaded into memory by the OS.
✔ If a process relocates to a different memory location, the OS adjusts addresses before execution.
✔ More flexible than compile-time binding.
📌 Example:
- The OS decides to load a program at memory location 4000 instead of 1000.
- The logical addresses in the program are modified to match the new starting address.
3. Execution-Time Binding (Dynamic Binding)
✔ Occurs when: The program is executing and needs memory access.
✔ Logical addresses are translated to physical addresses dynamically.
✔ Processes can move during execution (e.g., swapping in virtual memory).
✔ Most flexible → Used in modern operating systems with paging and segmentation.
📌 Example:
- The OS moves a running process from memory location 5000 to 8000.
- The process continues executing without recompilation or reloading.
Comparison of Address Binding Methods
| Binding Type | When It Happens? | Flexibility | Example Use Case |
|---|---|---|---|
| Compile-Time | During compilation | ❌ Least flexible | Embedded systems, fixed allocation |
| Load-Time | When program is loaded | ⚡ Moderate flexibility | Older OS without virtual memory |
| Execution-Time | During execution | ✅ Most flexible | Modern OS (paging, segmentation) |
Logical vs. Physical Address Space
📌 Logical Address Space → Set of logical addresses generated by a program.
📌 Physical Address Space → Set of physical memory locations assigned to a process.
🔹 The base register in MMU holds the starting address of a process in RAM.
🔹 The limit register ensures a process does not exceed allocated memory.
Conclusion
Address binding is essential for memory management and ensures efficient execution of programs. Modern OS use execution-time binding for flexibility, allowing process relocation and virtual memory usage.