COMP 339-439
v0.5
Index
Site
Introduction and Issues
What is a distributed system?
Examples
Illustration
Advantages of Distributed Systems vs. Centralized
Advantages of Distributed Systems vs. Standalones
Disadvantages of Distributed Systems
Key Characteristics
Resource Sharing
Resources Must be Managed
Openness
Open Distributed Systems
Concurrency
Scalability
Fault Tolerance
Transparency
Design Issues
Issues arising from Distributed Systems
Naming
Naming - Name Resolution
Naming - Design Considerations
Communication
Types of Communication
Client-Server Communication
Client-Server Communication
Group Multicast
Software Structure
Distributed System Software Structure
Consistency Management
Caching
Consistency
Workload Allocation
Processor Pool Model
Quality-of-Service
Networking Primer
Networks
Many Types of Networks
Many Types of Networks
Many Types of Networks
Internetworks
Performance Issues
Example- A Typical Campus Network
Network Topologies
Network Topologies
A Network is not an Island
Design Issues In Layers
Protocols are divided into layers
Physical Layer
Data Link Layer
The Network Layer
The Transport Layer
The Session & Presentation Layers
Application Layer
Interprocess Communication:
Reliability
Mapping Data to Messages
Marshaling
Case Study: UNIX Interprocess Communication (IPC)
Example - Simple TCP Messaging Framework (from HPJPC)
Message class
MessageClient class
MessageServer class
MessageServerDispatcher class
DateService using Message Classes/Interfaces
DateClient using Message Classes/Interfaces
Sockets Communication Using Datagram
Stream Communication
Remote Procedure Call
Remote Procedure Call (RPC)
Observations
RPC
RPC Mechanisms
RPC Steps
Design Issues
Parameter Passing
Parameter Passing
Binding
Use of Specification
Locating the Server
How to Handle Failures
Client Cannot Locate Server
Lost Request Message
Lost Reply Message
Lost Reply Message
Server Crashes
Server Crashes
Client Crashes
Client Crashes
Acknowledgments
Flow Control
Performance
Concurrency and Threads
Threads vs Processes
What are Processes, Threads?
Common Threading Use Cases
Mutual Exclusion
Tools for Achieving Mutual Exclusion
Mutex Example/Java
Semaphore Example
Barrier
Deadlock - a classic problem
Fork
Diner0
Diners0
Diners1 - eliminating deadlock with resource enumeration
Execution - With Deadlock
Deadlock-Free Version
Common Data Structures in Concurrent Programming
Design Considerations
Kernel Threads vs User Mode Threads
Concurrent File Copy Example
Sequential File Copy
Concurrent File Copy Organization
Execution
Distributed Systems and Storage
Types of Non-Local Storage
How Do We Evaluate Storage Systems?
Storage Devices
Storage and Failure
Maximizing Availability - RAID
RAID
RAID - 0
RAID - 1
RAID - 5
Local Storage
Implementing Files and Folders
Inodes
Inodes - Indirect Blocks
Block Caches
Folders and Path Traversal
Virtual Filesystems / VFS
Virtual Filesystems / VFS
Virtual Filesystems and Stacking
Distributed Filesystems
File Service Model
Directory Service
Naming Transparency
File Sharing Semantics
UNIX Semantics
More Semantics
Distributed File System Implementation
System Structure
Directory Service
Stateless versus Stateful
Caching
Caching - Server
Caching - Client
Client - Cache Consistency
Client - Cache Consistency - Other Options
Replication
Replication - Update Protocols
Replication - Voting Algorithm
Replication - General Quorum Algorithm
Case Study - SUN NFS
SUN NFS - Implementation
Directories and LDAP
What is a Directory?
What is NOT a Directory?
Types
Characteristics of Directories
Evolution of Directories
So what is LDAP, exactly?
Early LDAP Implementations
SLAPD: Stand-alone LDAP Daemon
SLAPD: Continued
LDAP Client-Server Exchange Protocol
Example LDAP Usage
Schemas
attributes and objectclasses
Namespaces
LDAP Tree Topology
Network Architecture
Distributed LDAP Server Model
LDIF Example
Acknowledgements
References
Continuous Integration
What Does Continuous Integration Do?
How Often is Continuous Integration Run?
What are the Bits and Pieces of Continuous Integration?
Continuous Integration Products / Vendors
Continuous Integration and the Key Characteristics of Distributed Systems
Case Study - My Simple CI System
The Front Page of Team City
Build Nodes
Project Build Management With Maven
Introduction
Creating a Maven Project from Scratch
Generating an Eclipse Project from a Maven Project
Configuring Eclipse
Running Unit tests with Maven
Writing with Sphinx
Introduction
About Sphinx
Additional Resources
Setting up Sphinx - Ubuntu Linux
Sphinx on non-Linux Platforms
Setting up Sphinx - Mac OSX (Using HomeBrew instead of MacPorts)
Setting up Sphinx - Windows
Setting up Sphinx in a Python virtualenv
Authoring in Sphinx
Examples
Clocks and Synchronization
What is Time? Some Physics
Time and Computation
Physical Clocks
Physical Clocks - Multiple Systems
Clock Synchronization
Clocks Synchronization and Reliability
Lamport’s Logical Clocks
Implementing Lamport’s Logical Clocks
Limitations of Lamport’s Logical Clocks
Vector Clocks
Implementing Vector Clocks
So... What Did We Get Out of All of This?
Domain Name Service
Message Passing Interface
Object Brokers and CORBA
REST and Web Services
NoSQL and Sharding
Legacy Lectures
Software
Introduction
Networking Overview
Threads and Processes
Filesystems
Filesystems Research at LUC
Grids and Clouds
Message Passing / Messaging Middleware
Distributed Object Programming
Modern Distributed Databases
Page
Message Passing Interface
Source
Message Passing Interface
¶