empty intemal connections) for this process based on the received response. When in the
`
`large regime, the expected number of holes is zero. When in the small regime, the expected
`
`number of holes varies from one to three,
`
`In block 1109, the routine sets the estimated
`
`diameter of the broadcast channel based on the received response.
`
`In decision block 1111, if
`
`5
`
`the dialed process is ready to connect to this process as indicated by the response message,
`
`then the routine continues at block 1112, else the routine continues at block 1113.
`
`In block
`
`1112,
`
`the routine invokes the add neighbor routine to add the answering process as a
`
`neighbor to this process. This adding of the answering process typically occurs when the
`
`broadcast charmel is in the small regime. When in the large regime, the random walk search
`
`10
`
`for a neighbor is performed.
`
`In block 1113, the routine hangs up the external connection
`
`with the answering process computer and then returns.
`
`Figure 12 is a flow diagram of the processing of the check for external call
`
`routine in one embodiment. This routine is invoked to identify whether a fellow seeking
`
`process is attempting to establish a connection to the broadcast channel through this process.
`
`15
`
`In block 1201, the routine attempts to answer a call on the call-in port.
`
`In decision block
`
`1202, if the answer is successful, then the routine continues at block 1203, else the routine
`
`retums.
`
`In block 1203, the routine receives the external message from the external port.
`
`In
`
`decision block 1204, if the type of the message indicates that a seeking process is calling
`
`(i.e., seeking_connection_caH), then the routine continues at block 1205, else the routine
`
`20
`
`returns. In block 1205, the routine sends an external message (i. e., seeking_connection_resp)
`
`to the other seeking process indicating that this process is also is seeking a connection.
`
`In
`
`decision block 1206, if the sending of the external message is successfiil, then the routine
`
`continues at block 1207, else the routine returns.
`
`In block 1207, the routine adds the other
`
`seeking process to a list of fellow seeking processes and then returns. This list may be used
`
`25
`
`if this process can find no process that is fully connected to the broadcast channel.
`
`In which
`
`case,
`
`this process may check to see if any fellow seeking -process were successful
`
`in
`
`connecting to the broadcast channel. For example, a fellow seeking process may become the
`
`first process fully connected to the broadcast channel.
`
`Figure 13 is a flow diagram of the processing of the achieve connection routine
`
`so
`
`in one embodiment. This routine sets the state of this process to fully connected to the
`
`broadcast channel and invokes a callback routine to notify the application program that the
`
`process is now fully connected to the requested broadcast channel.
`
`In block 1301,
`
`the
`
`[03004-8001/SLO03733.l05]
`
`-30-
`
`751,00
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 452 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 452 of 1442
`
`

`
`routine sets the connection state of this process to fully connected.
`
`In block 1302,
`
`the
`
`routine notifies fellow seeking processes that it is fully connected by sending a connected
`
`external message to them (i.e., connected_stmt).
`
`In block 1303, the routine invokes the
`
`connect callback routine to notify the application program and then returns.
`
`5
`
`Figure 14 is a flow diagram illustrating the processing of the external
`
`dispatcher routine in one embodiment. This routine is invoked when the external port
`
`receives a message. This routine retrieves the message, identifies the external message type,
`
`and invokes the appropriate routine to handle that message. This routine loops processing
`each message until all the received messages have been handled.
`In block 1401, the routine
`
`10
`
`answers (e.g., picks up) the external port and retrieves an external message.
`
`In decision
`
`block 1402, if a message was retrieved, then the routine continues at block 1403, else the
`
`routine hangs up on the external port in block 1415 and returns.
`
`In decision block 1403, if
`
`the message type is for a process seeking a connection (i. e., seeking_connection_call), then
`
`' the routine invokes the handle seeking connection call routine in block 1404, else the routine
`
`is
`
`continues at block 1405.
`
`In decision block 1405, if the message type is for a connection
`
`request call (i. e., connection_request_call), then the routine invokes the handle connection
`
`request call routine in block 1406, else the routine continues at block 1407.
`
`In decision
`
`block 1407, if the message type is edge proposal call (i.e., edge_proposal_call), then the
`
`routine invokes the handle edge proposal call routine in block 1408, else the routine
`
`20
`
`continues at block 1409.
`
`In decision block 1409, if the message type is port connect (all
`
`(i. e., port_connect_call), then the routine invokes the handle port connection call routine in
`
`block 1410, else the routine continues at block 1411.
`
`In decision block 1411, if the message
`
`type is a connected statement
`
`(i. e., connected_stmt),
`
`the routine invokes the handle
`
`connected statement in block 1112, else the routine continues at block 1212.
`
`In decision
`
`25
`
`block 1412, if the message type is a condition repair statement (i. e., condition_repair_stmt),
`
`then the routine invokes the handle condition repair routine in block 1413, else the routine
`
`loops to block -1414 to process the next message. After each handling routine is invoked, ‘the
`
`roun'ne loops to block 1414.
`
`In block 1414, the routine hangs up on the external port and
`
`continues at block 1401 to receive the next message.
`
`30
`
`Figure 15 is a flow diagram illustrating the processing of the handle seeleing
`
`connection call routine in one embodiment. This routine is invoked when a seeking process
`
`is calling to identify a portal computer through which it can connect to the broadcast charmel.
`
`[03004-800]/SL003733. I05]
`
`-3 1-
`
`7/3,00
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 453 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 453 of 1442
`
`

