Consecutive Commands by a Single User

So far, we have assumed that a user enters a command when the system is in a quiescent state. In this section, we relax this assumption by considering the case when a user enters a command before all users’ devices have completed the processing and transmission tasks of all commands entered previously by the user. Thus, we are considering the case

107

when think times are low or there is type-ahead and only one user is entering commands. In this case, a command may arrive at a computer early, that is, before the computer has

completed the processing and transmission tasks of a previous command. When this happens, the new command must wait until the computer completes the transmission and processing task of the previous commands. Hence, the analysis presented so far does not apply because a command can be delayed on a user’s computer for longer than the time accounted for in the above response time equations. We next present an analysis that accounts for this additional delay. We present first the analysis for input commands entered by a master user in the replicated architecture.

Replicated Local Response Time

Consider first the local response times of commands entered by a master user. The response time equation for the first command 𝑖 entered by master 𝑗 user when the system is in a quiescent state is repeated from above

𝑙𝑜𝑐𝑎𝑙𝑅𝐸𝑃,𝑖,𝑗 = 𝑓𝑎𝑛𝑗 ∗ 𝑥_{𝐶𝑃𝑈𝑖,𝑗}𝐼𝑁 + 𝑝𝑖,𝑗𝐼𝑁 + 𝑝𝑖,𝑗𝑂𝑈𝑇

Suppose that user 𝑗 enters command 𝑖 + 1𝑡𝑖+1 time after entering command 𝑖 and that 𝑡_𝑖+1 < 𝑓𝑎𝑛_𝑗 ∗ 𝑥_{𝐶𝑃𝑈 𝑖,𝑗}𝐼𝑁 + 𝑝_𝑖,𝑗𝐼𝑁 + 𝑝_𝑖,𝑗𝑂𝑈𝑇. Therefore, after command 𝑖 + 1 arrives, the CPU on userj’s computer still requires 𝑓𝑎𝑛𝑗 ∗ 𝑥𝐶𝑃𝑈 𝑖,𝑗𝐼𝑁+ 𝑝𝑖,𝑗𝐼𝑁 + 𝑝𝑖,𝑗𝑂𝑈𝑇 − 𝑡𝑖+1 time to complete the transmission and processing tasks of command 𝑖. The response time of command 𝑖 + 1 includes this additional delay, and is given by

𝑙𝑜𝑐𝑎𝑙𝑅𝐸𝑃,𝑖+1,𝑗 = 𝑓𝑎𝑛𝑗 ∗ 𝑥_{𝐶𝑃𝑈 𝑖,𝑗}𝐼𝑁 + 𝑝𝑖,𝑗𝐼𝑁 + 𝑝𝑖,𝑗𝑂𝑈𝑇 − 𝑡𝑖+1+ 𝑓𝑎𝑛𝑗 ∗ 𝑥_{𝐶𝑃𝑈 𝑖+1,𝑗}𝐼𝑁 + 𝑝𝑖+1,𝑗𝐼𝑁 + 𝑝𝑖+1,𝑗𝑂𝑈𝑇 Suppose that user 𝑗 enters command 𝑖 + 2𝑡_𝑖+2 time after entering command 𝑖. If the command is entered after userj’s computer completes all tasks for command 𝑖, this is the

computer is still carrying out tasks for command 𝑖, then the local response time of command

𝑖 + 2 includes the time the computer requires to complete the tasks for command 𝑖, 𝑓𝑎𝑛_𝑗 ∗

𝑥_{𝐶𝑃𝑈 𝑖,𝑗}𝐼𝑁_{+ 𝑝}

𝑖,𝑗𝐼𝑁 + 𝑝𝑖,𝑗𝑂𝑈𝑇 − 𝑡𝑖+2, plus the time it requires to complete the tasks for command

𝑖 + 1, 𝑓𝑎𝑛𝑗 ∗ 𝑥_{𝐶𝑃𝑈 𝑖+1,𝑗}𝐼𝑁 + 𝑝𝑖+1,𝑗𝐼𝑁 + 𝑝𝑖+1,𝑗𝑂𝑈𝑇, plus the time it requires to perform the task for command 𝑖 + 2, 𝑓𝑎𝑛_𝑗 ∗ 𝑥_{𝐶𝑃𝑈 𝑖+2,𝑗}𝐼𝑁 + 𝑝_𝑖+2,𝑗𝐼𝑁 + 𝑝_𝑖+2,𝑗𝑂𝑈𝑇 . More generally, the local response time of command 𝑖 + 𝑧 entered 𝑡_𝑖+𝑧 time after the CPU on userj’s computer begins transmitting

