Formal Analysis

Developing an analytical model is a complex task. Therefore, like Chung [21], we make certain assumptions in our response time model of collaboration architectures: the collaboration involves at most three users, who we denote as user1, user2, and user3; the

transmission costs are negligible; and there is no type-ahead. Because of the second assumption, whenever a computer must both send a command to the other computers and process the command, we assume that it first sends the command and then processes it.

Unlike Chung, we do not assume a constant cost of processing each input command, zero cost of processing each output command, or constant think times. It is important to consider processing times because a computer must process commands before displaying

outputs to the local user. The impact of think times on response times is somewhat less apparent. Think times can impact response times because when think times of commands are low, slower computers may fall behind the faster computers in processing the commands. In particular, when a command reaches slower computers, these computers may not be ready to begin processing the command immediately if they are still busy processing previous

commands. The delays in processing the commands increase the response times of the commands.

In all of the small-scale collaborations we logged, the users’ think times were high enough that computers were always ready to process the next command whenever it arrived. These collaborations included commands that were generated fairly rapidly, such as those of telepointers. Telepointing actions are typically generated thirty times each second, that is, they have think times of 33ms. Even though these think times appear low, they are much higher than the processing times of telepointing commands, which were 1.5ms on a P3 desktop, the slowest computer we used in our experiments. Thus, the think times are effectively high even for telepointing actions. Therefore, in this chapter, we present the analysis only for the case when think times are high.

Analysis Scope:

In this chapter, we present the analysis only for the case when think times are high because in all of the small-scale collaborations we observed, think times were always high. Separate analysis is needed for the case when think times are low.

43

We will introduce the remaining parameters of our model as we develop the

equations. We start by considering the equations for the local response times in centralized architectures.

2.2.1 Local Response Times in Centralized Architectures

In a centralized architecture, the shared program executes on a computer belonging to one of the collaborators, receiving input from and broadcasting output to all users. The computer running the shared program is called the master while all other computers are called slaves.

In cases where a master user inputs commands, the commands are processed by the local computer. It processes each input command immediately after the local user provides it, computes the output for the command, transmits the output to the slave users, and process the output to display the result to the local user. Let 𝑝_𝑖,𝑗𝐼𝑁 (𝑝_𝑖,𝑗𝑂𝑈𝑇)denote the time userj’s computer

requires to process input (output) command 𝑖. Hence, if userm is the master in a centralized

architecture, userm’s local response time is 𝑝𝑖,𝑚𝐼𝑁 + 𝑝𝑖,𝑚𝑂𝑈𝑇.

Now, consider the case where a slave user inputs command. The slave user’s

computer must first transmit the command to the master, which must then travel to the master computer. When the master computer receives the command, it then processes the command without interruption, computes an output message, and transmits the output back to the slave user, which must then travel back to the slave’s computer. When the slave’s computer receives the output, it processes the output. Let 𝑑(𝑗, 𝑘) denote the network latency a command experiences as it travels from userj’s to userk’s computer. Therefore, if users1

(users2’s) local response time is 𝑑 𝑠1, 𝑚 + 𝑝𝑖,𝑚𝐼𝑁 + 𝑑(𝑚, 𝑠1) + 𝑝𝑖,𝑠1𝑂𝑈𝑇 (𝑑 𝑠2, 𝑚 + 𝑝𝑖,𝑚𝐼𝑁 +

𝑑(𝑚, 𝑠2) + 𝑝_𝑖,𝑠2𝑂𝑈𝑇_{). Hence, if user}

m is the master and users1 and users2 are slaves, we have 𝑙𝑜𝑐𝑎𝑙𝐶𝐸𝑁𝑇,𝑖,𝑚𝑢𝑚 = 𝑝𝑖,𝑚𝐼𝑁 + 𝑝𝑖,𝑚𝑂𝑈𝑇 if userm is master 𝑙𝑜𝑐𝑎𝑙_{𝐶𝐸𝑁𝑇,𝑖,𝑠1}𝑢_𝑚 = 𝑑 𝑠1, 𝑚 + 𝑝_𝑖,𝑚𝐼𝑁 _{+ 𝑑(𝑚, 𝑠1) + 𝑝}