`
`In decision block 1501, if this process is currently fully connected to the broadcast channel
`
`identified in the message, then the routine continues at block 1502, else the routine continues
`
`at block 1503.
`
`In block 1502, the routine sets a message to indicate that this process is fully
`
`connected to the broadcast channel and continues at block 1505.
`
`In block 1503, the routine
`
`5
`
`sets a message to indicate that this process is not fully connected.
`
`In block 1504, the routine
`
`adds the identification of the seeking process to a list of fellow seeking processes.
`
`If this
`
`process is not fully connected, then it is attempting to connect to the broadcast channel.
`
`In
`
`block 1505, the routine sends the external message response (i.e., seel<ing_connection__resp)
`
`to the seeking process and then returns.
`
`10
`
`Figure 16 is a flow diagram illustrating processing of the handle connection
`
`request call routine in one embodiment. This routine is invoked when the calling process
`
`wants this process to initiate the connection of the process to the broadcast channel. This
`
`routine either allows the calling process to establish an internal connection with this process
`
`(e.g., if in the small regime) or starts the process of identifying a process to which the calling
`
`15
`
`process can connect.
`
`In decision block 1601, if this process is currently fully connected to
`
`the broadcast channel, then the routine continues at block 1603, else the routine hangs up on
`
`the external port in block 1602 and retums.
`
`In block 1603, the routine sets the number of
`
`holes that the calling process should expect in the response message.
`
`In block 1604, the
`
`routine sets the estimated diameter in the response message.
`
`In block 1605, the routine
`
`20
`
`indicates whether this process is ready to connect to the calling process. This process is
`
`ready to connect when the number of its holes is greater than zero and the calling process is
`
`not a neighbor of this process.
`external message.
`that
`is
`
`In block 1606, the routine sends to the calling process an
`responsive
`to
`the
`connection
`request
`call
`(i.e.,
`
`connection_request_resp).
`
`In block 1607, the routine notes the number of holes that the
`
`25
`
`calling process needs to fill as indicated in the request message.
`
`In decision block 1608, if
`
`this process is ready to connect to the calling process, then the routine continues at block
`
`1609, else the routine continues at block 1611.
`
`In block 1609, the routine invokes the add
`
`neighbor routine to add the calling process as a neighbor.
`
`In block 1610,
`
`the routine
`
`decrements the number of holes that the calling process needs to fill and continues at block
`
`30
`
`1611.
`
`In block 1611, the routine hangs up on the external port.
`
`In decision block 1612, if
`
`this process has no holes or the estimated diameter is greater than one (i.e.,
`
`in the large
`
`regime), then the routine continues at block 1613, else the routine continues at block 1616.
`
`[03004-8001/SU)03733.l05]
`
`-32-
`
`7/31/00
`
`|PR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 454 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 454 of 1442
`
`

