Int. J. Computational Science and Engineering, Vol. 2, Nos. 1/2, 2006 23 Hierarchical Grown Bluetrees (HGB): an effective topology for Bluetooth scatternets Tsung-Chuan Huang* Department of Electrical Engineering, National Sun Yat-sen University, Kaohsiung, Taiwan, ROC Fax: +886 7 5254199 E-mail: tch@mail.nsysu.edu.tw *Corresponding author Chu-Sing Yang Department of Computer Science and Engineering, National Sun Yat-sen University, Kaohsiung, Taiwan, ROC E-mail: csyang@cse.nsysu.edu.tw Chao-Chieh Huang Department of Electrical Engineering, National Sun Yat-sen University, Kaohsiung, Taiwan, ROC E-mail: m8731629@student.nsysu.edu.tw Sheng-Wen Bai Department of Computer Science and Engineering, National Sun Yat-sen University, Kaohsiung, Taiwan, ROC E-mail: sevenbai@gmail.com Abstract: Bluetooth is a promising technology for short range wireless communication and networking, mainly used as a replacement for connected cables. Since the Bluetooth specification only defines how to build piconet, several solutions have been proposed to construct a scatternet from the piconets in the literatures. A tree shaped scatternet is called the bluetree. In this paper, we present a method to generate the bluetree hierarchically; namely, the nodes are added into the bluetree level by level. This kind of Hierarchical Grown Bluetree (HGB) topology resolves the defects of the conventional bluetree. During growing up, HGB always remains balanced so as to preserve shorter routing paths. Besides, the links between siblings provide alternative paths for routing. As a result, the traffic load at parent nodes can be greatly improved and only two separate parts will be induced if a parent node is lost. The Bluetooth network therefore achieves better reliability. Keywords: piconet; scatternet; bluetree; scatternet formation; average routing path; destination hit ratio. Reference to this paper should be made as follows: Huang, T-C., Yang, C-S., Huang, C-C. and Bai, S-W. (2006) Hierarchical Grown Bluetrees (HGB): an effective topology for Bluetooth scatternets, Int. J. Computational Science and Engineering, Vol. 2, Nos. 1/2, pp.23 31. Biographical notes: Tsung-Chuan Huang received his BS and MS Degrees both in engineering science from National Cheng-Kung University, Taiwan, in 1975 and 1982, respectively, and holds PhD in electrical engineering also from National Cheng-Kung University, in 1989. From August 1993 to 1994, he visited Center for Supercomputing Research and Development, University of Illinois at Urbana-Champaign, as a visiting scholar. He is currently a Professor of Department of Electrical Engineering, National Sun Yat-Sen University, Taiwan, ROC. His research interests include parallelising compiler, high performance computer architectures, parallel processing, algorithm, and wireless & ad hoc networks. Copyright 2006 Inderscience Enterprises Ltd.
24 T-C. Huang, C-S. Yang, C-C. Huang and S-W. Bai Chu-Sing Yang received the BS Degree from the Department of Engineering Science, National Cheng Kung University in 1976, and both of the MS and PhD Degrees from the Department of Electrical Engineering, National Cheng Kung University in 1984 and 1987, respectively. Since 1993, he has been a Professor in the Department of Computer Science and Engineering at National Sun Yat-Sen University. His research interests include internet technology, scalable web server, multimedia communication, wireless communication and e-learning system. Chao-Chieh Huang received his BE in Electrical Engineering from National Cheng-Kung University, Tainan, Taiwan, in 1996. After completing military service, he joined V-Star Co. as a software engineer for one year. In 2003, he received his ME in Electrical Engineering from National Sun Yen-sen University, Kaohsiung, Taiwan. Currently he is a PhD candidate in Electrical Engineering at National Sun Yen-sen University, Kaohsiung Taiwan. His research interests include wireless communication and mobile ad hoc networks. Sheng-Wen Bai received his BS and the MS Degrees in Information Engineering from Feng Chia University in 1996 and 1998, respectively, and PhD in Computer Science Engineering from Sun Yat-Sen University in 2005. His research interests are in the area of parallel and distributed computing, high performance compilers, and mobile computing systems. 1 Introduction Bluetooth is a fast growing technology for short range wireless networks and wireless personal area networks (WPAN) in recent years. It aims at supporting wireless connectivity among mobile devices such as cellular phones, headsets, PDAs (Personal Digital Assistants), digital cameras, laptop and computer peripheries. The Bluetooth technology enables the design of low cost, low power, small size radios that can be embedded in existing portable devices. For instance, a three in one phone is a GSM (Global System for Mobile Communications) cellular phone embedded with Bluetooth module. It is a GSM cellular phone outdoors, but becomes a Walkie-talkie indoors. When two three in one phones are in communication range, they can communicate with each other, free charged. When connecting to PSTN (Public Switched Telephone Network) adapter indoors, the three in one phones can be used for fixed line communication and are charged based on the fixed line communication rate. This is the advantage and convenience of devices with Bluetooth module embedded. According to the Bluetooth specification (http:// www.bluetooth.com), Bluetooth devices operate in the globally available 2.4 GHz band reserved for Industrial, Scientific, and Medical (ISM) applications. This band with 83.5 MHz is divided into 79.1 MHz spaced channels except the guard band. It uses the technique of the frequency hopping spread spectrum (FHSS) to define multiple channels, called frequency hopping sequences (FHS), which coexist in this wide band without interfering with each other. When two Bluetooth devices come into each other s communication range, a connection between them is established through the inquiry and page procedures defined in the Bluetooth specification. The inquiry procedure is used to discover other devices and the page procedure is used to establish the actual link. The sender device that broadcasts the inquiry message becomes the master while the receiver device that always keeps listening becomes the slave. Time division duplex (TDD) is used for communicating between the master and the slaves. The channel is divided into 625 msec intervals, called slots. Different slots use different hop frequencies. The master transmits in even numbered slots while the slave transmits in odd numbered slots. A group of devices sharing a common channel is called a piconet. Each piconet can only have one master, which decides the frequency hopping sequence for the piconet and controls the access to the channel. There is no limit on the maximum number of slaves connected to the master, but the number of active slaves at one time can be at most seven. If a master has more than seven active slaves, some slaves must be parked. Parked devices cannot operate in the piconet until they are unparked. The network constructed from connecting the piconets is called the scatternet. In Bhagwat and Segall (1999), Foo and Chua (2002) and Law and Siu (2001), a treebased scatternet called the bluetree was proposed. The scatternet is formed using the topology of tree shape, in which the parent node is the master and the child nodes are the slaves. These bluetrees will be referred as the general bluetree (GB) in the rest of this paper. The general bluetree has three defects: It is inefficient in routing. When GB is a skewed tree, rather than a balanced tree, a longer routing path will be induced. The parent nodes in GB are likely to become the communication bottlenecks, resulting in heavy traffic load. It is not reliable. When a parent node is lost, several separate parts may cause; the subtrees of the lost node and the remaining part of the bluetree. It will lead to a time consuming process for rebuilding the entire scatternet in order to maintain the connectivity. In this paper we improve the structure of GB and propose formation methods to cope with these problems. The proposed bluetree grows level by level, keeping the topology balanced during the process of scatternet formation. Compared to the skewed bluetree, a balanced bluetree has a shorter routing path. In addition, a
Hierarchical Grown Bluetrees (HGB): an effective topology for Bluetooth scatternets 25 message can be sent via the connection between the siblings (refer to Section 3 for details) instead of having to pass through the parent node. As a result, the communication bottlenecks at parent nodes can be greatly improved. Besides, once a parent node is lost, only two separate parts can be caused: one is the connected part below the lost node and the other is the remaining part of the bluetree. A better reliability can be achieved. The remainder of this paper is organised as follows. Section 2 describes the relevant researches on Bluetooth scatternets. Section 3 presents our improving scheme of tree based scatternet. Section 4 shows the experimental results. Finally, we conclude this paper in Section 5. 2 Related work Several methods for scatternet formation have been proposed (Basagni and Petrioli, 2002; Foo and Chua, 2002; Law and Siu, 2001; Salonidis et al., 2001; Sun et al., 2002; Tan et al., 2001; Wang et al., 2002; Zaruba et al., 2001). In Basagni and Petrioli (2002), Law and Siu (2001), Salonidis et al. (2001) and Wang et al. (2002), the net (or mesh) scheme has been used to construct a scatternet. But the bridge nodes in the net (or mesh) scheme may link too many piconets, resulting in the switching delay between different piconets. Thus many methods devoted to constrain the links of bridge nodes in order to reduce the switching overhead. In Basagni and Petrioli (2002), the generated topology is a connected mesh with multiple paths between any pair of nodes to achieve fault tolerance. There are three phases: neighbours discovery isolated piconets formation piconets interconnection. Since a piconet in this topology may contain 2 8 nodes, the scatternet will result in a large scale of network if piconets contain too small number of nodes. Longer routing path and complex routing cannot avoid in this method. In Law and Siu (2001), Law et al. presented a randomised distributed algorithm for constructing the scatternet. The algorithm guarantees that any device can be a member of at most two piconets and the number of piconets is close to minimum. Initially all devices enter inquiry state or inquiry scan state at random and alternate independently between the inquiry state or inquiry scan state. Two devices need appropriate time intervals to finish the inquiry procedure; otherwise they reenter the inquiry state or inquiry scan state. Failure inquiry is time consuming and delays the scatternet formation. The protocol, BTCP (Bluetooth Topology Construction Protocol) proposed in Salonidis et al. (2001) consists of two phases. The first is coordinator election. All nodes join in the link establishing process. When two nodes establish a link, the one with smaller address becomes the winner and owns the other s address and clock information. The winners then join in the link establishing process again until the one with the smallest address is determined. This node becomes the leader to have the address and clock information of all nodes. The second phase is role determination and topology construction. The coordinator determined in the first phase constructs the scatternet by using the address and clock information of all nodes. In this method, the first phase is time consuming. If there exist 30 nodes, 29 comparisons are needed for electing the coordinator. Therefore, the number of nodes should be limited in a small size to avoid consuming too much time during election period. The Bluenet scheme in Wang et al. (2002) tried to reduce as much bridge overhead as possible while maintaining a reasonable degree of connectivity in the resulting scatternet. But this method cannot guarantee the scatternet fully connected after scatternet formation. The ring scheme called BlueRing in Foo and Chua (2002) simplifies the structure of scatternet. All nodes are arranged in a ring structure. Each node acts as a slave in this piconet but acts as a master in the neighbour piconet. The disadvantage of ring structures is high packet delays due to large network diameter in the BlueRing. The tree structure proposed in Sun et al. (2002), Tan et al. (2001) and Zaruba et al. (2001) is neither complicated like a net or a mesh nor simple as a ring. It is suitable for scatternet formation in the wireless personal area network. In Sun et al. (2002), Sun et al. presented a method to embed b-trees scheme into a scatternet, enabling such a network to be selfrouting. It requires only small fix sized information and needs no routing table at each node despite the size of scatternet. During the scatternet formation, pruning and adjusting nodes into allowable range is time consuming because nodes must be arranged into the structure of b-tree when two subtrees are merged. In Tan et al. (2001), Tan et al. proposed a TSF scattenet formation protocol to construct a tree based scatternet. The protocol is selfhealing such that nodes can join or remove at any time. Since the bluetree is kept connected anytime, the actions of rejoining will make the bluetree unbalanced. The optimal routing path length is not achieved therefore. In Zaruba et al. (2001), Zaruba et al. introduced Bluetrees as a practical protocol for forming connected scatternets, which has two variations: Blueroot Grown Bluetree and Distributed Bluetree. The former builds a scatternet starting from some specified node called the Blueroot; the latter speeds up the scatternet formation process by selecting more than one root for tree formation and then merging the trees generated by each root. These two bluetrees cannot guarantee the structure always balanced. Hence, the skewed bluetree will cause a longer routing path. In dealing with the routing problem of Bluetooth network, Bhagwat et al. provided an ondemand method in Bhagwat and Segall (1999). Only the nodes wishing to send a message broadcast a query to learn the route to the destination node before sending the message. The drawback of this method lay in the delay incurred by query phase and the flooding of query signals (Sun et al., 2002).
26 T-C. Huang, C-S. Yang, C-C. Huang and S-W. Bai 3 Hierarchical Grown Bluetree This section describes the scatternet formation method and routing protocols in detail. The followings are the definitions associated with node x in proposed bluetree. They will be used throughout the rest of this paper: dev_info(x). The information of node x, including the address, clock and level of node. bd_addr(x). The Bluetooth MAC address of node x defined in the Bluetooth specification. level(x). The level of node x in the bluetree. struc_array. A one dimensional array recording the nodes in the bluetree. Table 1 is an example of array representation for the bluetree in Figure 1. Each node is associated with an index. The position of index 0 records the root node 35. The positions from indices 1 to 5 record the children of node 35, i.e., 70, 21, 15, 39 and 33, respectively. For each node, we reserved 5 index positions to record its children. Since node 70 has only one child, node 36 is recorded in the position of index 6; indices 7 to 10 are set to 0. Figure 1 An example of bluetree Table 1 struc_array for the bluetree in Figure 1 inquiry scan state, page state, page scan state and connection state. A node switches between these states according to the specific condition it meets in the network. In scatternet formation, a node will be selected as the root of our bluetree. This strategy was proposed by Zaruba et al. (2001) in which an arbitrary node is initially designated as the blueroot. Using Figure 1 as an example, let us explain the scatternet formation process in our method. Suppose that node 35 is selected as the blueroot at the outset. It accordingly enters into the inquiry state by broadcasting inquiry messages to discover other devices. All of the isolated nodes are in the inquiry scan state. Assume that node 70 receives the inquiry message from node 35 and responses with dev_info(70) message which contains the information of address, clock and level of node 70. Node 35 now locks itself to deny the insertions of other nodes. It then switches to the page state to page node 70 and set up a link using the information in dev_info(70). Node 35 acts as the master and node 70 is the slave. After this, node 35 reenters into the inquiry state again. This process repeats until the number of children grows up to 5. To relieve the traffic load of parent nodes, we improve the general bluetree topology by establishing extra links between the siblings. In the bluetree scheme, parent nodes act as the master and child nodes act as the slaves. Because the Bluetooth specification only allows a master to have seven slaves, we limit parent nodes to have at most five child nodes, reserving two links for the connections between siblings. When a node is a master, its children and siblings will act as slaves. For the example in Figure 2, if node B acts as a master then its child nodes G, H, I, J, K and sibling nodes C, D will be its slaves. In other words, the blueroot has at most five slaves, but parent nodes other than the blueroot have at most seven slaves (among which five are child node and two are sibling node). Index 0 1 2 3 4 5 6 11 12 21 22 26 27 28 29 30 Node 35 70 21 15 39 33 36 0 19 65 0 7 45 0 60 63 24 0 0 Figure 2 A parent node has at most seven slaves (five child nodes and two sibling nodes) In the following, we describe the required control messages for scatternet formation. The control messages are italicized. When a node is added or deleted, the parent will send an update message to the blueroot to update struc_array. When five children have been established, the parent will send a complete message accompanied with its level, to the blueroot. When the bluetree becomes a full tree with degree 5, the blueroot sends a permit_inq message to all of the leaf nodes. 3.1 Construction protocol In the Bluetooth specification (http://www.bluetooth.com), a node can be in one of several states. They are inquiry state, In Figure 1, if node 35 has only two children, nodes 70 and 21, the master and slave connection between siblings will be like in Figure 3(a) where the node at the arrow tail is the master, while the node pointed by the arrowhead is the slave. When the number of children increases from 3 to 5, the connections between the siblings will be as illustrated in Figures 3(b) (d), respectively. When node 33 acts as a master the slaves will be the sibling nodes 70 and 21 together with the child nodes 60, 63, and 24.
Hierarchical Grown Bluetrees (HGB): an effective topology for Bluetooth scatternets 27 Figure 3 Examples of master and slave link between siblings To see that the traffic load at the parent node can be efficiently improved by our bluetree scheme, let us assume that node 36 will communicate with node 60. In the general bluetree topology the message must be sent upward to node 35 then downward to node 60. Because any message from the source node must be sent to the common parent node, and then to the destination node, the common parent node incurs a heavy communication load. But in our scheme, the message from node 36 can take the path from node 70 to node 33 then to node 60 rather than having to pass through node 35 (because there is a link from node 70 to 33). This effectively avoids the communication congestion at the common parent node (node 35 in this example). Once the blueroot owns 5 children, all nodes in level 2 are permitted to enter into the inquiry state simultaneously and broadcast inquiry messages to discover other devices. Similarly, the nodes in level 3 can enter into the inquiry state only when all of the nodes in level 2 have 5 children, and so on. In other words, the leaf nodes in level h can enter into the inquiry state and concurrently construct their own piconet only when they already have 5 h 1 nodes. In this way our bluetree always keeps balanced in the scattenet formation process. Since the bluetree is constructed level by level, the time complexity is O(log 5 n) if the network has n nodes. In the following, we describe the procedure for each state. The state transition diagram is illustrated in Figure 4. The dash lines represent the access message and the solid lines indicate the state transition. In sending an access message, the nodes in the inquiry state and page state are the senders while those in the inquiry scan state and page scan state are the receivers. The sender sends an access message, and the receiver responds to the access message. In the following procedure, we use x implicitly to denote a sender and y a receiver. The inquiry state procedure. The nodes in this state broadcast inquiry message periodically and keep listening all the time. When receiving a response message from some node y, i.e., dev_info(y), the node locks itself and switches to the page state if the number of children is <5. The inquiry scan state procedure. The nodes in this state keep listening to the inquiry message. When a node y receives the inquiry message from x, it responds dev_info(y) to x and switches to the page scan state. The page state procedure. Node x in the page state will handshake with node y that responded to the inquiry message. If the handshaking succeeded (the connection between x and y was established), node x switches to the connection state otherwise unlocks itself and returns to the inquiry state. The page scan state procedure. Node y in the page scan state handshakes with node x to which the response message was sent. If the handshaking succeeded (the connection between x and y was established), node y switches to the connection state, otherwise returns to the inquiry scan state. The connection state procedure If the node in this state switched from the page state (namely, it is a master or parent node), it unlocks itself. If this node is the blueroot, it updates struc_array directly, otherwise establishes the links between siblings according to the number of children it owns and sends update message to the blueroot for updating the struc_array. Once five children have been established, the parent node sends a complete message to the blueroot. The blueroot broadcasts a permit_inq message to all of the leaf nodes if it received a complete message (refer to Section 3) and the maximum level of bluetree is full. If the node in this state switched from the page scan state (i.e., it is a slave or a leaf node), it is inserted into the struc_array. When a leaf node receives a permit_inq message, it switches to the inquiry state. Figure 4 The state transition diagram
28 T-C. Huang, C-S. Yang, C-C. Huang and S-W. Bai The detailed construction protocol is shown as bellow. All nodes execute this protocol to construct the scatternet. HGB Construction Protocol //The node in the inquiry or page state (i.e., the sender) is indicated by x; the node in the inquiry scan or page scan state (i.e., the receiver) is indicated by y. INQUIRY STATE: node x broadcasts inquiry message periodically on receiving an inquiry response of dev_info(y) if the number of x s children < 5 x locks itself and switches to page state INQUIRY SCAN STATE: node y listens to the inquiry messages on receiving the inquiry message from x sends dev_info(y) to x and switches to page scan state PAGE STATE: node x handshakes with node y if the handshake succeeded /* the connection is established */ x switches to connection state unlocks itself and returns to inquiry state PAGE SCAN STATE: node y handshakes with node x if the handshake succeeded /* the connection is established */ y switches to connection state returns to inquiry scan state CONNECTION STATE: //Let z be a node in the connection state if z is a parent node /* z switched from the page state */ unlocks itself if z is the blueroot updates the struc_array sends an update message to the blueroot //Establish (master, slave) links between the siblings switch the number of z s children case 2: establish the link (1st child, 2nd child) between the siblings. case 3: establishes the links (2nd child, 3rd child), and (1st child, 3rd child) between the siblings. case 4: establish the links (3rd child, 4st child), (2nd child, 4th child), and (4th child, 1st child) between the siblings. case 5: establish the links (4th child, 5th child), (3rd child, 5th child), (5th child, 1st child), and (5th child, 2nd child) between the siblings. if z is the blueroot sends permit_inq message to its children /* z is not the blueroot */ sends a complete message to the blueroot end switch /* z switched from the page scan state */ insert node z into the struc_array on receiving a complete message if z is the blueroot and the maximum level is full sends a permit_inq message to all of the leaf nodes on receiving a permit_inq message if z is a leaf node switches to the inquiry state on receiving an update message if z is the blueroot updates the struc_array 3.2 Routing protocol When a node wants to send a message to another node, it polls the blueroot to get the routing path rp. The routing path rp contains the hops that the message will pass. The blueroot uses the following routing protocol to calculate the routing path. HGB Routing Protocol //Assume that node s wants to send a packet to node d. Search struc_array for the destination node d if d is not found respond that d does not exist initialise s and d with 0 //Let idx s and idx d be the index of node s and d, respectively while idx s idx d if idx s > idx d add idx s to the routing path rp idx idx s = s 1 5 set s to 1 if idx s < idx d add idx d to the routing path rp idx idx d = d 1 5 set d to 1 end while
Hierarchical Grown Bluetrees (HGB): an effective topology for Bluetooth scatternets 29 if s = 0 add idx s to the routing path rp if d = 0 add idx d to the routing path rp return the routing path rp to node s In the routing protocol, the blueroot firstly checks if the destination node exists. If it does not exist, the blueroot responds a nonexistence message to the source node. Otherwise, the blueroot compares the indices of source node and destination node. The node with the larger index is added into the routing path rp and is replaced by its parent for the subsequent comparison. The index comparison between the source node and the destination node is repeated until they are with the same parent. The routing path rp is now obtained and sent to the source node. In the protocol, we use two flags s and d to represent if the source node or the destination node has ever been moved upward during the construction of routing path. They are initialised with 0. When the source node is moved upward to its parent, s is set to 1. Likewise, when the destination node is moved upward to its parent, d will be set to 1. After the routing path has been found, if s is 0 then the source node will be an ancestor of the destination node. Similarly, if d is 0 then the destination node will be an ancestor of the source node. In this situation, the routing paths in HGB and GB have the same path length. If the source/destination node is not an ancestor of the destination/source node, the routing path in HGB can choose to pass through the siblings instead of through the parent. Therefore, the routing path of HGB will be shorter than that of GB. Figure 5 is an HGB bluetree of four levels. Level 3 is full of 25 nodes with dots representing the omitted nodes. The nodes in level 4 are all leaf nodes. The array representation is demonstrated in Table 2. Now assume that node 36 wants to send a message to node 6. From struc_array the blueroot finds the index of node 36 to be 6 and the index of node 6 to be 131. Because 6 < 131, the blueroot adds 131 into rp (i.e., rp becomes (131)). The parent of node 6 is node 60 whose index is 26. Because 6 < 26, index 26 is hence added into rp. Now rp yields (26, 131). Continuing the process, the parent of node 60 is node 33 whose index is 5. Because 6 > 5, index 6 is added into rp. Therefore rp becomes (6,26,131). The parent of node 36 is then computed to be node 70 and the index of node 70 is 1. Because 1 < 5, index 5 is added into rp. Now rp yields (6,5,26,131). The parent of node 33 is computed to be node 35 whose index is 0. Because 1 < 0, index 1 is added into rp. rp is now (6,1,5,26,131). The parent of node 33 is computed to yield node 35 whose index is 0. Since the source node and destination node have common roots. The routing path is finally obtained to be rp = (6,1, 5, 26, 131). Figure 5 A routing example of bluetree Table 2 struc_array for the bluetree in Figure 5 Index 0 1 2 3 4 5 6 16 21 26 30 31 131 141 Node 35 70 21 15 39 33 36 0 45 7 60 24 43 0 6 12 4 Experiments and results Three values are measured to evaluate the performance of proposed protocol: average routing path (ARP) destination reachable ratio (DRR) throughput. ARP is the average number of hops counted from the source node to the destination node. DRR is defined as the ratio of total reachable nodes from each node to total number of nodes in the network when one node is lost. Throughput is the data amount that the destination node can receive per second (Das et al., 2001). We compare the three values of general bluetree (GB) to that of Hierarchical Grown Bluetree (HGB) by simulation. In the experiments, NS (Network Simulator) (http://www.isi.edu/nsnam/ns) is used to implement the simulation. 4.1 ARP evaluation The average routing path length in the bluetrees should be as smaller as better. To simplify the comparison, the node degree, except the leaf, of both GB and HGB is assumed full (i.e., the node degree of general bluetree is 7 and that of HGB is 5). In this situation, the GB is balanced and in the best case. The recursive functions used for computing the path length from the source node idx s to the destination node idx d in GB and HGB are shown as follows, respectively.
30 T-C. Huang, C-S. Yang, C-C. Huang and S-W. Bai PL HGB idxs 1 PLHGB, 1, 1, 5 idxd + s = s + if idxs > idxd idxd 1 PLHGB idxs, + 1, d = d + 1, 5 ( idxs, idxd) = if idxs < idxd 0, if ( idxs = idxd) and source node and destination node are with the relationship of ancestor and descendant 1 otherwise idxs 1 PLGB, d 1, s d 7 idx + if idx > idx idxd 1 PLGB( idxs, idxd) = PLGB idxs, 1, if idxs idxd 7 + < 0, if idxs = idxd. Both functions are recursive with two parameters: the indices of source node and destination node. Before invoking the function itself, the indices of source node and destination node are compared. The larger one will be replaced by the index of its parent computed using the formula (idx 1)/7 (for GB) or (idx 1)/5 (for HGB) and the path length is increased by 1, then the function is invoked again. The recursive call repeats until the same parent is reached. In this time, the routing path length has been evaluated. Only when the source/destination node is an ancestor of the destination/source node, are the routing paths in HGB and GB of the same length. In all other cases the routing path in HGB can pass through the sibling link but not through the parent. This feature cannot only reduce the routing path but also can relieve the parent node from becoming a bottleneck. Figure 6 shows the results of ARP comparison between GB and HGB with the number of nodes varying from 5 to 500. We find that the ARP of HGB is consistently smaller than that of GB in all cases. Besides, since the GB structure in this experiment is assumed balanced (i.e., it is in the best case), its ARP in the real situation will be larger than what we have measured. In other words, the average routing path of HGB in the real case will be shorter than that of GB. Figure 6 ARP comparison between GB and HGB 4.2 DRR evaluation When a node is lost or fails, the impacts on the ratio of reachable nodes for GB and HGB are different. For GB, there will be a yield of n separate parts if the lost node has n subtrees; but for HGB, the subtrees of the lost node are still connected due to the sibling link. We use a 5 level full tree with degree 5 for both GB and HGB (so that they have equal numbers of nodes in the network) to compare their destination reachable ratio (DRR) when one node is lost. The level of the missing node is simulated, varying from 1 to 5. Figure 7 shows the results. When the blueroot in level 1 is lost, the DRR of GB is dramatically lower than that of HGB because GB is seriously split. In contrast, the DRR of HGB remains 1 because HGB is still fully connected even when the blueroot is lost. When the missing node happens in level 2 to level 5, we find that lower level has smaller DRR than the higher level because lower level losing a node causes more nodes to be separated from each other on both structures of GB and HGB. Furthermore, the DRR of HGB is always higher than that of GB because the subtrees of the lost node in GB are separated but are full connected on HGB. Figure 7 DRR comparison of GB and HGB varying the level of lost node from 1 to 5 4.3 Throughput evaluation According to the Bluetooth specification (http:// www.bluetooth.com), each baseband packet can cover 1, 3 or 5 time slots. Among these, the one covering 5 timeslots has the largest payload size of 339 bytes. We use constant packet transmission rate, CBR (constant bit rate) as the traffic model in the throughput experiment. The traffic model defines the packet size and the packet transmission rate. The packet size we used was 640 Kb and the packet transmission rate was 433.9 Kbit/s. A traffic generator was employed to simulate the transmitted packets. Figure 8(a) and 8(b) show the piconet model of GB and HGB respectively, that were used in this experiment. Node 1 to node 5 represents the root of their subtrees, respectively. Packets transmitted between two subtrees can be simulated by transmitted between node 1 and node 5. This model can be used in the experiment because sending a packet from one node of a subtree to another node of a subtree must pass
Hierarchical Grown Bluetrees (HGB): an effective topology for Bluetooth scatternets 31 via their root nodes. To be precise, sending a packet from some node in a subtree of node 1 to a certain node in subtree of node 4 must go through node 1 and node 4. Traffic generators are employed from node 1 to node 5 to simulate the transmitted packets randomly and the destination node is also randomly generated every second. For instance, node 5 may send packets to node 4 in this second, but to node 1 in the next second. The experiment simulates 15 seconds, using random traffic generator to reflect the practical environment. Figure 8 Piconet model the missing node, the other is the remaining part of the bluetree. In the ARP experiment, we find that HGB has shorter routing path than balanced GB. If GB is not balanced, its routing path will be even longer. In the throughput evaluation, HGB obtains better throughput because the heavy congestion at root node is improved by the link between siblings. In the DRR evaluation, we find that missing the blueroot will cause the scatternet of GB seriously split and make network reliability greatly down. In contrast, the topology of HGB is still fully connected even when the blueroot is removed. When a node is lost, 8 parts might have arisen (because the degree of the missing node is at most 7) in GB but only two parts will be caused in HGB. In addition, the time consuming recovery procedure is also a problem of GB structure. References Figure 9 shows the measured throughputs where axis X is the simulation time and axis Y is the packet amount. They reveal that HGB outperforms GB. In GB structure, the congestion occurring at parent nodes will be more serious when the bluetree is large and transmission data is heavy. But the congestion can be greatly improved by the complete connection between the siblings in HGB. Figure 9 5 Conclusions Throughput comparison between GB and HGB In this paper, a Hierarchical Grown Bluetree topology and its construction protocol are proposed. The height balance property and sibling links of HGB makes its routing path shorter than GB. The congestion prone to happen at the parent nodes of GB is also improved by HGB using the sibling links. Besides, the complete connection between the siblings resulting in only two separate parts in HGB when a parent node is lost; one is the connected part below Basagni, S. and Petrioli, C. (2002) A scatternet formation protocol for ad hoc networks of bluetooth devices, IEEE Vehicular Technology Conference, Spring, Vol. 1, pp.424 428. Bhagwat, P. and Segall, A. (1999) A routing vector method (RVM) for routing in bluetooth scatternets, Proc. IEEE International Workshop on Mobile Multimedia Communications (MoMuC), November, pp.375 379. Das, A., Ghose, A., Razdan, A., Saran, H. and Shorey, R. (2001) Enhancing performance of asynchronous data traffic over the bluetooth wireless ad-hoc network, Proc. of IEEE INFOCOM 2001, Alaska, USA, April. Foo, C.C. and Chua, K.C. (2002) BlueRings-bluetooth scatternets with ring structures, IASTED International Conference on Wireless and Optical Communication (WOC 2002), Banff, Canada, July. Law, C. and Siu, K-Y. (2001) A bluetooth scatternet formation algorithm, Proc. of the IEEE Symposium on Ad Hoc Wireless Networks 2001, San Antonio, Texas, USA, November. Salonidis, T., Bhagwat, P., Tassiulas, L. and LaMaire, R. (2001) Distributed topology construction of bluetooth personal area networks, IEEE INFOCOM 2001, Anchorage, USA, April. Sun, M., Chang, C.K. and Lai, T.H. (2002) A self-routing topology for bluetooth scatternets, Proc. I-SPAN 2002, Manila, Philippines, May. Tan, G., Miu, A., Guttag, J. and Balakrishnan, H. (2001) Forming Scatternets from Bluetooth Personal Area Networks, MIT Technical Report, MIT-LCS-TR-826, October. Wang, Z., Thomas, R.J. and Haas, Z.J. (2002) Bluenet a new scatternet formation scheme, 35th Hawaii International Conference on System Science (HICSS-35), Big Island, Hawaii, January. Zaruba, G.V., Basagni, S. and Chlamtac, I. (2001) Bluetrees scatternet formation to enable bluetooth-based ad hoc networks, IEEE International Conference on Communications (ICC) 2001, pp.273 277. Websites Bluetooth Core Specification, http://www.bluetooth.com. NS (Network Simulator), http://www.isi.edu/nsnam/ns.