𝑖,𝑠1𝑂𝑈𝑇 if userm is master 𝑙𝑜𝑐𝑎𝑙_{𝐶𝐸𝑁𝑇,𝑖,𝑠2}𝑢_𝑚 = 𝑑 𝑠2, 𝑚 + 𝑝_𝑖,𝑚𝐼𝑁 _{+ 𝑑(𝑚, 𝑠2) + 𝑝}

𝑖,𝑠2𝑂𝑈𝑇

We next derive the equations for the local response times in the replicated architecture.

2.2.2 Local Response Times in Replicated Architectures

In the replicated architecture, a separate replica of the program executes on the computer of each user, receiving input from all users and producing output for only the local user. Hence, all computers are masters in the replicated architecture. Thus, userj’s local

response time in the replicated case is 𝑝_𝑖,𝑗𝐼𝑁+ 𝑝_𝑖,𝑗𝑂𝑈𝑇. Hence,

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

2.2.3 Remote Response Times in Centralized Architectures

Recall that a non-inputting user’s remote response time for a command is defined as the time that elapses from the moment the command is input to the moment the user sees its output. In centralized architectures, a user’s remote response time depends on whether the non-inputting and inputting users are both slaves or if one of them is the master. If the master user provides the input, a slave user will see the output once the input command is processed, the output traverses the network, and the slave user’s computer processes the output. Thus, we have

𝑟𝑒𝑚𝑜𝑡𝑒_{𝐶𝐸𝑁𝑇,𝑖,𝑠1}𝑢_𝑚 = 𝑝_𝑖,𝑚𝐼𝑁 _{+ 𝑑(𝑚, 𝑠1) + 𝑝}

𝑖,𝑠1𝑂𝑈𝑇 if master userm inputs

45

If a slave user provides the input, the master user will see the output once the input command reaches the master computer and the computer processes it and the corresponding output. The other slave user will see the output once the input command reaches the master computer, the master computer processes and transmits the output to the other slave, the output travels to the other slave’s computer, and finally the other slave’s computer processes it. Thus,

𝑟𝑒𝑚𝑜𝑡𝑒_{𝐶𝐸𝑁𝑇,𝑖,𝑚}𝑢_𝑚 = 𝑑 𝑠1, 𝑚 + 𝑝_𝑖,𝑚𝐼𝑁 _{+ 𝑝} 𝑖,𝑚𝑂𝑈𝑇

𝑟𝑒𝑚𝑜𝑡𝑒_{𝐶𝐸𝑁𝑇,𝑖,𝑠2}𝑢_𝑚 = 𝑑 𝑠1, 𝑚 + 𝑝_𝑖,𝑚𝐼𝑁 _{+ 𝑑(𝑚, 𝑠2) + 𝑝} 𝑖,𝑠2𝑂𝑈𝑇 if slave users1 inputs, and

𝑟𝑒𝑚𝑜𝑡𝑒_{𝐶𝐸𝑁𝑇,𝑖,𝑚}𝑢_𝑚 = 𝑑 𝑠2, 𝑚 + 𝑝_𝑖,𝑚𝐼𝑁 _{+ 𝑝} 𝑖,𝑚𝑂𝑈𝑇

𝑟𝑒𝑚𝑜𝑡𝑒𝐶𝐸𝑁𝑇,𝑖,𝑠1𝑢𝑚 = 𝑑 𝑠2, 𝑚 + 𝑝𝑖,𝑚𝐼𝑁 + 𝑑(𝑚, 𝑠1) + 𝑝𝑖,𝑠2𝑂𝑈𝑇 if slave users2 inputs.

2.2.4 Remote Response Times in Replicated Architectures

In the replicated architecture, the remote response time of a command includes the time the command requires to travel from the inputting user’s computer to the receiving user’s computer and the time the receiving user’s computer requires to process the command and its output. Thus, the userk’s remote response time of command 𝑖 entered by userj is given

by

𝑟𝑒𝑚𝑜𝑡𝑒𝑅𝐸𝑃,𝑖,𝑘 = 𝑑 𝑗, 𝑘 + 𝑝𝑖,𝑘𝐼𝑁+ 𝑝𝑖,𝑘𝑂𝑈𝑇