command 𝑖 but before it completes processing command 𝑖 is given by

𝑙𝑜𝑐𝑎𝑙𝑅𝐸𝑃,𝑖+𝑧,𝑗 = 𝑓𝑎𝑛𝑗 ∗ 𝑥_{𝐶𝑃𝑈 𝑐,𝑗}𝐼𝑁 + 𝑝𝑐,𝑗𝐼𝑁 + 𝑝𝑐,𝑗𝑂𝑈𝑇 𝑖+𝑧

𝑐=𝑖

− 𝑡𝑖+𝑧

As described above, userj’s computer’s destination delay for command 𝑖 entered in a

quiescent state is equal to 𝑓𝑎𝑛_𝑗 ∗ 𝑥_{𝐶𝑃𝑈 𝑖,𝑗}𝐼𝑁 + 𝑝_𝑖,𝑗𝐼𝑁+ 𝑝_𝑖,𝑗𝑂𝑈𝑇. Therefore, the above equation can be stated equivalently as

𝑙𝑜𝑐𝑎𝑙_{𝑅𝐸𝑃,𝑖+𝑧,𝑗} = 𝑑𝑒𝑠𝑡(𝑐, 𝑗)

𝑖+𝑧

𝑐=𝑖

− 𝑡_𝑖+𝑧

Replicated Remote Response Times

The remote response time analysis is more complicated. The reason is that a command may arrive early at more than one computer from the path to the destination. In particular, even if userj enters command 𝑖 + 1 after the computer 𝑗 completed the tasks for

command 𝑖, an intermediate or the destination computer may not have completed tasks for command 𝑖 by the time command 𝑖 + 1 reaches it. To illustrate how this can happen, consider the remote response times of userb for command 𝑖 + 𝑧 entered by userj. Let

109

takes the longest to perform tasks of commands. We call _𝑠 the critical computer on the path. If 𝑠 is idle when command 𝑖 + 𝑧 reaches it, then all computers must be idle when the

command reaches them. Therefore, response times reduce to those of commands entered in a quiescent state. Thus, we consider the case when _𝑠 is busy performing tasks for previous commands when command 𝑖 + 𝑧 reaches it. Let command 𝑖 entered by userj be the last

command that _𝑠 received when it was in an idle state. Since it was idle when command 𝑖 reached it, then all computers were idle when the command reached them; otherwise, _𝑠 would not be the critical computer on the path. Moreover, command 𝑖 + 𝑧 reaches all computers downstream from _𝑠 when they are in an idle state; otherwise, again, _𝑠 would not be the critical computer on the path.

Figure 3-5. Critical computer on path from source to destination. time Source 1 i i+1 cmd i, i+1, and i+2 i+2 ₃ ₄ Destination_ 5 ₂ i i+1 i+2 i i+1 i+2 i i+1 i+2 i i+1 i+2 ti+z Time cmd i takes to reach 3 Time 3 takes perform tasks for cmds i to i+1 and transmit i+2 to 5 Time cmd i+2 takes to reach 5 from 3

We illustrate the notion of a critical computer through an example of a path of length five shown in Figure 3-5. As Figure 3-5 shows, three commands, 𝑖, 𝑖 + 1, and 𝑖 + 2, are entered consecutively. The total transmission and processing time for each for each

command on the five computers is shown by the sizes of the boxes in the diagram. The total times spent on a command by each computer ordered from lowest to highest are ₁ < ₂ =

₄ <₅ < ₃. As Figure 3-5 shows, the source user inputs commands quicker than the source computer ₁ can complete the transmission and processing tasks. Hence, commands arrive early at the source computer. Since 2, the next computer on the path, takes longer to complete the tasks for each command, they arrive early also at 2. Since 3 is takes even longer than ₂ the second computer, they also arrive early at ₃. However, they do not arrive early at ₄ and ₅, the destination computer. The reason is that these computers are able to complete the tasks for each command faster than ₃ the third computer. Hence, in this case,

3 is the critical computer.

