What is Relocation in Memory Management?
Relocation in memory management explained — static vs dynamic relocation and the relocation register — with OS interview questions.
Expected Interview Answer
Relocation is the process of adjusting a program’s memory address references so it can be loaded and correctly executed at a physical memory location that is different from the one it was originally compiled or linked to assume.
A compiler typically generates code assuming the program will start at address zero, but in a real multiprogramming system the OS may load that program anywhere in physical memory, and may even move it while it runs to compact free space or make room for other processes. Static relocation adjusts every address-dependent instruction once, at load time, by adding the load address as an offset to every reference before execution begins, which is fast but means the program cannot be moved again afterward without redoing the adjustment. Dynamic relocation instead uses hardware support, typically a relocation register loaded with the process’s current base address, so every logical address the CPU generates is transparently offset by that register’s value on every single memory access, which allows the OS to freely move the process in physical memory at any time simply by updating the register. Dynamic relocation is what modern operating systems use because it enables compaction, swapping, and paging, none of which would be possible if addresses were permanently baked into the program at load time.
- Lets a program run correctly no matter where the OS loads it in physical memory
- Dynamic relocation enables moving a process later, supporting compaction and swapping
- Foundation for paging, where each page can be independently relocated
- Decouples program compilation from the eventual runtime memory layout
AI Mentor Explanation
Relocation is like a touring team’s fixture list being written with provisional ground names, then the actual ground assigned only once the tour schedule is finalized — every "home ground" reference in the fixture list is adjusted to the real venue at that point. If the venue later changes due to weather, static relocation would mean reprinting the whole fixture list, while dynamic relocation is like the team simply updating one central "current venue" reference that every fixture automatically points through, without touching the printed list itself.
Step-by-Step Explanation
Step 1
Compile-time assumption
The compiler generates code assuming a starting address of zero, unaware of the eventual physical load location.
Step 2
OS decides load location
At load time, the OS picks an available physical memory region for the process, which may differ from address zero.
Step 3
Static or dynamic adjustment
Static relocation patches every address once at load time; dynamic relocation instead loads a relocation register that offsets addresses on every access.
Step 4
Process may move later
With dynamic relocation, the OS can move the process for compaction or swapping simply by updating the relocation register, without touching the code itself.
What Interviewer Expects
- A clear definition of why relocation is needed (compile-time address assumption vs actual load location)
- Distinction between static relocation (one-time patch) and dynamic relocation (hardware register)
- Awareness that dynamic relocation enables moving a process after it starts running
- Connection to compaction, swapping, and paging as beneficiaries of dynamic relocation
Common Mistakes
- Thinking relocation only happens once and never again for a running process
- Confusing relocation with the overlay technique or paging directly
- Not knowing static relocation prevents the process from being moved later
- Forgetting the relocation register is what enables dynamic relocation in hardware
Best Answer (HR Friendly)
“Relocation is how the operating system makes a program work correctly no matter where in memory it actually gets loaded, even though the program was compiled assuming it would start at address zero. Modern systems do this dynamically with a hardware register that offsets every address on the fly, which also means the OS can move a running program around in memory later without breaking it.”
Code Example
unsigned relocation_register = 0; /* set by the OS when the process is loaded/moved */
void load_process_at(unsigned physical_base) {
relocation_register = physical_base; /* moving the process is now O(1) */
}
/* Every memory access the CPU makes is transparently offset like this: */
unsigned resolve_physical(unsigned logical_addr) {
return logical_addr + relocation_register;
}
/* Compacting memory: move a process, then just update the register */
void compact_and_move(struct process *p, unsigned new_base) {
memcpy((void *)new_base, (void *)p->physical_base, p->size);
p->physical_base = new_base;
relocation_register = new_base; /* no code inside the process changes */
}Follow-up Questions
- What is the difference between static and dynamic relocation?
- How does a relocation register relate to a base-and-limit register scheme?
- How does relocation enable memory compaction?
- How does relocation relate to paging, where each page has its own frame mapping?
MCQ Practice
1. Why is relocation needed at all?
Compilers typically assume address zero as the start; relocation adjusts references so the program works wherever it is actually loaded in physical memory.
2. What allows the OS to move a running process to a different physical location using dynamic relocation?
With dynamic relocation, updating the relocation register is enough — every subsequent address generated by the CPU is offset by the new value automatically.
3. A key limitation of static relocation compared to dynamic relocation is?
Static relocation bakes the load address into the code once; moving the process afterward requires re-patching every address again, unlike dynamic relocation’s single register update.
Flash Cards
What is relocation? — Adjusting a program’s address references so it runs correctly at whatever physical memory location it is actually loaded into.
Static vs dynamic relocation? — Static patches addresses once at load time; dynamic offsets addresses on every access via a hardware relocation register.
What enables moving a running process? — Dynamic relocation — updating the relocation register moves the process without touching its code.
What does dynamic relocation enable? — Memory compaction, swapping, and (in generalized form) paging.