`
`In blocks 1613-1615, the routine loops forwarding a request for an edge through which to
`
`connect to the calling process to the broadcast channel. One request is forwarded for each
`
`pair of holes of the calling process that needs to be filled.
`
`In decision block 1613, if the
`
`number of holes of the calling process to be filled is greater than or equal to two, then the
`
`5
`
`routine continues at block 1614, else the routine continues at block 1616.
`
`In block 1614, the
`
`routine invokes the forward connection edge search routine. The invoked routine is passed
`
`to an indication of the calling process and the random walk distance.
`
`In one embodiment, the
`
`distance is twice in the estimated diameter of the broadcast channel.
`
`In block 1614, the
`
`routine decrements the holes left to fill by two and loops to block 1613.
`
`In decision block
`
`10
`
`1616, if there is still a hole to fill, then the routine continues at block 1617, else the routine
`
`returns.
`
`In block 1617, the routine invokes the fill hole routine passing the identification of
`
`the calling process. The fill hole routine broadcasts a connection port search statement (i.e.,
`
`connection_port_search_stmt) for a hole of a connected process through which the calling
`
`process can connect to the broadcast channel. The routine then returns.
`
`15
`
`Figure 17 is a flow diagram illustrating the processing of the add neighbor
`
`routine in one embodiment. This routine adds the process calling on the external port as a
`neighbor to this process.
`In block 1701, the routine identifies the calling process on the
`
`external port.
`
`In block 1702, the routine sets a flag to indicate that the neighbor has not yet
`
`received the broadcast messages fi'om this process. This flag is used to ensure that there are
`
`20
`
`no gaps in the messages initially sent to the new neighbor. The external port becomes the
`
`In decision block 1703, if this process is in the seeking
`internal port for this connection.
`connection state,
`then this process is connecting to its first neighbor and the routine
`
`continues at block 1704, else the routine continues at block 1705.
`
`In block 1704, the routine
`
`sets the connection state of this process to partially connected.
`
`In block 1705, the routine
`
`25
`
`adds the calling process to the list of neighbors of this process.
`
`In block 1706, the routine
`
`installs an internal dispatcher for the new neighbor. The internal dispatcher is invoked when
`
`a message is received from that new neighbor through the internal port of that new neighbor.
`
`In decision block 1707, if this process buffered up messages while not fully connected, then
`
`the routine continues at block 1708, else the routine continues at block 1709.
`
`In one
`
`30
`
`embodiment, a process that is partially connected may buffer the messages that it receives
`
`through an internal connection so that it can send these messages as it connects to new
`
`neighbors.
`
`In block 1708, the routine sends the buffered messages to the new neighbor
`
`[o3oo4.sooi/swo3733.1os]
`
`-33-
`
`7,3,,oo
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 455 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 455 of 1442
`
`

`
`through the internal port.
`
`In decision block 1709, if the number of holes of this process
`
`equals the expected number of holes, then this process is fully connected and the routine
`
`continues at block 1710, else the routine continues at block 1711.
`
`In block 1710, the routine
`
`invokes the achieve connected routine to indicate that this process is fully connected.
`
`In
`
`5
`
`decision block 1711, if the number of holes for this process is zero,
`
`then the routine
`
`continues at block 1712, else the routine returns.
`
`In block 1712, the routine deletes any
`
`pending edges and then retums. A pending edge is an edge that has been proposed to this
`
`process for edge pinning, which in this case is no longer needed.
`
`Figure 18 is a flow diagram illustrating the processing of the forward
`
`10
`
`connection edge search routine in one embodiment. This routine is responsible for passing
`
`along a request to connect a requesting process to a randomly selected neighbor of this
`
`process through the internal port of the selected neighbor, that is part of the random walk.
`
`In
`
`decision block 1801, if the forwarding distance remaining is greater than zero,
`
`then the
`
`routine continues at block 1804, else the routine confinues at block 1802.
`
`In decision block
`
`15
`
`1802, if the number of neighbors of this process is greater than one,
`
`then the routine
`
`continues at block 1804, else this broadcast channel is in the small regime and the routine
`
`continues at block 1803.
`
`In decision block 1803, if the requesting process is a neighbor of
`
`this process, then the routine returns, else the routine continues at block 1804.
`
`In blocks
`
`1804-1807,
`
`the routine loops attempting to send a connection edge search call
`
`internal
`
`20 message (i. e. , connection_edge_search_call) to a randomly selected neighbor.
`
`In. block 1804,
`
`the routine randomly selects a neighbor of this process.
`
`Indecision block 1805, if all the
`
`neighbors of this process have already been selected, then the routine cannot forward the
`
`message and the routine retums, else the routine continues at block 1806.
`In block 1806, the
`routine sends a connection edge search call internal message to the selected neighbor.
`In
`
`25
`
`decision block 1807, if the sending of the message is successful, then the routine continues at
`
`block 1808, else the routine loops to block 1804 to select the next neighbor. When the
`
`sending of an internal message is unsuccessful, then the neighbor may have disconnected
`
`from the broadcast charmel in an unplarmed manner. Whenever such a situation is detected
`
`by the broadcaster component, it attempts to find another neighbor by invoking the fill holes
`
`30
`
`routine to fill a single hole or the forward connecting edge search routine to fill two holes.
`
`111
`
`block 1808, the routine notes that the recently sent connection edge search call has not yet
`
`been acknowledged and indicates that the edge to this neighbor is reserved if the remaining
`
`[D3004-8001/SU)03733.lO5]
`
`-34-
`
`751,00
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 456 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 456 of 1442
`
`