We can use the notion a critical computer to derive the remote response time of command 𝑖 + 𝑧. The critical computer may be an intermediate computer or the destination computer. When it is an intermediate (destination) computer, then userb’s remote response

time of command 𝑖 + 𝑧 is equal to 1) the amount of time that elapses from the moment command 𝑖 is entered to the moment it reaches the critical computer, 2) plus the amount of time that elapses from the moment the critical computer receives command 𝑖 to the it transmits command 𝑖 + 𝑧 to the next computer on the path (completes processing of command 𝑖 + 𝑧), 3) plus the amount of time that elapses from the moment the critical computer transmits command 𝑖 + 𝑧 to the next downstream computer to the moment userb

111

entered to the moment command 𝑖 + 𝑧 is entered. The case when an intermediate computer other than the source is the critical computer is illustrated in Figure 3-5. Since the critical computer is idle when command 𝑖 reaches it, then by the definition of the critical computer, all computers are idle when command 𝑖 reaches them, as shown in Figure 3-5. Thus, the first is term is equal to the sum of network latencies on the part of the path from the source to the critical computer plus the intermediate delays for command 𝑖 of computers on this part of the path, that is, 𝑠−1𝑘=1𝑑 𝜋𝑘, 𝜋𝑘+1 + 𝑠−1𝑘=1𝑖𝑛𝑡𝑅𝐸𝑃 𝑖, 𝜋𝑘 . Note that if the critical computer is the same as the source computer, then the first term is equal to zero. The second term is more complicated and we return to it momentarily. The third term is similar to the first term. By the definition of the critical computer, all computers downstream from the critical computer are idle when command 𝑖 + 𝑧 reaches them, as shown in Figure 3-5. Thus, the third term is equal to sum of the network latencies along the part of the path from the critical to the destination computer, plus the intermediate delays for command 𝑖 + 𝑧 of all non-destination computers on this part of the path, plus the delay command 𝑖 + 𝑧 on the destination

computer, that is, 𝑚 −1𝑘=𝑠 𝑑 𝜋𝑘, 𝜋𝑘+1 + 𝑚 −1𝑘=𝑠+1𝑖𝑛𝑡𝑅𝐸𝑃 𝑖 + 𝑧, 𝜋𝑘 + 𝑑𝑒𝑠𝑡𝑅𝐸𝑃 𝑖 + 𝑧, 𝜋𝑚 . Note that if the critical computer is the same as the destination computer, then the third term is equal to zero. The fourth term is a constant. Therefore, the first, third, and fourth terms are

independent of the number of consecutive commands that have been entered.

The second term, which we refer to as the critical computer time, is more complex than the others because it depends on the number of commands that have been entered consecutively. When the critical computer is an intermediate computer, then the time it requires to complete the tasks of consecutive commands is a function of both the network card and CPU costs. It is a function of CPU costs because until the CPU completes tasks for

a command, the network card cannot begin transmitting the next command even if it is idle because the CPU must first transmit it. It is a also function of transmission times because until the network card completes transmitting a command to all destinations, it cannot begin transmitting the next command even if the CPU has completed the processing and

transmission tasks for it. In one extreme case, the total network card transmission time is higher than the CPU processing time for each command. In this case, the network card falls

further behind the CPU with each command, as shown in Figure 3-6 (left). The other extreme case is that the CPU processing time is higher than the total network card transmission time for each command. In this case, the network card keeps up with the CPU, as shown in Figure 3-6 (right). In all other cases, when neither the total network card transmission time nor the CPU processing time dominate each other, then for any one command, the network card either falls further behind or makes up ground on the CPU. Therefore, on average, the

Figure 3-6. Critical computer time for completing tasks of consecutive commands.

time CPU NIC i i i i+1 i+1 time CPU NIC cmd i+1cmd i Transmission Processing cmd i+1cmd i i+1 i i i i+1 i+1 i+1

113

network card keeps up with the CPU. Hence, all non-extreme cases are equivalent to the second extreme case. Thus, we analyze the response times only for the two extreme cases.

Let us first consider the extreme case when the total network card transmission times dominate the CPU processing times. The critical computer time is equal to (1) the amount of time that elapses from the moment the critical computer receives command 𝑖 to the moment the CPU transmits 𝑖 to the first destination, plus (2) the amount of time that elapses from the moment the network card begins to transmit 𝑖 to the first destination to the moment it

