Process & it's Architecture

What is a process ?

A process in an operating system (OS) is an instance of a computer program that is currently being executed. It is a sequence of instructions executed in a predefined order. Processes change their state as they execute and can be either new, ready, running, waiting, or terminated. The OS must allocate resources to processes, enable processes to share and exchange information, protect the resources of each process from other processes, and enable synchronization among processes.

The Process Control Block (PCB) is responsible for managing a process in the OS. It contains information about the process, such as its process ID, state, program counter (address of the next instruction to be executed), and other relevant details.

What is a program ? Compiled code, that is ready to execute.

How OS creates a process?

Converting program into a process.

STEPS:

a. Load the program & static data into memory.

b. Allocate runtime stack.

c. Heap memory allocation.

d. IO tasks.

e. OS handoffs control to main ()

Architecture of process:

A process typically consists of the following components:

a. Program Code: This is the binary code of the program being executed. It contains the instructions that the CPU will execute.

b. Data: This includes variables, constants, and other data used by the program. It's stored in the process's memory space.

c. Stack: The stack is used for managing function calls, local variables, and maintaining the execution context. It grows and shrinks as functions are called and return.

d. Heap: The heap is used for dynamic memory allocation. It's where objects, data structures, and memory requested at runtime are stored.

e. Registers: Registers are small, high-speed memory locations within the CPU. They store data, addresses, and other information critical for the program's execution.

Stack & Heap Overflow Issues

Stack overflow and memory errors in the heap are common issues that can occur in computer programs, especially in languages like C and C++ where developers have more direct control over memory allocation and deallocation. Here's an explanation of each problem:

1. Stack Overflow:

   • Cause: A stack overflow occurs when the call stack, a region of memory used for managing function calls and local variables, becomes full. This can happen when a program has too many nested function calls or when functions with large local variables are called recursively without proper termination conditions.

   • Consequences: When a stack overflow occurs, it typically results in a program crash or termination. This is because the operating system cannot allocate more memory for the call stack, and the program cannot continue executing.

   • Prevention and Solutions:

     • Avoid deep or infinite recursion by ensuring that recursive functions have proper termination conditions.

     • If you need to allocate a large amount of memory for local variables, consider using the heap instead of the stack by dynamically allocating memory using functions like malloc in C or new in C++.

     • Increase the stack size, although this may not be a recommended solution as it can lead to other issues and is platform-dependent.

2. Memory Errors in the Heap:

   • Cause: Memory errors in the heap occur when a program improperly manages dynamic memory allocation and deallocation. Common issues include:

     • Memory Leaks: When a program allocates memory on the heap but forgets to release it, causing memory to accumulate over time and potentially lead to the exhaustion of available memory.

     • Dangling Pointers: Accessing or modifying memory through a pointer that has been deallocated or has gone out of scope, leading to undefined behavior.

     • Double Free: Attempting to free a block of memory that has already been freed, which can result in memory corruption.

     • Buffer Overflow: Writing or reading data beyond the bounds of allocated memory, potentially overwriting critical data structures or causing segmentation faults.

   • Consequences: Memory errors in the heap can lead to program crashes, data corruption, security vulnerabilities, and unpredictable behavior. They are often challenging to diagnose and debug.

   • Prevention and Solutions:

     • Use memory management best practices, such as always releasing memory when it is no longer needed (e.g., using free in C or delete in C++).

     • Avoid using raw pointers whenever possible; prefer smart pointers in C++ or safer data structures and libraries in other languages.

     • Perform bounds checking to ensure that array and buffer accesses stay within allocated memory.

     • Use memory analysis tools, like memory profilers and sanitizers, to detect and address memory-related issues during development and testing.

Both stack overflow and memory errors in the heap are critical issues that can lead to program instability and security vulnerabilities. Developers should be vigilant in their code reviews and testing processes to catch and address these issues early in the development cycle.