`
`forwarding distance is less than or equal to one.
`
`It is reserved because the selected neighbor
`
`may offer this edge to the requesting process for edge pinning. The routine then returns.
`Figure 19 is a flow diagram illustrating the processing of the handle edge
`
`proposal call routine. This routine is invoked when a message is received fiom a proposing
`
`5
`
`process that proposes to connect an edge between the proposing process and one of its
`
`neighbors to this process for edge pinning.
`
`In decision block .1901, if the number of holes of
`
`this process minus the number of pending edges is greater than or equal to one, then this
`
`process still has holes to be filled and the routine continues at block 1902, else the routine
`
`continues at block 1911. In decision block 1902, if the proposing process or its neighbor is a
`
`10
`
`neighbor of this process, then the routine continues at block 1911, else the routine continues
`
`at block 1903. In block 1903, the routine indicates that the edge is pending between this
`
`process and the proposing process.
`
`In decision block 1904, if a proposed neighbor is already
`
`pending as a proposed neighbor, then the routine continues at block 1911, else the routine
`
`continues at block 1907.
`
`In block 1907, the routine sends an edge proposal response as an
`
`15
`
`external message to the proposing process (i.e., edgeJ>roposa]_resp) indicating that the
`
`proposed edge is accepted.
`
`In decision block 1908, if the sending of the message was
`
`successful, then the routine continues at block 1909, else the routine returns.
`
`In block 1909,
`
`the routine adds the edge as a pending edge.
`
`In block 1910, the routine invokes the add
`
`neighbor routine to add the proposing process on the external port as a neighbor. The routine
`
`20
`
`then returns. In block 1911, the routine sends an external message (i.e., edge_proposa1_resp)
`
`indicating that this proposed edge is not accepted.
`
`In decision block 1912, if the number of
`
`holes is odd, then the routine continues at block 1913, else the routine returns.
`
`In block
`
`1913, the routine invokes the fill hole routine and then returns.
`
`Figure 20 is a flow diagram illustrating the processing of the handle port
`
`25
`
`connection call routine in one embodiment. This routine is invoked when an external
`
`message is received then indicates that the sending process wants to connect to one hole of
`
`this process.
`
`In decision block 2001, if the number of holes of this process is greater than
`
`zero, then the routine continues at block 2002, else the routine continues at block 2003.
`
`In
`
`decision block 2002, if the sending process is not a neighbor, then the routine continues at
`
`30
`
`block 2004, else the routine continues to block 2003.
`
`In block 2003, the routine sends a port
`
`connection response external message (i.e., poit__connection_resp) to the sending process that
`
`indicates that it is not okay to connect to this process. The routine then returns.
`
`In block
`
`[D3004-8001/SLO03733.l05]
`
`-3 5-
`
`1/31/00
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 457 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 457 of 1442
`
`

`
`2004, the routine sends a port connection response external message to the sending process
`that indicates that is okay to connect this process.
`In decision block 2005, if the sending of
`
`the message was successful,
`
`then the routine continues at block 2006, else the routine
`
`continues at block 2007.
`
`In block 2006, the routine invokes the add neighbor routine to add
`
`5
`
`the sending process as a neighbor of this process and then returns.
`
`In block 2007, the routine
`
`hangs up the external connection.
`
`In block 2008, the routine invokes the connect request
`
`routine to request that a process connect to one of the holes of this process. The routine then
`
`returns.
`
`Figure 21 is a flow diagram illustrating the processing of the fill hole routine in
`
`10
`
`one embodiment. This routine is passed an indication of the requesfing process.
`
`If this
`
`process is requesting to fill a hole, then this routine sends an internal message to other
`
`processes. If another process is requesting to fill a hole, then this routine invokes the routine
`
`to handle a connection port search request.
`
`In block 2101,
`
`the routine initializes a
`
`connection port search statement internal message (i. e., conneetion_port_search_stmt).
`
`In
`
`15
`
`decision block 2102, if this process is the requesting process, then the routine continues at
`
`block 2103, else the routine continues at block 2104.
`
`In block 2103, the routine distributes
`
`the message to the neighbors of this process through the internal ports and then returns.
`
`In
`
`block 2104, the routine invokes the handle connection port search routine and then returns.
`
`Figure 22 is a flow diagram illustrating the processing of the internal dispatcher
`
`20
`
`routine in one embodiment. This routine is passed an indication of the neighbor who sent the
`
`intemal message.
`
`In block 2201, the routine receives the intemal message. This routine
`
`In
`identifies the message type and invokes the appropriate routine to handle the message.
`block 2202, the routine assesses whether to change the estimated diameter of the broadcast
`
`charmel based on the information in the received message.
`
`In decision block 2203, if this
`
`25
`
`process is the originating process of the message or the message has already been received
`
`(i. e., a duplicate), then the routine ignores the message and continues at block 2.208, else the
`
`routine continues at block 2203A.
`
`In decision block 2203A, if the process is partially
`
`connected, then the routine continues at block 2203B, else the routine continues at block
`
`2204.
`
`In block 2203B, the routine adds the message to the pending connection bufier and
`
`30
`
`continues at block 2204.
`
`In decision blocks 2204-2207, the routine decodes the message
`
`type and invokes the appropriate routine to handle the message. For example, in decision
`
`block 2204, if the type of the message is broadcast statement (i. e., broadcast_stmt), then the
`[03004-8001/SLOO3733.lO5)
`-36-
`7,3,“,
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 458 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 458 of 1442
`
`

