Thoroughly covers the many ways to design interactive and concurrent client and server software, as well as their proper use and application. This is everyone working on Internet communications. This is the Second Edition of Vol. This is the only book available who's central theme is software design that teaches designers how to structure clients and servers.
The server designs are directly applicable to WWW and other applications. The authors present the most complete coverage of server technology that allows designers to understand the costs and benefits of advanced server technologies. In addition, the Second Edition discusses the use of application gateways to allow client-server communication across heterogeneous protocols.
Convert currency. Add to Basket.
Book Description Pearson India. Condition: NEW. End Chapter Exercises may differ. Legal to use despite any disclaimer. We ship to PO Box, addresses. We may ship the books from multiple warehouses across the globe, including India depending upon the availability of inventory storage.
✎ Books by Douglas E. Comer
In case of orders from Europe, custom charges may comply by the relevant government authority and we are not liable for it. Please feel free to contact us for any queries. Customer Satisfaction Guaranteed. More information about this seller Contact this seller. Condition: New. Excellent Quality, Service and customer satisfaction guaranteed!
We may ship the books from Asian regions for inventory purpose. Book Description Condition: New. SoftCover International edition. Perfect condition. Customer satisfaction our priority. Book Description Condition: Brand New. Customer Satisfaction guaranteed!!. Excellent Customer Service. Book Description Pearson Education. It is written fork. At run-time, however, control passes to the operating system, which creates a new process.
Once the first process completed, the operating system switched the processor to the second process, which also ran to completion. The entire run took less than a second. Therefore, once a process gained control of the CPU, it quickly ran to completion.
If we examine concurrent processes that perform substantially more computation, an interesting phenomenon occurs: the operating system allocates the available CPU power to each one for a short time before moving on to the next. We use the term timeslicing to describe systems that share the available CPU among several processes concurrently. For example, if a timeslicing system has only one CPU to allocate and a program divides into two processes, one of the processes will execute for a while, then the second will execute for a while, then the first will execute again, and so on.
If the timeslicing system has many processes, it runs each for a short time before it runs the first one again. A timeslicing mechanism attempts to allocate the available processing equally among all available processes. Thus, all processes appear to proceed at an equal rate, no matter how many processes execute. With many processes executing, the rate is low; with few, the rate is high. To see the effect of timeslicing, we need an example program in which each process executes longer than the allotted timeslice.
Douglas E. Comer
However, instead of all output from the first process followed by all output from the second process, output from both processes is mixed together. In one run, the first process iterated 74 times before the second process executed at all. Then the second process iterated 63 times before the system switched back to the first process. On subsequent timeslices, the processes each received enough CPU service to iterate between 60 and 90 times. Of course, the two processes compete with all other processes executing on the computer, so the apparent rate of execution varies slightly depending on the mix of programs running.
Creating a truly identical copy of a running program is neither interesting nor useful because it means that both copies perform exactly the same computation.
In practice, the process created by fork is not absolutely identical to the original process: it differs in one small detail. Fork is a function that returns a value to its caller. When the function call returns, the value returned to the original process differs from the value returned to the newly created process. In the newly created process, the fork returns zero; in the original process, fork returns a small positive integer that identifies the newly created process. Technically, the value returned is called a process identifier or process id3. Concurrent programs use the value returned by fork to decide how to proceed.
Remember that each process has its own copy of all variables, and that fork will either return zero in the newly created process or nonzero in the original process. Following the call to fork, the if statement checks variable pid to see whether the original or the newly created process is 3 Many programmers abbreviate process id as pid. The two processes each print an identifying message and exit.
When the program runs, two messages appear: one from the original process and one from the newly created process. To summarize: The value returned by fork differs in the original and newly created processes; concurrent programs use the difference to allow the new process to execute different code than the original process. The mechanism that UNIX uses is a system call, execve4, that takes three arguments: the name of a file that contains an executable object program i.
Execve replaces the code that the currently executing process runs with the code from the new program. The call does not affect any other processes. Thus, to create a new process that executes the object code from a file, a process must call fork and execve.
For example, whenever the user types a command to one of the UNIX command interpreters, the command interpreter uses fork to create a new process for the command and execve to execute the code. Execve is especially important for servers that handle diverse services. To keep the code for each service separate from the code for other services, a programmer can build, write, and compile each service as a separate program. When the server needs to handle a particular service, it can use fork and execve to create a process that runs one of the programs.
Later chapters discuss the idea in more detail, and show examples of how servers use execve. To make sure that all processes proceed concurrently, the operating system uses timeslicing, switching the CPU or CPUs among processes so fast that it appears to a human that the processes execute simultaneously. When the operating system temporarily stops executing one process and switches to another, a context switch has occurred.