Abstract:
Techniques are disclosed for processing requests in a data processing system. While the principles of the invention are not limited to a particular domain, they are particularly suitable for use in an electronic trading system. By way of example of one aspect of the invention, a method for directing requests to at least one node in a system comprising multiple nodes and a plurality of requests comprises associating a number to each request, assigning at least one number to each node so as to balance a load across the nodes, and sending a request to a node based on the number associated to the request. Various other aspects are disclosed.

Description:
FIELD OF THE INVENTION  
       [0001]     The present invention generally relates to data processing systems and, more particularly, to techniques for partitioning data in a parallel processing environment.  
       BACKGROUND OF THE INVENTION  
       [0002]     Market matching is a core component needed to manage trading in a set of financial instruments. A market matching service typically maintains a set of order books. In an electronic trading system, such order books are electronically maintained. Different order books may be maintained for different financial instruments traded. The order books may be used for processing arriving orders to buy and sell those instruments.  
         [0003]     Requests arriving at the market matching service may be a mixture of new orders, cancellations and modifications of previous orders, etc. By way of example, a simple order may be a request to buy or sell a specific quantity of a specific instrument on behalf of a specific customer at a named price or limit price. Refinements such as mass-quote, stop loss and all-or-nothing orders require additional features, but do not change the basic pattern of processing.  
         [0004]     One problem known to exist in a conventional electronic trading system, which implements a market matching service, is the ability of the system to efficiently process a high volume of requests.  
         [0005]     Accordingly, there is a need for techniques that are able to efficiently process a high volume of requests in a data processing system such as in an electronic trading system.  
       SUMMARY OF THE INVENTION  
       [0006]     Principles of the invention provide techniques for processing requests in a data processing system. While the principles of the invention are not limited to a particular domain, they are particularly suitable for use in an electronic trading system.  
         [0007]     In a first aspect of the invention, a method for directing requests to at least one node in a system comprising multiple nodes and a plurality of requests comprises associating a number to each request, assigning at least one number to each node so as to balance a load across the nodes, and sending a request to a node based on the number associated to the request.  
         [0008]     In a second aspect of the invention, a method for storing information across nodes in a system comprising multiple nodes comprises assigning different prices to different parts of the information, and storing the information across the nodes based on the prices.  
         [0009]     In a third aspect of the invention, a method for balancing load across nodes in a system comprising multiple nodes comprises storing multiple data objects among the plurality of nodes, and in response to a node becoming overloaded, migrating at least one data object from the overloaded node to a second node.  
         [0010]     In a fourth aspect of the invention, a method for balancing load across nodes in a system comprising multiple nodes and multiple data objects comprises maintaining an estimate of load associated with each data object, and using the estimates of load associated with each data object to store the data objects among the plurality of nodes so as to balance load among the nodes.  
         [0011]     Advantageously, as will be described herein in the context of various embodiments, illustrative principles of the invention are applicable to parallel processing in electronic trading systems as well as other domains. For example, methods and systems are provided for partitioning data objects or structures such as order books across multiple processors. By way of further example, load balancing techniques applicable to a broad range of parallel systems are also provided.  
         [0012]     These and other objects, features and advantages of the present invention will become apparent from the following detailed description of illustrative embodiments thereof, which is to be read in connection with the accompanying drawings. 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0013]      FIG. 1  is a block diagram illustrating how multiple order books can be distributed across multiple nodes, in accordance with an embodiment of the present invention;  
         [0014]      FIG. 2  is a block diagram illustrating how a single order book can be partitioned across multiple nodes, in accordance with an embodiment of the present invention;  
         [0015]      FIG. 3  is a flow diagram illustrating a method for partitioning an order book across multiple nodes, in accordance with an embodiment of the present invention;  
         [0016]      FIG. 4  is a block diagram illustrating how multiple order book partitions can be merged, in accordance with an embodiment of the present invention;  
         [0017]      FIG. 5  is a flow diagram illustrating a method for merging a plurality of order book partitions, in accordance with an embodiment of the present invention;  
         [0018]      FIG. 6  is a block diagram illustrating an assignment of load statistics to order books, in accordance with an embodiment of the present invention;  
         [0019]      FIG. 7  is a flow diagram illustrating a method for balancing load by transferring data, in accordance with an embodiment of the present invention;  
         [0020]      FIG. 8  is a block diagram illustrating a method for partitioning a single order book across multiple nodes in which individual price levels are assigned to different nodes, in accordance with an embodiment of the present invention;  
         [0021]      FIG. 9  is a diagram illustrating a computing system in accordance with which one or more components/steps of an electronic trading system may be implemented, according to an embodiment of the present invention;  
         [0022]      FIG. 10  is a flow diagram illustrating a method for routing requests to nodes, in accordance with an embodiment of the present invention; and  
         [0023]      FIG. 11  is a block diagram illustrating an initial assignment and dynamic re-assignment of numbers to nodes, in accordance with an embodiment of the present invention. 
     
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS  
       [0024]     Illustrative principles of the invention will be explained below in the context of a distributed electronic trading system, wherein customers make trading requests to the system and the system processes the requests. However, it is to be understood that the present invention is not limited to such an implementation. Rather, the invention is more generally applicable to any request-based data processing environment in which it would be desirable to provide improved request processing performance.  
         [0025]     Furthermore, data that is to be maintained and processed, such as an order book, may be referred to generally herein as an “object” or a “data object” or a “data structure.” Thus, while the illustrative embodiment is explained in terms of order books, a data object or structure may take on any form. Accordingly, it is to be understood that the invention is not limited to any particular form of data object or structure.  
         [0026]     Before explaining an illustrative information partitioning methodology and system architecture for implementing principles of the invention, an illustrative description of a market matching service or function, and processing associated therewith, is provided in accordance with an embodiment of the invention.  
         [0027]     Within the market matching function, arriving orders (requests) may be added sequentially into an order book for a financial instrument to which it refers. A market matching engine (i.e., a data processing component of an electronic trading system) should then identify and execute one or more orders which can be traded immediately. The engine does this by matching a newly arrived order with other matching orders already in the book for that instrument. Orders to sell are matched with orders to buy for the same instrument at the same price and conversely.  
         [0028]     Published business rules govern how this matching of orders is to be done. For example, orders might have to be processed fairly and in the sequence in which they are received. Orders might always have to be satisfied at the best matching price available and for as much of the quantity specified in the arriving order as is possible at that price and time. If there is a choice of matching orders at the best price, published allocation rules may govern which matching orders will be selected for trading.  
         [0029]     A market matching function may also be responsible for generating acknowledgements when it has processed an order, reporting on successfully applying an order to the market book and on trades executed involving that order. A gateway function is to return these acknowledgements to the customer. The market matching function may also be responsible for generating and distributing market information describing the current market liquidity and recently executed trades anonymously.  
         [0030]     Customers may interact with a market matching function of an exchange through sessions with a set of gateways—we also use the term gateway processing nodes. The gateways may handle the communication and client session processing for an individual client&#39;s electronic connection to the exchange. One client may be interacting with multiple trading products in an exchange and with multiple order books within each trading product. The gateway processing may be responsible for forwarding orders from customers to an appropriate market matching function and getting acknowledgements from the market matching delivered back to the customer.  
         [0031]     Since reliability may be a critical requirement on the market matching function, market matching processing may be organized so as to have secondary market matching capability prepared and ready to take over processing responsibility from primary market matching capability in the event of a market matching engine failure.  
         [0032]     An electronic market matching engine may operate in a continuous loop executing a sequence of logical steps for received requests similar to the following: 
        Buy and sell orders are received for parsing, matching, and sequencing (they may have already been assigned conversation sequence numbers to ensure that the messages for each customer conversation are handled in the correct order, but now primary node sequencing numbers are added to fix the ordering between requests from different customers and to enable standby and failover processing by a secondary).     Order cancellations and modifies are applied to orders in the book.     New orders are placed in the book and logged to ensure recovery over a system failure.     The matching engine determines whether a newly arrived or modified order is tradable immediately because there are previous opposing orders in the book matching it.     An allocation algorithm is run to determine the exact orders to trade following precisely defined business rules.     All successfully completed and logged actions including order placement, and completed trades are acknowledged back to the trading or requesting customers via gate processing. Anonymized reports on executed trades and market liquidity are also published as market data.     Logged orders and trades are streamed into a database where they may be available to surveillance queries by, for example, control center staff.        
 
         [0040]     In addition, a market matching function may provide operator facilities to start, stop, pause and monitor markets (sets of books). It may also provide facilities to allow operators to locate books within the matching engine, orders of a particular customer, etc., and process them individually, or make manual corrections.  
         [0041]     In accordance with an illustrative embodiment of the invention, we now describe a scalable architecture for market matching which can handle high transaction rates. As will be evident, the architecture makes use of distributed memory clustering.  
         [0042]     The architecture is designed to be both scalable and highly available. Higher numbers of processors can result in greater availability and greater resilience to failure. The architecture is comprised of a plurality of nodes, where a node may be (but is not necessarily limited to) a single processor or a symmetric memory multiprocessor (SMP). The nodes may be clustered at a single site. Alternatively, for higher availability, multiple clusters at distinct geographic locations could exist.  
         [0043]     We will refer to our architecture as a highly available adaptive partitioning (HA-APART) architecture. The data distribution capabilities that HA-APART possesses can be used to distribute a “hot” order book among several nodes. It is to be understood that a “hot” order book is one that receives a high level of activity (e.g., a high volume of requests relating to that book). If one node wants to access a data object or structure stored on another node, the first node may request the data from the second node.  
         [0044]     One of the key difficulties in parallelizing electronic market matching is how to partition the application across multiple processing nodes (referred to herein as “nodes”).  
         [0045]     One approach is not to split a single order book across different nodes. This approach is illustrated in  FIG. 1 . As shown, on the left hand side of the arrow, node  1  ( 10 - 1 ) maintains order books  11  (S&amp;P),  12  (YEN),  13  (Euro$) and  14  (EuroFX). On the right hand side of the arrow, the order books have been partitioned across multiple nodes ( 10 - 1 ,  10 - 2  and  10 - 3 ). Note that each order book remains as a whole on a given node.  
         [0046]     However, if a single order book becomes very hot, however, it may become necessary to partition the order book across more than one node. This approach is illustrated in  FIG. 2 . Order books may be assigned to nodes in order to balance load among the nodes. As load on the system changes, it may be desirable to move order book data between nodes to dynamically balance load. The HA-APART architecture has the ability to dynamically move data (e.g., order books) from one node to another. One key reason for doing this would be for load balancing. Another reason would be to add and/or remove a node.  
         [0047]     We now describe a method for partitioning hot order books. A single order book may receive such a high level of activity that it needs to be partitioned among multiple nodes. This is referred to as a hot order book. When this is done, different tick ranges will be assigned to different nodes. This process is illustrated in  FIG. 2 .  
         [0048]     As shown, on the left hand side of the arrow, order book (S&amp;P)  21  is maintained on node  20 - 1 . On the right hand side of the arrow (after partitioning), node  1  handles orders (from order book  21 ) less than $200. Node  4  handles orders (from order book  21 ) between $200 and $220. Node 5  handles orders (from order book  21 ) above $220. For example, a request to buy shares at $199 per share would be handled by node  1 . A request to sell shares at $225 per share would be handled by node  5 .  
         [0049]     Partitioning is preferably done in a manner which balances load evenly among different nodes. The scenario depicted in  FIG. 2  corresponds to a situation in which the trading price of the financial instrument is close to $210. The vast majority of orders are clustered close to $210. Therefore, even though the price range handled by node  4  is considerably smaller than the price ranges handled by node  1  and node  5 , node  4  is still likely to receive a large number of orders.  
         [0050]      FIG. 3  depicts a flow diagram for splitting a hot order book. Statistics may be maintained regarding the frequency of orders received by an order book and/or the load on a node corresponding to an order book. Once the order book traffic and/or load on the node exceeds a threshold (step  30 ), the system may decide to split an order book across multiple nodes (step  32 ). This will enable more processing resources to be devoted to the order book which should mean that the system can handle a higher transaction rate for the order book.  
         [0051]     It is to be understood that the “system” referred to here is the electronic trading system to which the processing nodes belong. Thus, it is to be understood that the steps of maintaining statistics regarding order frequency and node load, checking whether order book traffic exceeds a threshold value, and splitting of an order book, are steps that are automatically or semi-automatically performed by a computing system associated with the electronic trading system. Thus, such a computing system (illustratively described below in the context of  FIG. 9 ) is in communication with the various nodes such that a decision to split an order book can be effectuated.  
         [0052]     Note that the steps in  FIG. 3  can be applied to further split an order book which is already partitioned across multiple nodes into additional partitions spread across additional nodes.  
         [0053]     It may also be desirable to merge partitions in order to reduce the number of nodes handling an order book. This could be done if the request traffic to a hot order book drops to a level where it no longer needs as many nodes. It can also be used to free up a node for other tasks.  FIG. 4  presents an example of merging partitions ( 41 - 1 ,  41 - 2 ,  41 - 3  merged to  41 - 4 ,  41 - 5 ) in order to reduce the number of nodes handling the order book for the S&amp;P from three ( 40 - 1 ,  40 - 2 ,  40 - 3 ) to two ( 40 - 1 ,  40 - 2 ). Thus as shown, after the merge, node  5  is no longer handling S&amp;P commodity trading and can be used for other purposes.  
         [0054]      FIG. 5  depicts a flow diagram for merging partitions corresponding to an order book. Again, statistics may be maintained regarding the frequency of orders received by an order book partition and/or the load on a node corresponding to an order book partition. Once the order book traffic and/or load on one or more nodes handling an order book partition falls below a threshold (step  50 ), the system may decide to merge partitions (step  52 ) so that the order book uses fewer nodes. This will free up nodes for other purposes. Alternatively, it is to be appreciated that the triggering event for merger may be that computing resources are needed for another task.  
         [0055]     Note that if an order book is partitioned across n nodes, the steps in  FIG. 5  can be applied to merge partitions so that the order book uses anywhere between one and n−1 nodes.  
         [0056]     In order to balance load across multiple nodes, order books (either a whole order book or a partition) can be migrated from one node to another. We now describe an illustrative method for load balancing by migrating data.  
         [0057]     Order book data is partitioned across different nodes. Transactions directed to a particular partition p 1  on node n 1  generally increase the load on n 1 . In order to decrease the load that n 1  receives, p 1  may be moved to another node n 2 . If so, then n 2  will subsequently receive requests corresponding to p 1 , not n 1 . This should free up processing power on node n 1 .  
         [0058]     When a node n 1  becomes overloaded, the system may pick an underutilized node, n 2 , to which to transfer load. Order book data is then transferred from n 1  to n 2 . The system may monitor the load on different nodes to estimate load levels and make decisions on how to migrate data. It may also maintain load statistics H for different order book partitions to make load balancing decisions.  
         [0059]     Load statistics H may be maintained for a partition p 1 . Note that a partition may be interpreted as encompassing a part of an order book or a whole order book. These load statistics are correlated with how much load (e.g., CPU processing overhead and/or possibly other resources such as I/O, storage, network bandwidth) p 1  adds to a node. If it is assumed that this load is directly related to the number of transactions corresponding to p 1 , then H may be determined by the rate of transactions directed to p 1 . This transaction rate may constantly be changing. If so, it is preferable to weight more recent transactions more heavily than less recent transactions in determining H.  
         [0060]      FIG. 6  illustrates the use of load statistics H for performing load balancing. In this example, node  1  ( 60 - 1 ) is overloaded relative to node  2  ( 60 - 2 ). The H values are correlated with transaction rates received by different order books as well as with the load incurred by the node storing the order book. The H value for “Euro$” indicates a much higher transaction rate than that for “Yen” (900 versus 200). The system may make the decision to migrate “S&amp;P” from node  1  to node  2 . If the entire S&amp;P order book is moved from node  1  to node  2 , then the H value of node  1  (2600−700=1900) will equal the H value of node  2  (1200+700=1900). Thus, after this is done, resources on node 1  will be freed up, and node 1  and node 2  will have comparable loads.  
         [0061]     Note that load statistics H can be maintained for an entire node, an entire order book, or partitions of order books, such as the partitions shown in  FIGS. 1 and 2 . For a given order book, H values can be maintained for different price ranges. For example, different H values can be maintained for transactions in the range of $160-$180, $181-$200, $201-$210, etc. These H values can be used to determine how to partition order books as depicted in  FIGS. 3 and 5 .  
         [0062]     There are several methods for determining H values. One method is to simply count a number of transactions received over a certain time period. Variations of this method which weight more recent accesses more highly than less recent accesses are also possible. A wide variety of other methods for computing H are possible within the spirit and scope of the invention.  
         [0063]      FIG. 7  depicts a flow diagram illustrating a method for balancing load in accordance with an embodiment of the invention. In step  70 , load information is maintained. This step typically is continuously executed. There are a number of ways to maintain load information. For example, load statistics H may be maintained for data objects or structures which are stored on a node. One method of estimating load on a node is via H values. For example, the estimated load on a node might be the sum of the H values of data structures residing on the node.  
         [0064]     There are other methods of estimating load as well. For example, CPU or other resources (e.g., I/O resources, storage, and network bandwidth) could be monitored to estimate load.  
         [0065]     The first time step  70  is invoked (for example, when the system is first started up), estimates of past H values may be used to perform an initial load balancing in which the sum of H values for data stored on the same node are roughly equivalent across different nodes.  
         [0066]     In step  72 , the system determines that a node n 1  has become overloaded.  
         [0067]     In step  74 , data is transferred from n 1  to one or more less loaded nodes to reduce the overload on node n 1 . If H values are being maintained, then the H values can be used to determine how much data to transfer, just as in the example previously given corresponding to  FIG. 6 .  
         [0068]     The methodology depicted in  FIG. 7  can easily be generalized to transfer load from multiple nodes using a single application of steps  72  and  74 .  
         [0069]     Although the detailed description of preferred embodiments so far has been presented within the context of a trading system for electronic marketplaces, the techniques are applicable to load balancing across a wide variety of other domains. The method for load balancing depicted in  FIG. 7  can be applied to a broad range of parallel applications including ones not having anything to do with electronic marketplaces. The assignment of H values is also applicable to a broad range of data structures in addition to order books. In situations where other data structures are used, H values may be correlated with how frequently the data structures are accessed. The techniques disclosed for partitioning order books can be applied to other data structures in other domains as well.  
         [0070]     We now describe another method for partitioning by price levels.  
         [0071]      FIG. 8  illustrates shows a method for partitioning the orders ( 81 - 2 ,  81 - 3 ,  81 - 4 ) of a single book ( 81 - 1 ) which is an alternate to the partitioning by price range illustrated in  FIG. 2 . In this approach, individual price levels are assigned to nodes using a function. We show, as an example, the case where all orders whose price level in dollars is exactly divisible by 3 (such orders being denoted as  81 - 2 ) are assigned to node  1  ( 80 - 1 ), all orders whose price level in dollars is congruent to 1 modulo  3  (such orders being denoted as  81 - 3 ) are assigned to node  4  ( 80 - 2 ), and all orders whose price level in dollars is congruent to 2 modulo  3  (such orders being denoted as  81 - 4 ) are assigned to node  5  ( 80 - 3 ). This method is clearly extensible to work with varying numbers of nodes and alternative hashing or other functions on the price level of orders.  
         [0072]     A benefit of this partitioning method relative to the method in  FIG. 2  is that, since the highest price resting order to buy on a book is often one tick value below the lowest price resting order to sell, active trading is likely to be occurring at two adjacent tick levels. With a price level partitioning as described here, this is likely to lead to at least two nodes being involved in active trading. The third node in the example here will be active in accepting orders outside the active trading range and will also become involved in active trading as soon as there is a price movement to a value adjacent to the current trading prices.  
         [0073]     However, relative to the range based partitioning illustrated in  FIG. 2 , partitioning as per  FIG. 8  will result in more frequent transfers of active trading responsibility between nodes causing more frequent cross-node synchronizations of order processing. In situations where cross-node synchronization can be done efficiently and good load balancing across multiple nodes is required, this partitioning method may be preferable.  
         [0074]     Referring to  FIG. 9 , a computing system is illustrated in accordance with which one or more components/steps of an electronic trading system (e.g., components and methodologies described in the context of  FIGS. 1 through 8  above, and  FIGS. 10 and 11  below) may be implemented, according to an embodiment of the present invention. It is to be understood that the individual components/steps may be implemented on one such computer system, or more preferably, on more than one such computer system. In the case of an implementation on a distributed computing system, the individual computer systems and/or devices may be connected via a suitable network, e.g., the Internet or World Wide Web. However, the system may be realized via private or local networks. The invention is not limited to any particular network.  
         [0075]     Thus, the computing system shown in  FIG. 9  may represent an illustrative architecture for a computing system associated with an electronic trading system. For example, the computing system in  FIG. 9  may be the computing system that performs the steps illustrated in the context of  FIGS. 3, 5  and  7  (as well as any applicable steps discussed in the context of  FIGS. 1, 2 ,  4 ,  6 ,  8  and  10 ). Also, the computing system in  FIG. 9  may represent the computing architecture for each of the nodes upon which order books (and partitions thereof) are maintained.  
         [0076]     As shown, the computing system may be implemented in accordance with a processor  90 , a memory  92 , I/O devices  94 , and a network interface  96 , coupled via a computer bus  98  or alternate connection arrangement.  
         [0077]     It is to be appreciated that the term “processor” as used herein is intended to include any processing device, such as, for example, one that includes a CPU (central processing unit) and/or other processing circuitry. It is also to be understood that the term “processor” may refer to more than one processing device and that various elements associated with a processing device may be shared by other processing devices.  
         [0078]     The term “memory” as used herein is intended to include memory associated with a processor or CPU, such as, for example, RAM, ROM, a fixed memory device (e.g., hard drive), a removable memory device (e.g., diskette), flash memory, etc.  
         [0079]     In addition, the phrase “input/output devices” or “I/O devices” as used herein is intended to include, for example, one or more input devices (e.g., keyboard, mouse, etc.) for entering data to the processing unit, and/or one or more output devices (e.g., speaker, display, etc.) for presenting results associated with the processing unit.  
         [0080]     Still further, the phrase “network interface” as used herein is intended to include, for example, one or more transceivers to permit the computing system of  FIG. 9  to communicate with another computing system (e.g., a node of the electronic trading system) via an appropriate communications protocol.  
         [0081]     Accordingly, software components including instructions or code for performing the methodologies described herein may be stored in one or more of the associated memory devices (e.g., ROM, fixed or removable memory) and, when ready to be utilized, loaded in part or in whole (e.g., into RAM) and executed by a CPU.  
         [0082]     Note that the above techniques can be generalized to a wide variety of cases in which an electronic system is used to sell items and customers are placing bids at different values. In accordance with principles of the invention, an electronic sales system may be scaled to run on multiple nodes. Different nodes handle different price values. In some cases, an entire range of prices may be assigned to a single node. Requests are then directed to different nodes based on a price associated with a request.  
         [0083]     The prices assigned to different nodes may be selected to evenly distribute load across the nodes.  
         [0084]     As another example, data may be associated with different prices. The data can be distributed across multiple nodes of a system based on price. While embodiments described above use examples of order book data, other kinds of information may also be distributed across multiple nodes.  
         [0085]     As yet another example, a computer system might have multiple nodes. Numbers may be assigned to nodes of the system. In some cases, an entire range of numbers may be assigned to a node. Requests and/or tasks also have numbers associated with them. An individual request or task is assigned to an appropriate node based on the number of the request or task. In some cases, the request or task may cause data to be stored on the correct node based on the number.  
         [0086]      FIG. 10  is a flow diagram illustrating such a method. In step  100 , a number is associated with a request. The number could represent a price or something else. In step  101 , the request is routed to a node based on its number. In step  102 , the node handles the request. This step may optionally cause information to be stored on the node.  
         [0087]      FIG. 11  is a block diagram illustrating how numbers may be assigned to nodes. As shown,  11 - 1 ,  11 - 2 , and  11 - 3  represent three nodes. Initially, numbers  1 - 10  are assigned to node  1  ( 11 - 1 ), numbers  11 - 20  are assigned to node  2  ( 11 - 2 ), and numbers  21 - 30  are assigned to node  3  ( 11 - 3 ). The initial assignment is preferably done in a manner which balances load across the nodes.  
         [0088]     If node  2  becomes overloaded (and/or there is a change in workload), it may become desirable to reassign numbers to nodes. This re-assignment should preferably be done in a fashion which balances load across the nodes.  
         [0089]     In  FIG. 11 , after node  2  ( 11 - 2 ) becomes overloaded, dynamic reassignment of numbers occurs so that fewer numbers are assigned to node  2  ( 11 - 2 ). In the new assignment, numbers  1 - 12  are assigned to node  1  ( 11 - 1 ), numbers  13 - 18  are assigned to node  2  ( 11 - 2 ), and numbers  19 - 30  are assigned to node  3  ( 11 - 3 ).  
         [0090]     Although illustrative embodiments of the present invention have been described herein with reference to the accompanying drawings, it is to be understood that the invention is not limited to those precise embodiments, and that various other changes and modifications may be made by one skilled in the art without departing from the scope or spirit of the invention.