Background
Computer System Architectures
Computer System Software
Computer System
Architectures
Centralized (Tightly Coupled)
Distributed (Loosely Coupled)
Centralized v Distributed
Centralized systems consist of a single
computer
Possibly multiple processors
Shared memory
A distributed system consists of multiple
independent computers that appear to its
user as a single coherent system
Tanenbaum, p. 2
Defer discussion of distributed systems
Centralized Architectures with
Multiple Processors
(Tightly Coupled)
All processors share same physical
memory.
Processes (or threads) running on
separate processors can communicate
and synchronize by reading and writing
variables in the shared memory.
SMP: shared memory multiprocessor/
symmetric multiprocessor
Symmetric Multiprocessor (SMP)
A stand-alone computer system with
the following characteristics:
two or more similar processors of comparable
capability
processors share the same main memory and are
interconnected by a bus or other internal connection
scheme
processors share access to I/O devices
all processors can perform the same functions
the system is controlled by an integrated operating
system that supports interaction between processors
and their programs
Organization of a Symmetric Multiprocessor
Drawbacks
Scalability based on adding processors.
Memory and interconnection network
become bottlenecks.
Caching improves bandwidth and access
times (latency) up to a point but introduces
consistency problems.
Shared memory multiprocessors are not
practical if large numbers of processors
are desired.
UMA: Uniform Memory
Access
NUMA: Non-Uniform
Memory Access
Based on processor
access time to system
memory.
All processors can
directly access any
address in the same
amount of time.
Symmetric
Multiprocessors are UMA
machines.
One physical address
space
A memory module is
attached to a specific
CPU (or small set of
CPUs) = node
A processor can access
any memory location
transparently, but can
access its own local
memory faster.
NUMA machines address
the scalability issues of
SMPs
Multicore Computers
Combine two or more complete
processors (cores) on a single piece
of silicon (die)
In addition, multicore chips also
include L2 cache and in some cases
L3 cache
In December, 2009 Intel introduced a
48-core processor which it calls a
"single-chip cloud computer" (SCC)
http://www.dailytech.com/article.aspx?newsid=16951
Computer System Software
Operating Systems
Middleware
System Software
The operating system itself
Compilers, interpreters, language run-time
systems, various utilities
Middleware (Distributed Systems)
Runs on top of the OS
Connects applications running on separate
machines
Communication packages, web servers,
Operating Systems
General purpose operating systems
Real time operating systems
Embedded systems
General Purpose Operating
Systems
Manage a diverse set of applications with
varying and unpredictable requirements
Implement resource-sharing policies for
CPU time, memory, disk storage, and
other system resources
Provide high-level abstractions of system
resources; e.g., virtual memory, files
Kernel
The part of the OS that is always in memory
Monolithic kernels versus microkernels
Monolithic: all OS code is in a single program, which
is the kernel.
Microkernels: kernel contains minimal functionality;
other functions provided by servers executing in user
space
Hybrid kernels: a mixture of the two approaches
Kernel Architectures
Traditional: UNIX/Linux, Windows, Mac
Typically monolithic
Non-traditional:
Pure microkernels
Extensible operating systems
Virtual machine monitors
Non-traditional kernels experiment with
various approaches to improving the
performance of traditional systems.
System Architecture and the OS
Shared memory architectures have one or
more CPUs
Multiprocessor OS is more complex
Master-slave operating systems
SMP operating systems
Distributed systems run a local OS and
typically various kinds of middleware to
support distributed applications
Effect of Architecture on OS
SMP
Multicore
Distributed system
Symmetric Multiprocessor OS
A multiprocessor OS must provide all the
functionality of a multiprogramming system for
multiple processors, not just one.
Key design issues:
Design Issues for Multiprocessors
True simultaneous execution
Scheduling
every processor can perform scheduling
activities
Synchronization
Sharing memory
Fault tolerance
Should the OS be designed to handle failures
Multicore Issues - 1
Traditionally, operating systems multiplexed
many sequential processes onto 1 or a few
processors.
With multicore chips a high degree of
parallelism will be available even in small
devices.
The operating system must be able to
harness this parallelism
Multicore Issues
Kinds of parallelism
Instruction level parallelism
Support for multiprogramming on each core
Users must be able to parallelize programs
(multithreading) & OS must be able to
schedule related threads in an intelligent
manner.
Amdahls Law
Speedup = time to run on 1 processor
time on N parallel processors
=
1
(1-f) + f / N
where f is the amount of code that can
be parallelized, with no overhead
Not all code benefits from parallelization but
certain categories of applications; e.g., games,
database apps, JVM (its multithreaded); can
take advantage of multiple cores.
SMP & Multicore
Multicore issues echo those of SMP
Multicore is SMP
Multicore computers are faster and require
less power than SMP with processors on
separate chips.
Faster because signals dont travel as far
Some Multicore Resources
Increased interest in new operating
systems to utilize multicore technology:
Barrelfish Microsoft research/Eth Zurich
http://www.barrelfish.org/#publications
Article from MIT News:
http://web.mit.edu/newsoffice/2011/multicore-series-2-0224.html
Tesselation: a many-core OS (Berkeley)
http://tessellation.cs.berkeley.edu/#
Distributed Systems
Distributed systems do not have shared
memory; communication is via messages.
A distributed operating system would manage all
computers in the network as if they were
individual processors in a SMP
i.e., user would be able to run parallelized programs
without significant modification
Theres no general purpose distributed OS
instead, middleware supports various distributed
applications.
