Review Questions

Concurrent Systems

  1. Explain the motivation for threads.
  2. Discuss the motivation for and difference between user-level and kernel-level threads.
  3. Explain how the scheduler in a user-level threads package “multiplexes” user-level threads on top of kernel-level threads.
  4. 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?
  5. 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?
  6. 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?
  7. What is meant by a “race condition”? Explain what the implications of race conditions are for debugging concurrent applications.

Distributed Computing

  1. What is meant by network transparency?
  2. Discuss the pros and cons of the following statement: “One of the most important goals of distributed software is to provide network transparency”.
  3. 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”
  4. Discuss with some examples that you are familiar with (from CS 571) how scalability can be achieved in distributed systems
  5. Discuss how distributed systems provide fault-tolerance or enhanced availability. What are the costs associated with obtaining enhanced fault-tolerance?

Client-Server Systems

  1. Give examples of applications that fall into each of the six Gartner Group categories.
  2. What is the motivation for multi-tier architectures? Discuss the pros and cons of multi-tier architectures.
  3. What are the main costs associated with client-server systems? Are these costs reduced in any way in multi-tier architectures?
  4. What is the motivation for thin clients? Do thin clients represent a move back towards centralized computing?

Application-level protocols and Network Programming

  1. Discuss the pros and cons of stateless vs. stateful servers.
  2. Is HTTP 1.0 stateful or stateless? How about HTTP 1.1?
  3. 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?
  4. What are the implications of "statelessness” for NFS? (This was not discussed in class but can be found in OS textbooks)
  5. Discuss the performance problems associated with HTTP 1.0. Are all these problems resolved in HTTP 1.1? Explain.
  6. Discuss how and why cookies are used with HTTP.
  7. Discuss why a sender can block while doing a “write” operation on a TCP socket.
  8. Discuss why the TIME_WAIT state is needed in the TCP protocol.
  9. Discuss why binary files can be transmitted without ASCII encoding for HTTP but need to be encoded into ASCII for email (SMTP).
  10. How are threads useful for client-server applications? Discuss their use in both clients and servers.
  11. What are the advantages and disadvantages of pre-allocating a pool of threads in a server instead of creating threads on demand?
  12. What are the limitations of Java’s socket API? i.e., are there tasks that you can do if you’re using the UNIX/Solaris sockets API that you cannot do in Java?
  13. 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

  1. 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?
  2. "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.
  3. What are the implications of "at least once" semantics for the design of applications that use RPC. 
  4. Give an example of an RPC operation that is idempotent and another that is not idempotent.

RMI & CORBA

  1. 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.
  2. In CORBA, is the remoteness of an object visible to the programmer? What are the differences between Java RMI and CORBA in this regard?
  3. How can RMI be used to "pass behavior" from one system to another?
  4. In RMI, how do you know if an object will be passed by reference or whether it will be passed by value?
  5. Explain the importance of DII and DSI for CORBA ORB-to-ORB communications.
  6. How can a CORBA client invoke a method of a remote object in a non-blocking (asynchronous) fashion?
  7. 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.
  8. Give examples of applications that would find useful the POA policy combinations that were described in class (e.g. RETAIN & USE_DEFAULT_SERVANT).
  9. Discuss the tradeoffs between the various policies or mechanisms that can be used for garbage collection of distributed objects.
  10. Do RMI and CORBA provide at most once semantics or at least once semantics?