Distributed Programming and Processes Overview

Overview of Topics

• Topics covered in the presentation include processes, creating/deleting Unix processes, inter-process communication, Posix thread programming, Java thread programming, Goroutines in Golang, and virtualization.

Introduction to Distributed Programming

• Distributed programming involves processes communicating over a network.
• A fundamental requirement is understanding how to handle processes locally.

Processes Explained

• Virtual processors are created in software, augmenting physical processors.
• A processor provides instructions and automatically executes instruction sequences.
• A thread is a minimal software processor handling instructions, with context saving for later continuation.
• A process is a software processor within which one or more threads execute, executing instructions in the thread's context.
• Threads share the instructions, global memory, open files, and signal handlers within a process.
• Each thread has its own ID, stack, program counter, stack pointer, errno, and signal mask.

Threads and Distributed Systems

• Multithreaded web clients hide network latency, where separate threads fetch files needed for an incoming HTML page, each doing a blocking HTTP request.
• Display of files happens as they are fetched.
• Multiple request-response calls to different machines (RPC) also hide network latencies. A variety of simultaneous requests (each one on the thread) speeds up the overall response.

One Process Composition

• A process is composed of a process identifier (integer), executing program instructions, memory for program execution, a program counter (current program location), and signal handlers to define action based on received signals.

Processes and Their Creation

• Computers perform concurrent program executions, where each program instance is a process.
• The same program can run multiple times as parallel processes, for example when multiple users start the same program on a computer.
• Processes are created by other processes. A user-initiated command, like running a program, causes the operating system shell process to create the new program's process.

The fork() Primitive

• fork() is the Unix method used to create a process.
• The child process is a duplicate of the parent process (same program, similar state).
• The processes differ in their process IDs, which are returned by fork() appropriately, 0 for the child, or the ID of the child for the parent, or -1 if there is an error during the process creation.
• The programmer's program code typically checks fork()'s returned value for error conditions.

The exec() Primitives

• exec() allows a process to switch to another program, destroying the previous process (code/data).
• The environment variables and file descriptors are preserved.
• The new code is loaded, and is started from the beginning.

Stopping a Process

• A process stops when the main() function returns or when exit() is called.
• A process stops after receiving a signal, or when signal handlers in the destination indicate that a signal was received.
• The SIGINT signal (typically from user keyboard input) stops processes by default.

Signal Handling

• Various signals are sent to processes by the system, indicating events, faults, and errors, like SIGSEGV for segmentation faults (unauthorized memory access) or SIGPIPE if an attempt to write to a pipe that has no reader occurs.

Signal Handlers

• A signal handler is a subroutine run when a signal is received.

Inter-Process Communications (IPC)

• Processes are typically isolated from each other.
• However, processes can communicate via signals, pipes (unidirectional communication channels), shared memory (processes can access the same memory area), and semaphores (used for synchronization).
• All these mechanisms are for IPC between processes on the same computer, not distributed processes.

Pipes

• Pipes are unidirectional communication channels between processes.
• Data written to a pipe is read at the other end.
• For bidirectional communication, use two separate pipes.
• Pipes are commonly used in shell commands.
• Pipes connect processes when those processes share a common ancestor process.

Shared Memory

• Processes share access to memory via shared memory segments.
• Segments must be created & detached when done.
• Careful management is critical to avoid race conditions.

Shared Memory (Example)

• Example code is provided that shows the usage of shmget, shmat, shmdt, and shmctl for managing shared memory segments.

Posix Thread Programming

• Threads (one process with multiple execution pathways, lighter than processes): allow for concurrent execution within a program and share access to the same program instructions, data, open files, and signal handlers.
• Each thread has its own thread ID, stack, program counter, and pointer and stack, errno value, and signal mask.
• Threads use specific synchronization mechanisms, like mutexes, to control concurrent access to shared resources.

Threads in C and Java

• POSIX threads (pthreads) are common in Unix-based systems, and thread-specific libraries must be linked (using the -lpthread option, for example).
• Java threads are a native feature in Java's virtual machines; they are platform-independent and can map to operating system threads or be emulated in user space.

Creating & Stopping a Pthread

• Creating a Posix thread involves using pthread_create.
• Stopping a thread is accomplished using pthread_exit.
• Threads need to be waited for using pthread_join to allow control flow to handle termination

Pthread Synchronization (with Mutex)

• Mutexes (fundamental synchronization tool) provide mutual exclusion for a shared resource.
• Thread safety concerns are handled by explicit locking & unlocking when threads require shared resource access.

Creating Java Threads

• Java threads extend the Thread class and overload the run() method to define the actions executed by the thread.
• Threads are started by calling the start() method.

Stopping Java Threads

• Java threads end when the run() method returns.

Java Thread Synchronization (with Monitors)

• Java monitors control access to shared resources.
• Monitors implicitly involve mutual exclusion.
• Monitors ensure that only one synchronization method for a given object can execute at a time.

Condition Variables

• Condition variables allow conditional waiting between threads.

Goroutines in Golang

• Goroutines are lightweight concurrency units provided by Go, enabling parallel activities within a program.

Goroutines vs Threads

• Goroutines are managed by the Go runtime, while threads are managed by the operating system.
• Goroutines have lower resources usage than threads due to their implementation by the language's go runtime (vs threads managed by the kernel).
• Goroutines provide efficient means for inter-goroutine communication.

Goroutine Example

• Example code showing how Goroutines are defined, concurrent processes are managed and execute.

Virtualization

• Virtualization provides hardware abstraction, making software portable across different hardware platforms and isolating failing or attacked components.
• Virtual Machine (VM) interfaces are abstracted: the running program is isolated to a VM and the associated OS.

VM Architecture

• Various levels of virtualization are supported depending on the system components and their interfaces (e.g., library functions, application code, OS, hardware).

This quiz covers essential concepts in distributed programming, including the creation and management of processes, inter-process communication, and threads in various programming environments like Java and Golang. Explore the differences between processes, threads, and virtual processors, along with their roles in executing instructions. Test your understanding of these foundational programming concepts.