`
`routine invokes the handle broadcast message routine in block 2205. After invoking the
`
`appropriate handling routine, the routine continues at block 2208.
`
`In decision block 2208, if
`
`the partially connected buffer is full,
`
`then the routine continues at block 2209, else the
`
`routine continues at block 2210.
`
`The broadcaster component collects all
`
`its internal
`
`5 messages in a buffer while partially connected so that it can forward the messages as it
`
`connects to new neighbors.
`
`If, however, that buffer becomes full, then the process assumes
`
`that it is now fully connected and that the expected number of connections was too high,
`
`because the broadcast channel is now in the small regime.
`
`In block 2209, the routine invokes
`
`the achieve connection routine and then continues in block 2210.
`
`In decision block 2210, if
`
`10
`
`the application program message queue is empty, then the routine returns, else the routine
`
`continues at block 2212.
`
`In block 2212, the routine invokes the receive response routine
`
`passing the acquired message and then returns. The received response routine is a callback
`
`routine of the application program.
`
`Figure 23 is a flow diagram illustrating the processing of the handle broadcast
`
`15 message routine in one embodiment. This routine is passed an indication of the originating
`
`process, an indication of the neighbor who sent the broadcast message, and the broadcast
`
`message itself.
`
`In block 2301, the routine performs the out of order processing for this
`
`message. The broadcaster component queues messages from each originating process until it
`
`can send them in sequence number order to the application program.
`
`In block 2302, the
`
`20
`
`routine invokes the distribute broadcast message routine toforward the message to the
`neighbors of this process.
`In decision block 2303, if a newly connected neighbor is waiting
`
`to receive messages, then the routine continues at block 2304, else the routine returns.
`
`In
`
`block 2304,
`
`the routine sends the messages in the correct order if possible for each
`
`originating process and then returns.
`
`25
`
`Figure 24 is a flow diagram illustrating the processing of the distribute
`
`broadcast message routine in one embodiment. This routine sends the broadcast message to
`
`each of the neighbors of this process, except for the neighbor who sent the message to this
`
`process.
`
`In block 2401, the routine selects the next neighbor other than the neighbor who
`
`sent the message.
`
`In decision block 2402, if all such neighbors have already been selected,
`
`30
`
`then the routine returns.
`
`In block 2403,
`
`the routine sends the message to the selected
`
`neighbor and then loops to block 2401 to select the next neighbor.
`
`[03004-8001/SLOO3733.l05]
`
`-37-
`
`7,3 W,
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 459 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 459 of 1442
`
`

