Distributed Systems

Distributed System

Hardware and software components, located at networked computers that communicate and coordinate their actions by message passing. They appear to the user as a single computer.

Functional separation

Feature of distributed system that specifies different computers can have different capabilities/purposes

Inherent distribution

Feature of distributed system that allows resources to be physically spread out

Power imbalance and load variation

Feature of distributed system that allows computational load to be spread out

Reliability

Feature of distributed system that means if one computer goes down the system as a whole is still okay

Economies

Feature of distributed systems that means the cost of a technology can be reduced by splitting the cost between several parties

Concurrency

Challenge in a distributed system to keep independent autonomous actions atomic and coordinated

Heterogeneity

Challenge in a distributed system to allow different devices to work together

No global clock

Challenge in a distributed system to ensure all devices keep the same time

Independent failures

Challenge in a distributed system to manage failures of a single node.

Transmission Control Protocol

Transport layer protocol that is connection-oriented

User Datagram Protocol

Transport layer protocol that is connectionless

Port

A 16-bit positive integer that routes network traffic to a specific process on a computer

Socket

An interface between programming networks and the transport layer

Socket(hostname, port)

Java constructor for communication/client socket

ServerSocket(port)

Java constructor for listening socket

accept()

Java method that waits for incoming connections and then returns their socket.

close()

Java method to shut off a socket connection

DatagramSocket(port)

Java constructor for UDP socket

DatagramPacket(message, n, hostname, port)

Java constructor to send UDP message

receive(packet)

Java method for receiving a UDP message

multi-threaded server

A server that simultaneously manages multiple clients

Middleware

A layer of software between applications and the operating system that powers the nodes of a distributed system. Manages higher level features such as communication and management

Distributed Operating System

Single, shared OS that is run over several machines, making them appear to act as one computer. Theoretically ideal but generally not used in practice

Network Operating Systems

Software that connects multiple devices and computers on the network and allows them to share resources on the network. An alternative to DOS

Process manager

OS component that creates and manages processes

Thread manager

OS component that creates and manages threads within processes

Memory manager

OS component that allocates and manages RAM

Communication manager

OS component that handles interprocess communication

Supervisor

OS component that manages privileged operations and protection

Multitasking

Multiple applications (processes) being run concurrently at the OS level

Multithreading

Multiple operations (threads) being run concurrently at the application level

Thread

A piece of code that runs concurrently with other pieces of code

yield()

Java method used to give up CPU voluntarily

suspend()

Java method used to pause thread execution (deprecated)

resume()

Java method used to restart thread execution (deprecated)

stop()

Java method used to terminate thread execution (deprecated)

setPriority(int)

Java method used to set the priority of a thread (lowest = 1, highest = 10)

currentThread()

Java method used to get a reference to the current thread

new Thread(() -> f()).start();

Java expression used to function f() on a new thread.

Worker pool

Multithreaded server architecture that holds a fixed number of threads that can be accessed

Thread per request

Multithreaded server architecture that creates a new thread for every request

Thread per connection

Multithreaded server architecture that creates a new thread for every connection

Thread per object

Multithreaded server architecture that creates a new thread for every object (used in OOP)

Client server model

DS architectural model that requires client processes to interact with server process to access data/resources

Two-tier model

Classic type of client server model that involves one server and (potentially) multiple clients

Three-tier model

Type of client server model that involves two servers, one of which also acts as a client

Multi-tier (cascade) model

Type of client server model that several layers of servers acting as clients to other servers

Kubernetes

Example of a distributed system that divides work between nodes, with allocation manages by a single master entity

Microservices

DS architecture that breaks down software into individual components that communicate via APIs

Proxy server

Servers that sit in the middle of a web server and client and manage caches

Peer processes model

DS architectural model commonly used in messaging applications where any peer can act as client or server

Mobile code

Client server model where code moves to server to client

Mobile agent

Client server model where running program moves from server to client

Thin client and compute server

Client server model where all computation is done server-side

Spontaneous networking

Client server model where clients are small portable, heterogenous and need to be able to seemlessly connection/disconnect (e.g. WLAN)

Fundamental model

A formal description of the properties that are common to all architectures

Interaction model

Model of how DS communicate and coordinate

Latency

Delay when a message is sent/received (problem managed by interaction model)

Bandwidth

Capacity of the network (problem managed by interaction model)

Jitter

Variation in the time taken to deliver a series of messages (problem managed by interaction model)

Clock drift

Difference between time on individual machines (problem managed by interaction model)

Failure Model

Model of the faults that can occur in a DS

Fail-stop

Type of failure where program crashes (detectable)

Crash

Type of failure where program crashes (not detectable)

Omission

Type of failure where message sent is never received

Send-omission

Type of failure where message is set to be sent, but never placed in outgoing buffer

Receive-omission

Type of failure where message is placed in in-buffer, but never received

Arbitrary

Type of failure where message is corrupted, timing is unpredictable, etc.

Clock

Type of failure where local time exceeds bounds of drift from real time

Performance

Type of failure where transmission or operation takes too long

Security model

Model of the threats that a DS is prone to

Kernel

Core component of the OS that manages system resources, hardware and essential resources.

Monolithic

OS design that keeps most of the services in the kernel space

Layered OS

OS design that requires services to be accessed through the interface of the layer below

Microkernel

OS design that keeps a minimal number of services in the kernel space

Hybrid

OS design that combines the benefits of other OS designs

User mode

Privilege level for applications and user space services

Kernel mode

Privilege level for kernel and critical system services

System calls

Used to allow user programs to access the kernel

Maybe

Guarantee of middleware that states RPC may be executes once or not at all (no way of knowing)

At-least-once

Guarantee of middleware that states RPC may be executed at least once

At-most-once

Guarantee of middleware that states RPC may be executed once or not at all

Remote procedure call

Remote invocation used in procedural languages

Remote Method invocation

Remote invocation used in object-oriented languages

Communication Module

Part of RPC that implements design choices (e.g. retransmission requrests, duplicate handling and retransmission of results)

Client stub procedure

Part of RPC that marshals the procedure identifiers and arguments to the communication module

Dispatcher

Part of RPC that selects the server stub based on the procedure identifier and forwards the request to the server stub

Server stub procedure

Part of RPC that unmarshalls the arguments in the request and forwards to service procedure

Remote object

Part of RMI that processes method calls (server)

Remote interface

Part of RMI that specifies which methods can be invoked remotely (client)

LocateRegistry.createRegistry(port)

Java method used to create an RMI registry at the specified port

bind(name, stub)

Java method used to publish a stub to the registry

LocateRegistry.getRegistry(address)

Java method used to retrieve an RMI registry from the specified address

lookup(name)

Java method used to retrieve a stub from the registry

UnicastRemoteObject

Java class that must be extended to create RMI remote object

Remote

Java interface that must be implemented to create RMI remote interface (methods must throw remote exception)

Time coupling

Client and server must exist at the same time

Space coupling

Client and server must know who they are communicating with

Indirect communication

Communication in DS with no direct coupling