transmits 𝑖 + 𝑧 − 1 to the last destination, plus (3) the amount of time that elapses from the moment the network card begins transmitting 𝑖 + 𝑧 to the moment it transmits it to the next downstream computer. The first term is equal to 𝑥_{𝐶𝑃𝑈 𝑖,}

𝑠

𝐼𝑁 _{. The second term is equal to}

𝑓𝑎𝑛𝑠∗ 𝑥𝑁𝐼𝐶 𝑘,𝐼𝑁_𝑠 𝑖+𝑧−1

𝑘=𝑖 because once the network card begins transmitting 𝑖, it does not stop until it finishes transmitting 𝑖 + 𝑧. The third term is equal to 𝑝𝑜𝑠 _𝑠,_𝑠+1 ∗ 𝑥_{𝑁𝐼𝐶 𝑖+𝑧,}

𝑠 𝐼𝑁 _. Thus, we can finally state userb’s remote response time of command 𝑖 + 𝑧 entered by

userj by adding the critical computer time to the other three components of the remote

response time, which we had derived earlier. In particular, when an intermediate computer is the critical computer and the total network transmission times dominate the CPU processing time the remote response time is given by

𝑟𝑒𝑚𝑜𝑡𝑒𝑅𝐸𝑃,𝑖+𝑧,𝑗 = 𝑑 𝜋𝑘, 𝜋𝑘+1 𝑚−1 𝑘=1 + 𝑖𝑛𝑡𝑅𝐸𝑃 𝑖, 𝜋𝑘 𝑠−1 𝑘=1 + 𝑥_{𝐶𝑃𝑈 𝑖,𝜋} 𝑠 𝐼𝑁 _{+ 𝑓𝑎𝑛} 𝜋𝑠 ∗ 𝑥𝑁𝐼𝐶 𝑐,𝜋𝐼𝑁_𝑠 𝑖+𝑧−1 𝑐=𝑖 + 𝑝𝑜𝑠 𝜋𝑠, 𝜋𝑠+1 ∗ 𝑥_{𝑁𝐼𝐶 𝑖+𝑧,𝜋}𝐼𝑁 _𝑠 + 𝑖𝑛𝑡𝑅𝐸𝑃 𝑖 + 𝑧, 𝜋𝑘 𝑚−1 𝑘=𝑠+1 + 𝑑𝑒𝑠𝑡𝑅𝐸𝑃 𝑖 + 𝑧, 𝜋𝑚 − 𝑡𝑖+𝑧

At first, this equation may appear quite different from the general remote response time equation for commands entered in a quiescent state. There are two differences in these two equations. The first difference is that there are two intermediate delay sums instead of one because in the consecutive command case, we have to separately consider the delays of computers upstream and downstream from the critical computer. The other, major difference is the critical computer time, 𝑥_{𝐶𝑃𝑈 𝑖,𝜋}

𝑠 𝐼𝑁 _{+ 𝑓𝑎𝑛} 𝜋𝑠∗ 𝑥𝑁𝐼𝐶 𝑐,𝜋𝐼𝑁_𝑠 𝑖+𝑧−1 𝑐=𝑖 + 𝑝𝑜𝑠 𝜋𝑠, 𝜋𝑠+1 ∗ 𝑥_{𝑁𝐼𝐶 𝑖+𝑧,𝜋} 𝑠

𝐼𝑁 _{, that is included in the equation for consecutive commands. However, a closer} look at the two differences shows that the consecutive command equation “stretches out” the delay of the intermediate computer 𝜋_𝑠 in the quiescent state equation. Therefore, the remote response time equation of consecutive commands indeed resembles the response time equation of commands entered in a quiescent state.

The other extreme case is when the CPU processing time dominates the total network card transmission for each command. In this case, the critical computer time is equal to (1) the amount of time that elapses from the moment the CPU begins to perform tasks for command 𝑖 to the moment the CPU completes that task for command 𝑖 + 𝑧 − 1, plus (2) the amount of time that elapses from the moment the CPU begins to perform tasks for command

𝑖 + 𝑧 to the moment the network transmits it to the next downstream computer. The first term is equal to 𝑖+𝑧−1𝑐=𝑖 𝑓𝑎𝑛𝑠 ∗ 𝑥𝐶𝑃𝑈 𝑐,𝐼𝑁_𝑠 + 𝑝𝑐,𝐼𝑁𝑠 + 𝑝𝑐,𝑂𝑈𝑇𝑠 . The second term is equal to

