Review Questions
Concurrent Systems
- Explain
the motivation for threads.
- Discuss
the motivation for and difference between user-level and
kernel-level threads.
- Explain
how the scheduler in a user-level threads package multiplexes
user-level threads on top of kernel-level threads.
- How many
kernel-level threads should be used for a multi-threaded
program? Should each user-level thread be mapped to a
separate kernel-level thread? If not, why not?
- Recall
the classical definition of monitors (as defined by Hoare).
Does the Java language (Pthreads library) support
monitors? How is the support for condition variables in
Java (Pthreads) different from condition variables in
classical monitors?
- Are
monitors more powerful as a construct than
semaphores? I.e., can you do accomplish some kind of
synchronization using monitors that you cannot with
semaphores? Are semaphores more powerful than monitors?
- What is
meant by a race condition? Explain what the
implications of race conditions are for debugging
concurrent applications.
Distributed Computing
- What is
meant by network transparency?
- Discuss
the pros and cons of the following statement: One
of the most important goals of distributed software is to
provide network transparency.
- Discuss
the pros and cons of the following statement: Limitations
on robustness and reliability of NFS have nothing to do
with the implementation
The problem can be traced
to the interface upon which NFS is built, an interface
that was designed for non-distributed computing where
partial failure was not possible
- Discuss with some examples that you are familiar with (from
CS 571) how scalability can be achieved in distributed
systems
- Discuss
how distributed systems provide fault-tolerance or
enhanced availability. What are the costs associated with
obtaining enhanced fault-tolerance?
Client-Server Systems
- Give
examples of applications that fall into each of the six
Gartner Group categories.
- What is
the motivation for multi-tier architectures? Discuss the
pros and cons of multi-tier architectures.
- What are
the main costs associated with client-server systems? Are
these costs reduced in any way in multi-tier
architectures?
- What is
the motivation for thin clients? Do thin clients
represent a move back towards centralized computing?
Application-level protocols and Network Programming
- Discuss
the pros and cons of stateless vs. stateful servers.
- Is HTTP
1.0 stateful or stateless? How about HTTP 1.1?
- Is TFTP
stateless? If not, explain why not. Further, explain how
would you redesign TFTP to make it stateless? Would there
be any advantage to doing this?
- What are
the implications of "statelessness for NFS? (This
was not discussed in class but can be found in OS
textbooks)
- Discuss
the performance problems associated with HTTP 1.0. Are
all these problems resolved in HTTP 1.1? Explain.
- Discuss
how and why cookies are used with HTTP.
- Discuss
why a sender can block while doing a write
operation on a TCP socket.
- Discuss
why the TIME_WAIT state is needed in the TCP protocol.
- Discuss
why binary files can be transmitted without ASCII
encoding for HTTP but need to be encoded into ASCII for
email (SMTP).
- How are
threads useful for client-server applications? Discuss
their use in both clients and servers.
- What are
the advantages and disadvantages of pre-allocating a pool
of threads in a server instead of creating threads on
demand?
- What are
the limitations of Javas socket API? i.e., are
there tasks that you can do if youre using the UNIX/Solaris
sockets API that you cannot do in Java?
- Explain
why the sender and receiver in TCP typically restrict the
segment size to the MTU of the network path between them?
Does each segment exchanged over a TCP connection follow
the same network route?
RPC
- What is meant by "at most once" and "at
least once" RPC semantics? How can the underlying
RPC protocol provide "at least once" semantics?
How can it provide "at most once" semantics?
- "It is impossible to implement exactly-once RPC
semantics". Do you agree or disagree with this
statement? If you disagree, explain how your RPC protocol
would provide these semantics. If you agree, explain why
you think it would be impossible to provide these
semantics.
- What are the implications of "at least once"
semantics for the design of applications that use RPC.
- Give an example of an RPC operation that is idempotent
and another that is not idempotent.
RMI & CORBA
- In Java RMI, the remoteness of a remote object is (intentially)
not transparent to the programmer. Briefly discuss the
arguments for and against making the remoteness of an
object visible to the programmer.
- In CORBA, is the remoteness of an object visible to the
programmer? What are the differences between Java RMI and
CORBA in this regard?
- How can RMI be used to "pass behavior" from one
system to another?
- In RMI, how do you know if an object will be passed by
reference or whether it will be passed by value?
- Explain the importance of DII and DSI for CORBA ORB-to-ORB
communications.
- How can a CORBA client invoke a method of a remote object
in a non-blocking (asynchronous) fashion?
- The USE_DEFAULT_SERVANT policy specifies that a POA will
use a single servant to implement all of its objects.
Explain with an example where such a policy would be
useful.
- Give examples of applications that would find useful the
POA policy combinations that were described in class (e.g.
RETAIN & USE_DEFAULT_SERVANT).
- Discuss the tradeoffs between the various policies or
mechanisms that can be used for garbage collection of
distributed objects.
- Do RMI and CORBA provide at most once semantics or at
least once semantics?