CPU Registers Explained

• Operating Systems primarily manage processes, covering topics in the CIS*3110 course.
• Parts of a computer commonly include RAM, CPU, and I/O Devices

RAM Organization

• RAM is structured in physical memory with specific sections.
• "Zero Page" contains the interrupt vector, I/O and Basic Input/Output System/Read-Only Memory if present, starting from memory address 0x00...00.
• The top of RAM begins at memory address Ox??...??

Hardware Architecture Tools

• Key components at the hardware level:
• Program Counter (PC) to track current instruction.
• Stack pointer/frame pointer for function call management.
• Processor status register for system state.
• General purpose registers for data manipulation.
• Memory management unit for address mapping and protection.
• Kernel/user mode to define privilege levels.
• Interrupts and interrupt vector for handling external events

Interrupt Vector and Service Routines

• An interrupt vector links hardware devices to specific service routines:
• Disk service routine is at address 3 with function name discintr(...).
• CD service routine is at address 2.
• Mouse service routine is at address 1 with function name mouseintr(...).
• Keyboard service routine is at address 0.

CPU Instruction Cycle and Processor Status

• Basic instruction cycle:
• Fetch instruction pointed to by the PC.
• Increment the PC.
• Execute the instruction.
• This cycle repeats continuously, driving program execution.
• Processor status is managed via a special register on each CPU.
• User mode can execute most instructions, excluding I/O operations.
• Kernel mode can execute all user instructions, plus special instructions for I/O and memory access, often referred to as supervisor mode.
• Interrupt vector is a special range of RAM locations, used to link hardware interrupts to interrupt service routines.

Process and Interrupt Visualization

• Processes (P1, P2, P3, P4) operate in User Space.
• They interact with the Kernel Space through interrupt or trap.
• Kernel Space includes interrupt service routines and hardware interfaces.

Example machine Code Program

• Sample code program:
• load R1, OxA2 is represented as machine code 0x11A2, and located at virtual address 0x10.
• Assembler registers: R0, R1, R2, R3, Stack Pointer (SP), Program Counter (PC)
• Example Op Codes:
• load = 0x1
• store = 0x2
• incr = 0x3
• decr = 0x4
• jmp = 0x5
• jsr = 0x6
• rsb = 0x7
• zero = 0x8

Context Switch

• A context switch is changing the running program "on the fly".
• Context switch requires the "program state" to be saved, including:
• Program counter.
• General purpose registers.
• Status register.
• Stack pointer.
• Each program must be stored resident in different parts of memory.

Context Switch Timeline

• A diagram shows the active program interrupted by Disk or Mouse events to trigger a context switch between process, disk and mouse,

Interrupts

• Interrupts: hardware-generated jump to a subroutine (JSR) requested by an external hardware device.
• Defined through the interrupt vector:
• Stored in physical memory.
• Function pointers array.
• Can be delayed by masking off.

Interrupts Handling

• Interrupt actions include:
• Save Program Counter (PC) on stack.
• Switch CPU to kernel (supervisor) mode.
• Load PC from vector using hardware ID.
• Vector contains interrupt service routine.
• Save all registers, then continue execution.
• Return from Interrupt (RTI) includes:
• Restore registers, then restore saved PC value.
• Set CPU to previous mode

Critical Sections and Shared Data

• A critical section has shared data references between threads.
• Critical sections can involve interrupts, processes, or multiple threads.
• Data use by all parties must be managed to ensure it is reliable.
• Failing to correctly manage data may lead to corruption or it being wrong for some processes.
• Example shows an increment operation i++ represented as a load, increment, and store sequence.

Device Drivers

• Device drivers are classified into three types in UNIX-type systems:
• BLOCK: For devices that read/write blocks (disk, tape, SD card, CD/DVD).
• NETWORK: For local area networks (Ethernet, token ring) and remote connection network interfaces (PPP, ISDN).
• CHARACTER: For devices that do not fit the above two categories (serial ports, keyboards, mice, joysticks, touchscreens).

Device Driver Functions

• Top Half (communicates with user, kernel):
• probe: Checks for hardware during boot.
• open: Called when a process opens a device file, initialises variables and may generate a user space file descriptor.
• close: Called on close(), to file descriptor and marks the device as closed.
• read: Reads data from the device.
• write: Queues data for device output.
• Bottom Half (event handling):
• interrupt service routine: Called when a device generates an interrupt; handles I/O on the hardware.

Device Driver Skeleton - Read Mode

• Device driver skeleton includes static character queue Q[QSIZE].
• Reads data from a queue with a limit to is size

Device Driver Skeleton - Interrupt Mode

• Device driver skeleton includes the GET_CHAR_FROM_DEVICE() function and manages queue operations by sending a signal to wake up a device read.

Running Programs