`
`Figure 26 is a flow diagram illustrating the processing of the handle connection
`
`port search statement routine in one embodiment. This routine is passed an indication of the
`
`neighbor that sent the message and the message itself. In block 2601, the routine invokes the
`
`distribute internal message which sends the message to each of its neighbors other than the
`
`5
`
`sending neighbor.
`
`In decision block 2602, if the number of holes of this process is greater
`
`than zero, then the routine continues at block 2603, else the routine returns.
`
`In decision
`
`block 2603, if the requesting process is a neighbor, then the routine continues at block 2605,
`
`else the routine continues at block 2604.
`
`In block 2604,
`
`the routine invokes the court
`
`neighbor routine and then returns. The court neighbor routine connects this process to the
`
`to
`
`requesting process if possible.
`
`In block 2605, if this process has one hole, then the neighbors
`
`with empty ports condition exists and the routine continues at block 2606, else the routine
`
`returns.
`
`In block 2606,
`
`the routine generates
`
`a condition check message
`
`(i. e.,
`
`condition_check) that includes a list of this process’ neighbors.
`
`In block 2607, the routine
`
`sends the message to the requesting neighbor.
`
`15
`
`Figure 27 is a flow diagram illustrating the processing of the court neighbor
`
`routine in one embodiment. This routine is passed an indication of the prospective neighbor
`
`for this process.
`
`If this process can connect to the prospective neighbor, then it sends a port
`
`connection call external message to the prospective neighbor and adds the prospective
`
`neighbor as a neighbor.
`
`In decision block 2701, if the prospective neighbor is already a
`
`20
`
`neighbor, then the routine returns, else the routine continues at block 2702.
`
`In block 2702,
`
`the routine dials the prospective neighbor.
`
`In decision block 2703, if the number of holes of
`
`this process is greater than zero, then the routine continues at block 2704, else the routine
`
`continues at block 2706.
`
`In block 2704, the routine sends a port connection call external
`
`message (i.e., port_connection_call) to the prospective neighbor and receives its response
`
`25
`
`(i. e., port_connection_resp). Assuming the response is successfully received, in block 2705,
`
`the routine adds the prospective neighbor as a neighbor of this process by invoking the add
`
`neighbor routine. In block 2706, the routine hangs up with the prospect and then returns.
`
`Figure 28 is a flow diagram illustrating the processing of the handle connection
`
`edge search call routine in one embodiment. This routine is passed a indication of the
`
`30
`
`neighbor who sent the message and the message itself. This routine either forwards the
`
`message to a neighbor or proposes the edge between this process and the sending neighbor to
`
`the requesting process for edge pinning.
`
`In decision block 2801, if this process is not the
`
`[D3004-8001/SlD03733.l05]
`
`-38-
`
`7/31/00
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 460 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 460 of 1442
`
`

