Computer Fundamental

Computer Fundamental

How you Managing Complexity?

Ans: for managing complexity we maintain four term that are Modularity, Abstraction,   Hierarchy and Layers.

Modularity:

! Also known as "Divide and Conquer"

! This approach that words best for the Bank Vault Problem

! Idea - Group the system components into a smaller set of interacting subsystems

! Which dimension of complexity does this reduce?

! Example - compilation of a large program

Abstraction

! Hide implementation details behind well specified interfaces

! Choose abstractions to minimize inter-module interactions

! Align modules (or groups of modules) and abstractions

! Careful with performance tradeoffs

Hierarchy

! Organize modules into a tree-like structure

! each node represents a set of modules

! Modules can interact only along the links

! Examples: Businesses

! Reduces interactions from O(n2) to O(n)

Layers

! Organizing technique that uses modularity and abstraction

! Create a different way of looking at an existing system, without adding more functionality

! Example 1: logic gates + memory cells: microprocessor:  machine language processor: Java processor

Briefly describe about Iteration and KIS of computer system?

Ans: all are describe bellow:

Iteration

! Start with a simple, working system that meets a few key requirements (sound familiar?)

! Use what you learn to evolve the system

! Learn from your mistakes early on (study failures!)

! Import new technology as it arrives

! Tradeoffs?

! “The kitchen sink”

! Harder to change early decisions as time goes on

KIS

! Keep It Simple

! “If in doubt, leave it out” - anonymous

! “Everything should be made as simple as possible, but no simpler” - Albert Einstein

! Problem - Convincing someone that leaving something out will help in the long term

! “we need more features to beat competitors!”

! “we’ve already tested each of the 100 features on its own - all we have to do is integrate

them”

What is a Distributed System? Note down the Design Issues of Distribution system ?

Ans:

! Tanenbaum and van Renesse: A distributed system is one that looks to its users like an ordinary, centralized, system but runs on multiple independent CPUs

! Symptoms? Shroeder:

! Multiple, independent processing units

! Processors communicate via a hardware interconnect

! Processing unit failures are independent

! Manage resource sharing

! State is shared among processors

Design Issues of Distribution system are

! Scaling

! Communication

! Coordination

! Transparency

! Naming

! Load sharing

! Consistency

! Failures

! Security

! Heterogeneity

! Mobility

Describe about Communication, Consistency and Load Sharing?

Ans: This short description given bellow:

Communication

! Messages can have many characteristics:

! Length, priority, streams

! Communication medium properties affect communication performance

! bandwidth, latency, multi-cast capability, message prioritization

Consistency

! Since we assume network links can fail at any time, replication is required to maintain consistency for longer computations

! Replication of data

! Replication of computation

! Costs associated with consistency:

! Reduction in the amount of effective resources

! Managing extended failures

Load Sharing

! Local vs. non-local

! e.g., communication failure less likely in local clusters of processors

! Process migration can be expensive

! What about a system that knows the load of each machine, then assigns computation?

! Doesn't scale well

! Issues - Turning Completeness, Propagation Delay

Shortly describe about NFS Mounting and NFS Performance Improvement?

Ans:-

NFS Mounting are bellow:-

_ Local file systems that can be mounted remotely stored in /etc/exports

_ Hard mounts - file system access is a blocking operation

_ Soft mounts - file system access is a non-blocking operation

_ less Transparency

_ Allows client to determine what happens when a failure occurs

_ Not backwards compatible!

8

NFS Performance Improvements are describe bellow:-

_ Locally, typically use read-ahead, write-behind

_ NFS Servers can use read-ahead as-is, but write caching raises fault tolerance issues

_ e.g., what if the server stores a write in the cache, and then dies?

_ Option 1: write-through caching

_ Problem: Performance bottleneck!

_ Option 2: Writes are cached; client determines when cache is written