• Executing a program leads to a process.
• Simplified environment provided by the operating system for program execution.
• UNIX/Mach process environment includes:
• Virtual (simplified) address space.
• Process context.
• Requires no direct access to I/O ports.

Process Table Entry

• The process table stores an entry for each current process.
• Each process has its own entry in the process table, if a process has multiple threads.
• Each entry holds all the information about a process:
• Process context for program counter, registers, stack pointer, and references to virtual address space.
• Scheduling information with status flags for BLOCKED, RUNNABLE, and RUNNING, along with priority and time used.

Process Listing Details

• Process listings that show relevant info like User, Process ID, CPU percentage, Memory use.
• Listing also provides Virtual memory Size (VSZ), Resident Set Size (RSS), Terminal type (TTY).
• Also displays the current states STAT, start time as well as the specific command

Synchronization Primitives

• Shared data between processes/threads requires critical section management.
• Two common synchronization primitives:
• mutex: brackets the critical section, to allow maximum one process at a time.
• semaphores: Allows N number of processes at a time.
• Co-operating sequential processes can be envisioned as a separate, dedicated processor, with no time guarantees when they run.

Mutex Synchronization

• Producer adds to a queue using critical_begin() and critical_end().
• Consumer deletes from a queue using critical_begin() and critical_end().

Mutual Exclusion Implementation

• Mutual exclusion in hardware manages concurrent access using mutex flags.

Dekker's Algorithm

• Dekker's algorithm manages mutual exclusion between two processes using need and turn variables.

Semaphores

• Semaphores synchronize internal integer counters that support signal to increment an internal counter, and wait until value is more than zero, then reduce the counter.

Semaphore Implementation Using Mutexes

• Semaphore functions which implement SEM_WAIT and SEM_SIGNAL using mutexes for process synchronization.

Semaphore Producer/Consumer

• Producer and consumer processes use semaphores for synchronization.

Semaphore Hints

• All semaphores need to be properly initialized.
• Follows from wait_sem() and signal_sem() definitions.
• There will be a wait_sem correlated with signal_sem() on the same semaphore
• Order for wait_sem() operations is important and signal order is less so.

Deadlock Condition

• Deadlock is created when processes hold the same resources and need new ones held by the other
• A cycle in request allocations shown on graph indicate deadlock

Java synchronized Keyword

• The “synchronized” keyword be applied on a whole method or specific block to ensure single access control.

IPC (Inter-Process Communication)

Common processes:

• Shared Memory: shared process image blocks.
• Semaphores/Mutexes: integers to control flow .
• Signals: software “interrupts”.
• Pipes: shared imitation files between two processes.

Signals in Process Communication

• Signals indicate the happening of significant event and its sequence:
• -Process A’ starts and carries out a task. B sends a signal. A interrupts its task and begins managing this incoming signal.
• -The call of a signal handler (function).
• -The return of process A is to what task it originally took on.
• -Process B receives no notification.

Signal value usage

• Signals: integer-based actions, like interrupts:
• -Signals (left column) generally take a constant number.
• -Signals (right column) can vary IDs that depend on the OS

Signal Example Code

• A code example shows how signals are used for sending command interrupts to performing clean up, which calls the signal

Pipes in programing

• Pipes join a pair of file descriptors that are shared between processes, bound to a buffer that all processes use. The buffer lives in memory, and is not on the file system.

Scheduling

• Processes follow the basic scheduler loop:
• -Process halt or wait.
• -The “process table entry” saves process.
• -The table is then “checked”.
• -Context of operations are restored."
• -This system part is completed like the “hardware” tasks.

Discipline

• FIFO: The jobs and/or process join the queue and the repeated joining is called “round robin.” Also, its preemptive.
• SJF:
• “First” lists jobs and the running time and those jobs are ahead in the queue at head. Also, its non- preemptive.
• Discipline is when a part is preemptive before it is done.

Scheduling Algorithms: Queuing Disciplines

• FIFO along with “round robin": fair, as jobs do not need wait.
• SJF is w.r.t. output:
• -If the running job proceeds at shortest “time.”
• -If the number finished jobs go to the set time compared to all “orders”.
• -Processes can be approached with its unjust attributes.

Scheduling Disciplines

• Preemptive planners are better because they are smooth in “response” when compared to non- preemptive and necessary for interactive systems. -Timers have “trade-offs": High better interactive and poor interactive.

Scheduling Algorithms: Queuing

• Preemption takes short shared-time and is titled “processor sharing."
• Discipline here, it will always use “FIFO."

Scheduling tasks

Task-scheduling has these forms:

• -Batch: Tasks completed regardless of “errors."
• -interactive: Runtime “sensitive” with high “I/O."
• -Realtime: CPU at limited timings.

Queue priorities

• -Those systems shift those priorities from system.

Explore CPU architecture focusing on the roles and functions of various registers. Includes the program counter, stack pointer and processor status register. Learn how these registers manage program execution and handle interrupts.