`
`requesting process or the number of holes of the requesting process is still greater than or
`
`equal to two, then the routine continues at block 2802, else the routine continues at block
`
`2813.
`
`In decision block 2802, if the forwarding distance is greater than zero,
`
`then the
`
`random walk is not complete and the routine continues at block 2803, else the routine
`
`5
`
`In block 2803, the routine invokes the forward connection edge
`continues at block 2804.
`search routine passing the identification of the requesting process and the decremented
`
`forwarding distance. The routine then continues at block 2815.
`
`In decision block 2804, if
`
`the requesting process is a neighbor or the edge between this process and the sending
`
`neighbor is reserved because it has already been offered to a process,
`
`then the routine
`
`to
`
`continues at block 2805, else the routine continues at block 2806.
`In block 2805, the routine
`invokes the forward connection edge search routine passing an indication of the requesting
`
`party and a toggle indicator that alternatively indicates to continue the random walk for one
`
`or two more computers. The routine then continues at block 2815.
`
`In block 2806, the
`
`routine dials the requesting process via the call-in port.
`
`In block 2807, the routine sends an
`
`15
`
`edge proposal call external message (i. e., edge_proposal_call) and receives the response (i. e.,
`
`edge_proposal_resp). Assuming that
`
`the response is successfiilly received,
`
`the routine
`
`continues at block 2808.
`
`In decision block 2808, if the response indicates that the edge is
`
`acceptable to the requesting process, then the routine continues at block 2809, else the
`
`routine continues at block 2812.
`
`In block 2809, the routine reserves the edge between this
`
`20
`
`process and the sending neighbor.
`
`In block 2810, the routine adds the requesting process as
`
`a neighbor by invoking the add neighbor routine.
`In block 2811, the routine removes the
`sending neighbor as a neighbor.
`In block 2812, the routine hangs up the external port and
`
`continues at block 2815. In decision block 2813, if this process is the requesting process and
`
`the number of holes of this process equals one, then the routine continues at block 2814, else
`
`25
`
`the routine continues at block 2815.
`
`In block 2814, the routine invokes the fill hole routine.
`
`In block 2815,
`
`the routine sends an connection edge search response message (i. e.,
`
`connection_edge_search_response) to the sending neighbor indicating acknowledgement and
`
`then returns. The graphs are sensitive to parity. That is, all possible paths starting from a
`
`node and ending at that node will have an even length unless the graph has a cycle whose
`
`30
`
`length is odd. The broadcaster component uses a toggle indicator to vary the random walk
`
`distance between even and odd distances.
`
`[o3oo4.soor/swo3733.1os]
`
`-3 9-
`
`7/31/90
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 461 of 1442
`
`IPR2016-00726 -ACTIVISION, EA, TAKE-TWO, 2K, ROCKSTAR,
`Ex. 1102, p. 461 of 1442
`
`

`
`Figure 29 is a flow diagram illustrating the processing of the handle connection
`
`edge search response routine in one embodiment. This routine is passed as indication of the
`
`requesting process, the sending neighbor, and the message.
`
`In block 2901, the routine notes
`
`that
`
`the connection edge search response (i. e., connection_edge_search_resp) has been
`
`5
`
`received and if the forwarding distance is less than or equal to one unreserves7‘th‘e edge
`
`between this process and the sending neighbor.
`
`In decision block 2902, if the requesting
`
`process indicates that the edge is acceptable as indicated in the message, then the routine
`
`continues at block 2903, else the routine returns.
`
`In block 2903, the routine reserves the edge
`
`between this process and the sending neighbor.
`
`In block 2904, the routine removes the
`
`10
`
`sending neighbor as a neighbor.
`
`In block 2905, the routine invokes the court neighbor
`
`routine to connect to the requesting process.
`
`In decision block 2906, if the invoked routine
`
`was unsuccessful, then the routine continues at block 2907, else the routine returns.
`
`In
`
`decision block 2907, if the number of holes of this process is greater than zero, then the
`
`routine continues at block 2908, else the routine returns.
`
`In block 2908, the routine invokes
`
`15
`
`the fill hole routine and then returns.
`
`Figure 30 is a flow diagram illustrating the processing of the broadcast routine
`
`in one embodiment. This routine is invoked by the application program to broadcast a
`
`message on the broadcast charuiel. This routine is passed the message to be broadcast.
`
`In
`
`decision block 3001, if this process has at least one neighbor, then the routine continues at
`
`20
`
`block 3002, else the routine returns since it is the only process connected to