𝑥_{𝐶𝑃𝑈 𝑖+𝑧,}

𝑠

𝐼𝑁 _{+ 𝑝𝑜𝑠 }

𝑠,𝑠+1 ∗ 𝑥_{𝑁𝐼𝐶 𝑖+𝑧,}𝐼𝑁 _𝑠. Thus, we can state userb’s remote response time of

command 𝑖 + 𝑧 entered by userj when an intermediate computer is the critical computer and

115 𝑟𝑒𝑚𝑜𝑡𝑒𝑅𝐸𝑃,𝑖+𝑧,𝑗 = 𝑑 𝜋𝑘, 𝜋𝑘+1 𝑚 −1 𝑘=1 + 𝑖𝑛𝑡𝑅𝐸𝑃 𝑖, 𝜋𝑘 𝑠−1 𝑘=1 + 𝑓𝑎𝑛_ 𝑠∗ 𝑥𝐶𝑃𝑈𝑐,𝑠 𝐼𝑁 _{+ 𝑝} 𝑐,𝑠 𝐼𝑁 _{+ 𝑝} 𝑐,𝑠 𝑂𝑈𝑇 𝑖+𝑧−1 𝑐=𝑖 +𝑥_{𝐶𝑃𝑈𝑖+𝑧,} 𝑠 𝐼𝑁 _{+ 𝑝𝑜𝑠 } 𝑠,𝑠+1 ∗ 𝑥_{𝑁𝐼𝐶𝑖+𝑧,}𝐼𝑁 _𝑠 + 𝑖𝑛𝑡_𝑅𝐸𝑃 𝑖 + 𝑧, 𝜋𝑘 𝑚 −1 𝑘=𝑠+1 + 𝑑𝑒𝑠𝑡_𝑅𝐸𝑃 𝑖 + 𝑧, 𝜋𝑚 −𝑡𝑖+𝑧 This equation, like the one before it, also resembles the general remote response time equation for commands entered in a quiescent state. The differences between this and the quiescent state equations are the same as the differences between the previous and quiescent state equations.

When the critical computer is the destination, the critical computer time is not a function of the network card transmission times. Hence, the second term on the destination computer is equal to the time the CPU requires to transmit and process all of the commands, that is, to 𝑖+𝑧𝑐=𝑖 𝑓𝑎𝑛𝑚 ∗ 𝑥𝐶𝑃𝑈 𝑐,𝐼𝑁_𝑚 + 𝑝𝑐,𝐼𝑁𝑚 + 𝑝𝑐,𝑂𝑈𝑇𝑚 . Thus, when the destination computer is the critical computer, the response time equations are given by

𝑟𝑒𝑚𝑜𝑡𝑒_{𝑅𝐸𝑃,𝑖+𝑧,𝑗} = 𝑑 𝜋_𝑘, 𝜋_𝑘+1 𝑚 −1 𝑘=1 + 𝑖𝑛𝑡_𝑅𝐸𝑃 𝑖, 𝜋𝑘 𝑚 −1 𝑘=1 + 𝑓𝑎𝑛_ 𝑚∗ 𝑥𝐶𝑃𝑈𝑐,𝑚 𝐼𝑁 _+𝑝 𝑐,𝜋𝐼𝑁𝑚 + 𝑝𝑐,𝜋𝑂𝑈𝑇𝑚 𝑖+𝑧 𝑐=𝑖 −𝑡𝑖+𝑧 This equation is similar the general remote response time equation of quiescent state

commands. This makes sense because command 𝑖 must traverse the path from the source to the destination regardless of whether the user enters consecutive commands after it. The only

difference is that the destination delay term is more complex in the consecutive command equation because of the extra delay command 𝑖 + 𝑧 experiences at the destination.

Centralized Response Times

So far, we have presented only the response times of consecutive commands entered by master users in the replicated architecture. Next, we give the equations for the response times of such commands entered by master and slave users in the centralized architecture. Consider first the remote response times of commands entered by the master user. As in the analysis of commands entered in the quiescent state, we can derive these equations from the replicated architecture equations as long as we account for the two main differences in the centralized and replicated architectures. First, in the centralized architecture, only the master computer processes both input and output commands, while other computers process only