EP1314284A4

EP1314284A4 - Automatically configurable telecommunications switching network

Info

Publication number: EP1314284A4
Application number: EP01984284A
Authority: EP
Inventors: Charles J Breidenstein; Eugene H Kohlmeer
Original assignee: Redcom Laboratories Inc
Current assignee: Redcom Laboratories Inc
Priority date: 2000-07-17
Filing date: 2001-07-17
Publication date: 2009-08-19
Also published as: EP1314284A2; AU2002222972A1; JP2004519872A; WO2002007331A3; WO2002007331A2

Abstract

A system for automatically configuring call routing tables of the switching units of a telephone switching network having a multiplicity of nodes (1-7) connected by trunks wherein signaling messages are sent periodically on the trunks (A-G) to inform connected nodes (1-7) of the network topology, to enable trunk groups to be create, and to create network routing tables. Calls can then be routed through the network based upon a dialed address, which address is later converted to routing digits based upon the routing configurations stored in the routing tables. The configuration is periodically updated thereby eliminating the need for manual administration.

Description

Automatically Configurable Telecommunications Switching Network

Description

The present invention relates to telecommunications switching systems and particularly a switching network of switching units connected by trunks which is automatically self configuring for routing calls between ports connected to the units.

The invention is especially suitable for use with modular switching units described in "Gueldenpfennig et al." US Patent 4,228,536 and "Breidenstein, et al." US Patent 4,229,816. These patents disclose a time-division digital communication system that is primarily used as a telephone switching system characterized by an especially attractive cost/port behavior at small port sizes due to its modular, distributed architecture. This telephone switching system is known as the IGX (Integrated Services Digital Network Gateway eXchange).

These IGX systems have been applied to many types of networks including fixed and mobile tactical military installations. Configuration of these military systems in particular presents several challenges to rapid "in-theatre" deployment. The configuration process involves creating an extensive database within the switching system for routing of calls within the network (trunk routing). Only when this database is constructed at each site, or network node, can calls be properly routed through that node. Complicating this is the need for trained personnel at each node and the difficulty of doing this work "under fire" . Tactical network topologies are also by nature very dynamic, with nodes disappearing and reappearing again, possibly at different locations within the network.

The present invention provides a system (method and apparatus) for making such networks essentially self-configuring so that minimal on-site configuration (ADMINistration) is needed to make the node capable of routing calls through the network. The invention permits each individual node of a network to determine its location within the network automatically; building trunk routing tables to permit network- wide call routing. This is implemented through software algorithms that reside within the switching system control software in addition to the control software already provided in such systems for processing of calls.

Briefly described, a system according to the invention sends information out periodically from each node on every one of its trunks (circuits which interconnect nodes), giving information about the local node and any nodes it has learned about. This information is likewise received periodically by each node and used to update its local information about the network. This updated information will then be sent out when the next generation of updates takes place. Eventually each node will have learned the entire network topology and routing of calls to all parts of the network will be possible. Since the updating process continues, any changes in network topology will be picked up automatically, resulting in a "self-healing" network. The invention is implemented in software algorithms or programs which process the data effecting a self-configuring of the network.

The foregoing and other features of the invention will become more apparent from the following description when read in connection with the accompanying drawings in which:

FIG. 1 is a block diagram of a switching unit used in each node of a telecommunications network embodying the invention;

FIG. 2 is a more detailed block diagram of the memories of the unit shown in FIG. 1 ;

FIG. 3 is an exemplary network of nodes each of which may be a unit of the type shown in FIGs. 1 & 2.

FIG. 4 shows a modification of the network of FIG. 3.

FIG. 3 shows individual nodes 1 to 7 of an IGX network. The system enables each node to determine its location within the network automatically, building trunk routing tables to permit network-wide call routing. The goal is to minimize, if not eliminate all trunk ADMIN related to network routing.

Each IGX node (separate switch) needs to acquire a unique node number. The node number uniquely identifies the node within the network and may act as an office code for the purposes of network routing.

For each of its ATRC (Automatic Trunk Route Configuration) trunks, an IGX node must be able to determine the node number sub-tree of the IGX network segment to which that trunk is connected. In order to avoid the complications which trunk group splitting and grooming would introduce, each trunk will be considered alone; in effect there are no predetermined trunk groups in this scheme. Furthermore, the trunk line and register signaling must be channel-associated so that the destination of a trunk can be determined unambiguously by digits received over that trunk. This does not preclude the use of alternate signaling systems, such as a Primary Rate (PRI) ISDN signaling system if the facility is treated atomically.

Once a node number sub-tree has been determined for a trunk, that trunk must be added to a dynamically created trunk group whose members share identical node number subtrees. The destination node numbers comprising a trunk group's sub-tree permit selection of a trunk in that group by the IGX when routing calls to those nodes.

Calls can then be deterministically routed throughout the network based upon a dialed address consisting of node number followed by station number. This is converted to routing digits and the call proceeds to its destination. Exemplary node number and digit assignments for the FIG. 3 networks are given in the following table:

Example network:

Consider the obtaining of a unique node number

There are several means by which a node can obtain a unique node number. One method is to derive the node number from the shelf zero's system controller board serial number (this is a circuit board containing a serial number which can be read by system software, and is always present in an IGX node), and somehow reduce it to a "small" unique number. The node number should be small since it is used for routing and forms the initial address digits of station numbers.

This method, although attractive since it requires no ADMIN, seems unworkable in the real world. If a controller board set in a working site is replaced for any reason, all phone numbers in that node will change. Furthermore, there is no way to prepare a telephone directory in advance when serial numbers are used. It seems that node numbers need to be ADMINed on-site in order to be workable. The IGX currently has a "network" number defined in the database. It is typically set to zero, but could easily serve as the node number.

Consider the determining of Node Number Sub-trees

Determining the node number sub-trees requires each node of a network to perform three tasks simultaneously and continuously.

First, each local ATRC trunk must periodically send the local node number sub-tree to its remote peer. When received by the remote node this becomes the remote node number subtree for this ATRC trunk, replacing any existing one stored for that trunk. Initially the local node number sub-tree sent is just the local node number itself.

Second, each node must merge the remote node number sub-trees received from all ATRC trunks and append the result to the node number of this node. This then becomes the single local node number sub-tree for this node. This process must include pruning to eliminate any sub-trees that include the local node to prevent circular ("ring-around-the-rosy") patterns.

Third, each local ATRC trunk must periodically receive a remote node number sub-tree from its remote peer, store it, and associate it with the trunk.

The above 3 steps must be repeated continuously, since the first node number sub-trees sent will only contain a single remote node number. Only after the second round of messages will the next level of connecting nodes be included, and so on. Eventually, the entire network topology will be reflected in the set of remote node number sub-trees received on all ATRC trunks in a given node. In order to help describe (and then implement) algorithms for this dynamic routing method, a notation for the representation of node number sub-trees will be adopted. A node number subtree can be formally defined as either a single node number, or as a single node number followed by a list of one or more node number sub-trees separated by commas and enclosed in (). This recursive definition in Bachus-Naur Form (BNF) can be given as:

nnst :: = { nodejαumber | node_number ( nst [, nnst]... ) }

Some valid node number sub-trees in this notation are:

12 12(4,6,7) 12(4,6(2),7) 12(4,6(2,3(9,8,11)),7)

Using this notation, the iterative process of sending, receiving and processing node number sub-trees will be described. (This simple example is not the example network given previously.)

1) Just after a node boots, it will clear the node number sub-trees for all its

ATRC trunks, and determine its local node number (say 5), which becomes the initial value of that node's local node number sub-tree.

2) The local node number sub-tree is sent out on all ATRC trunks. 3) The remote nodes associated with these trunks receive and store this node number sub-tree, associating it with the respective trunk on which it was received. The following value will be stored:

4) At the same time, local node 5 will be receiving node number sub-trees from its ATRC trunks, and storing them as described in (3). Assume local node 5 receives the following node number sub-trees on its (say 3) ATRC trunks:

Trunk A: 4 Trunk B: 7 Trunk C: 8

5) The merge process will then update the local node number sub-tree for node 5 by appending the sub-trees just received to the local node number resulting in:

Old local node number sub-tree: 5 New local node number sub-tree: 5(4,7,8)

6) Go to (2).

Routing of calls can begin immediately based upon the current node number sub-trees. After this process has iterated a number of times (dependent on the network size and topology), the local node sub-trees will have stabilized, and then can be used to route to any portion of the network. Trunks whose stored node number sub-trees are identical are placed into a dynamic group, and any node whose number appears in the node number sub-tree associated with that group is known to be reachable from a trunk in this group. Furthermore, the number of "(" traversed before finding a node number when scanning left to right within the node number sub-tree, indicates the number of hops to that node. This hops count can be used to judge the relative cost of a particular route in order to choose the optimal route when alternatives exist.

Since the process of sending, receiving, merging, sending, etc. occurs continuously, any trunk re-arrangements, network outages or network additions are picked up automatically, creating a truly self-configuring network requiring little or no ADMIN.

As mentioned before, pruning of the local node number sub-tree is required in order to prevent creation of circular ("ring-around-the-rosy") patterns. This is accomplished by not including in the local node number sub-tree any sub-trees that begin with the local node number.

An example showing the evolution of the local node number sub-trees for the network diagramed earlier will serve to illustrate the entire process. Generation 0 is the initial condition in which the local node number sub-tree is set to the local node number. Generation 0

Node l Local Sub-tree: 1 Trunk 1A Trunk Sub-tree: Trunk IB Trunk Sub-tree: Trunk 1C Trunk Sub-tree: Node 2 Local Sub-tree: 2 Trunk 2A Trunk Sub-tree: Node 3 Local Sub-tree: 3 Trunk 3C Trunk Sub-tree: Trunk 3D Trunk Sub-tree: Node 4 Local Sub-tree: 4 Trunk 4B Trunk Sub-tree: Trunk 4E Trunk Sub-tree: Trunk 4F Trunk Sub-tree: Node 5 Local Sub-tree: 5

Trunk 5D Trunk Sub-tree:

Trunk 5E Trunk Sub-tree:

Node 6 Local Sub-tree: 6

Trunk 6F Trunk Sub-tree:

Trunk 6G Trunk Sub-tree:

Node 7 Local Sub-tree: 7

Trunk 7G Trunk Sub-tree:

Generation 1

Node l Local Sub-tree: 1(2,4,3)

Trunk 1A Trunk Sub-tree: 2

Trunk IB Trunk Sub-tree: 4

Trunk 1C Trunk Sub-tree: 3

Node 2 Local Sub-tree: 2(1)

Trunk 2A Trunk Sub-tree: 1

Node 3 Local Sub-tree: 3(1,5)

Trunk 3C Trunk Sub-tree: 1

Trunk 3D Trunk Sub-tree: 5

Node 4 Local Sub-tree: 4(1,5,6)

Trunk 4B Trunk Sub-tree: 1

Trunk 4E Trunk Sub-tree: 5

Trunk 4F Trunk Sub-tree: 6

Node 5 Local Sub-tree: 5(3,4)

Trunk 5D Trunk Sub-tree: 3

Trunk 5E Trunk Sub-tree: 4

Node 6 Local Sub-tree: 6(4,7)

Trunk 6F Trunk Sub-tree: 4 Trunk 6G Trunk Sub-tree: 7

Node 7 Local Sub-tree: 7(6)

Trunk 7G Trunk Sub-tree: 6

Generation 2

Node l Local Sub-tree: 1(2,4(5,6),3(5))

Trunk 1A Trunk Sub-tree: 2(1)

Trunk IB Trunk Sub-tree: 4(1,5,6)

Trunk 1C Trunk Sub-tree: 3(1,5)

Node 2 Local Sub-tree: 2(1(4,3))

Trunk 2A Trunk Sub-tree: 1(2,4,3)

Node 3 Local Sub-tree: 3(1(2,4),5(4))

Trunk 3C Trunk Sub-tree: 1(2,4,3)

Trunk 3D Trunk Sub-tree: 5(3,4)

Node 4 Local Sub-tree: 4(1(2,3),5(3),6(7))

Trunk 4B Trunk Sub-tree: 1(2,4,3)

Trunk 4E Trunk Sub-tree: 5(3,4)

Trunk 4F Trunk Sub-tree: 6(4,7)

Node 5 Local Sub-tree: 5(3(1),4(1,6))

Trunk 5D Trunk Sub-tree: 3(1,5)

Trunk 5E ^' Trunk Sub-tree: 4(1,5,6)

Node 6 Local Sub-tree: 6(4(1,5),7)

Trunk 6F Trunk Sub-tree: 4(1,5,6)

Trunk 6G Trunk Sub-tree: 7(6)

Node 7 Local Sub-tree: 7(6(4))

Trunk 7G Trunk Sub-tree: 6(4,7)

Generation 3 Node l Local Sub-tree: 1(2,4(5(3),6(7)),3(5(4))) Trunk 1A Trunk Sub-tree: 2(1(4,3)) Trunk IB Trunk Sub-tree: 4(1(2,3),5(3),6(7)) Trunk 1C Trunk Sub-tree: 3(1(2,4),5(4)) Node 2 Local Sub-tree: 2(1(4(5,6),3(5))) Trunk 2A Trunk Sub-tree: 1(2,4(5,6),3(5)) Node 3 Local Sub-tree: 3(1(2,4(5,6)),5(4(1,6))) Trunk 3C Trunk Sub-tree: 1(2,4(5,6),3(5)) Trunk 3D Trunk Sub-tree: 5(3(1),4(1,6)) Node 4 Local Sub-tree: 4(1(2,3(5)),5(3(1)),6(7)) Trunk 4B Trunk Sub-tree: 1(2,4(5,6),3(5)) Trunk 4E Trunk Sub-tree: 5(3(1),4(1,6)) Trunk 4F Trunk Sub-tree: 6(4(1,5),7) Node 5 Local Sub-tree: 5(3(1(2,4)),4(1(2,3),6(7))) Trunk 5D Trunk Sub-tree: 3(1(2,4),5(4)) Trunk 5E Trunk Sub-tree: 4(1(2,3),5(3),6(7)) Node 6 Local Sub-tree: 6(4(1(2,3),5(3)),7) Trunk 6F Trunk Sub-tree: 4(1(2,3),5(3),6(7)) Trunk 6G Trunk Sub-tree: 7(6(4)) Node 7 Local Sub-tree: 7(6(4(1,5))) Trunk 7G Trunk Sub-tree: 6(4(1,5),7)

Generation 4

Node 1 Local Sub-tree: 1(2,4(5(3),6(7)),3(5(4(6))))

Trunk 1A Trunk Sub-tree: 2(1(4(5,6),3(5)))

Trunk IB Trunk Sub-tree: 4(1(2,3(5)),5(3(1)),6(7))

Trunk 1C Trunk Sub-tree: 3(1(2,4(5,6)),5(4(1,6))) Node 2 Local Sub-tree: 2(1(4(5(3),6(7)),3(5(4))))

Trunk 2A Trunk Sub-tree: 1(2,4(5(3),6(7)),3(5(4)))

Node 3 Local Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))))

Trunk 3C Trunk Sub-tree: 1(2,4(5(3),6(7)),3(5(4)))

Trunk 3D Trunk Sub-tree: 5(3(1(2,4)),4(1(2,3),6(7)))

Node 4 Local Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7))

Trunk 4B Trunk Sub-tree: 1(2,4(5(3),6(7)),3(5(4)))

Trank 4E Trunk Sub-tree: 5(3(1(2,4)),4(1(2,3),6(7)))

Trunk 4F Trunk Sub-tree: 6(4(1(2,3),5(3)),7)

Node 5 Local Sub-tree: 5(3(1(2,4(6))),4(1(2,3),6(7)))

Trunk 5D Trunk Sub-tree: 3(1(2,4(5,6)),5(4(1,6)))

Trunk 5E Trunk Sub-tree: 4(1(2,3(5)),5(3(1)),6(7))

Node 6 Local Sub-tree: 6(4(1(2,3(5)),5(3(1))),7)

Trunk 6F Trunk Sub-tree: 4(1(2,3(5)),5(3(1)),6(7))

Trunk 6G Trunk Sub-tree: 7(6(4(1,5)))

Node 7 Local Sub-tree: 7(6(4(1(2,3),5(3))))

Trunk 7G Trunk Sub-tree: 6(4(1(2,3),5(3)),7)

Generation 5

Node 1 Local Sub-tree: 1(2,4(5(3),6(7)),3(5(4(6(7)))))

Trunk 1A Trunk Sub-tree: 2(1(4(5(3),6(7)),3(5(4))))

Trunk IB Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7))

Trunk 1C Trunk Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))))

Node 2 Local Sub-tree: 2(1(4(5(3),6(7)),3(5(4(6)))))

Trunk 2A Trunk Sub-tree: 1(2,4(5(3),6(7)),3(5(4(6))))

Node 3 Local Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))))

Trunk 3C Trunk Sub-tree: 1(2,4(5(3),6(7)),3(5(4(6))))

Trunk 3D Trunk Sub-tree: 5(3(1(2,4(6))),4(1(2,3),6(7))) Node 4 Local Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7))

Trunk 4B Trunk Sub-tree: 1(2,4(5(3),6(7)),3(5(4(6))))

Trunk 4E Trunk Sub-tree: 5(3(1(2,4(6))),4(1(2,3),6(7)))

Trunk 4F Trunk Sub-tree: 6(4(1(2,3(5)),5(3(1))),7)

Node 5 Local Sub-tree: 5(3(1(2,4(6(7)))),4(1(2,3),6(7)))

Trunk 5D Trunk Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))))

Trunk 5E Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7))

Node 6 Local Sub-tree: 6(4(1(2,3(5)),5(3(1(2)))),7)

Trunk 6F Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7))

Trunk 6G Trunk Sub-tree: 7(6(4(1(2,3),5(3))))

Node 7 Local Sub-tree: 7(6(4(1(2,3(5)),5(3(1)))))

Trunk 7G Trunk Sub-tree: 6(4(1(2,3(5)),5(3(1))),7)

Generation 6

Node 1 Local Sub-tree: 1(2,4(5(3),6(7)),3(5(4(6(7)))))

Trunk 1A Trunk Sub-tree: 2(1(4(5(3),6(7)),3(5(4(6)))))

Trunk IB Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7))

Trunk 1C Trunk Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))))

Node 2 Local Sub-tree: 2(1(4(5(3),6(7)),3(5(4(6(7))))))

Trunk 2A Trunk Sub-tree: 1(2,4(5(3),6(7)),3(5(4(6(7)))))

Node 3 Local Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))))

Trunk 3C Trunk Sub-tree: 1(2,4(5(3),6(7)),3(5(4(6(7)))))

Trunk 3D Trunk Sub-tree: 5(3(1(2,4(6(7)))),4(1(2,3),6(7)))

Node 4 Local Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7))

Trunk 4B Trunk Sub-tree: 1(2,4(5(3),6(7)),3(5(4(6(7)))))

Trunk 4E Trunk Sub-tree: 5(3(1(2,4(6(7)))),4(1(2,3),6(7)))

Trunk 4F Trunk Sub-tree: 6(4(1(2,3(5)),5(3(1(2)))),7)

Node 5 Local Sub-tree: 5(3(1(2,4(6(7)))),4(1(2,3),6(7))) Trunk 5D Trunk Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))))

Trunk 5E Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7))

Node 6 Local Sub-tree: 6(4(1(2,3(5)),5(3(1(2)))),7)

Trunk 6F Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7))

Trunk 6G Trunk Sub-tree: 7(6(4(1(2,3(5)),5(3(1)))))

Node 7 Local Sub-tree: 7(6(4(1(2,3(5)),5(3(1(2))))))

Trunk 7G Trunk Sub-tree: 6(4(1(2,3(5)),5(3(1(2)))),7)

Note that succeeding generations will produce unchanging local node number sub-trees unless the network configuration changes due to the appearance of new node(s) or loss of existing node(s).

Although the amount of data which needs to be sent grows with the network size, this should not present a problem if high-speed sending techniques are used (such as a Primary Rate ISDN (Integrated Services Digital Network) "D" channel). Moreover, there are significant advantages to having each node possess the entire network topology:

1) Each node is aware of the entire network, so that local action can be taken if a distant node becomes unreachable. For example, if a critical resource exists in a node that has become unreachable, a local alert can be given.

2) The physical hops count to any node is easily determined and can be used to guide alternate routing.

3) Network routing is always deterministic, and unless node(s) have recently become unreachable, there will be no futile routing attempts.

Consider adding trunks to a dynamically created trunk group ATRC trunks which share identical node number sub-trees are placed into a dynamic group since these trunks are known to share a common destination. This process also involves creation of digit tables for each known node in the network. These digit tables point to the dynamic trunk group with the most direct (as determined by hops count) route to the destination node, with alternate routing (if desired) to other dynamic trunk groups whose hops count to the destination node is higher.

In creating these dynamic trunk groups, it is necessary only to compare the leftmost node number of the trunk's node number sub-tree to determine proper group membership, since thai number represents the node to which the trunk is connected. This also prevents spurious trunk groups from being created as the result of a trunk having more recent sub-tree information, even though the trunk leads to the same destination node. In this scheme, the node number sub-tree stored with the dynamic group will be the longest one received on any of the group members, since a longer sub-tree contains more information.

The creation of these groups and digit tables can supplement the existing system administrative facilities rather than replace them, so that the overall system operation remains consistent and predictable. This feature should be treated conceptually as a layer above ADMN.

The ATRC program is integrated within the switching system architecture

For reference, Fig. l depicts the preferred embodiment, a telephone switching system which may be a time-division digital communication system as taught in "Gueldenpfennig et al." US Patent 4,228,536 and "Breidenstein, et al." US Patent 4,229,816. It should be noted, however, that the ATRC system of the present invention in no way relies on the specific system architecture, except to the extent that a central processing unit (CPU or Microprocessor) is assumed to exist. There is a Switching Matrix providing for Voice/Data switching between a plurality of Trunk Circuits. These Trunk Circuits connect externally to the adjacent nodes of a communications network which consists of these nodes as network elements. Both the Switching Matrix and Trunk Circuits connect with and are controlled by the System Controller through its Input/Output Interfaces. The System Controller in turn consists of, in addition to these Input/Output Interfaces, a Central Processing Unit (CPU) which may be a Microprocessor, and its associated Read-Only and Read/Write Memory. The Read-Only Memory contains the control programs for directing the CPU in performing call processing tasks. The Read/Write memory contains scratchpad areas for temporary storage of transient data associated with calls in progress, database routing tables for determining the routing of calls, buffers for holding data prior to input or output, and other data which may change over time. The distinction between Read-Only and Read/Write Memory is functional only, and may not be reflected in the types of memory actually used in the system. For example, all memory could be of the Read/ Write type, but the control program storage portion of that memory would by convention not be written into after an initial program load operation had taken place.

Fig.2 expands on the memory allocation by showing the additional requirements when the ATRC functions are integrated into the system. In the Read-Only area, there is a special ATRC task. This task embodies the algorithms which are the subject of the present invention. Normally a Task Scheduler passes control as required to the Normal Call Processing Tasks which already exist in the system for performing the required call processing functions. The addition of the Special ATRC Task requires that the Scheduler pass control to that task on a regular basis so that it may perform its functions. These functions consist of sending out the local node number sub-tree on all ATRC trunks to other network nodes, receiving and processing the incoming sub-trees on ATRC trunks from other network nodes, determining ATRC trunk groups and the routing digit sets for those groups, and finally writing the ATRC route translations back into the Read/Write Memory reserved for this purpose within the route translation database portion. This memory area is shown in Fig.2 with an arrow linking it to the Special ATRC Task, since that memory is controlled by that task.

Routing of calls is accomplished as follows: It might appear that one could simply send the destination node number and station number, and the call could be routed at intermediate nodes simply by choosing a trunk that leads most directly to that destination. That method would in fact work in the example network (FIG. 3) if one additional rule were added: never route back out on the same trunk group on which the call arrived. For a call from node 2 to node 5 for example, if the call reaches node 3 via node 1 and all "D" trunk are busy, this rule prevents routing back to node 1 in an effort to reach node 5 via node 4.

However, if the example network is modified by the addition of a trunk "H" between nodes 3 and 4, this simple rule fails. A call from node 2 to node 5 encountering an all "D" and "E" trunks busy condition can now be routed circularly from nodes 1 to 3 to 4 to 1 to 3 to 4, etc. This pathologic behavior results from using local routing information at the intermediate nodes, instead of routing information from the originating node. Use of routing information from the originating node takes into account the preceding path taken by the call through the network.

The solution is to send routing information (a routing digit set) from the originating end and use that information at any intermediate nodes. This routing digit set is derived from the local node number sub-tree in the originating node and from the destination node number. For reference, here is the complete final state of the node number sub-trees for the modified example network:

Generation 6 (with trunk H added between nodes 3 and 4)

Node 1 Local Sub-tree: 1(2,4(5(3) ,6(7) ,3(5)) ,3(5(4(6(7))) ,4(5 ,6(7))))

Trunk 1A Trunk Sub-tree: 2(1(4(5(3),6(7),3(5)),3(5(4(6)),4(5,6(7)))))

Trunk IB Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7),3(1(2),5))

Trunk 1C Trunk Sub-tree: 3(1 (2,4(5,6(7))), 5 (4(1 (2), 6(7))), 4(1 (2), 5,6(7))) Node 2 Local Sub-tree: 2(1(4(5(3),6(7),3(5)),3(5(4(6(7))),4(5,6(7)))))

Trunk 2A Trunk Sub-tree: 1(2,4(5(3),6(7),3(5)),3(5(4(6(7))),4(5,6(7))))

Node 3 Local Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))),4(1(2),5,6(7)))

Trunk 3C Trunk Sub-tree: 1(2,4(5(3),6(7),3(5)),3(5(4(6(7))),4(5,6(7))))

Trunk 3D Trunk Sub-tree: 5(3(1(2,4(6(7))),4(1(2),6(7))),4(1(2,3),6(7),3(1(2))))

Trunk 3H Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7),3(1(2),5))

Node 4 Local Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7),3(1(2),5))

Trunk 4B Trunk Sub-tree: 1(2,4(5(3),6(7),3(5)),3(5(4(6(7))),4(5,6(7))))

Trunk 4E Trank Sub-tree: 5(3(1(2,4(6(7))),4(1(2),6(7))),4(1(2,3),6(7),3(1(2))))

Trunk 4F Trunk Sub-tree: 6(4(1(2,3(5)),5(3(1(2))),3(1(2),5)),7)

Trunk 4H Trunk Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))),4(1(2),5,6(7)))

Node 5 Local Sub-tree: 5(3(1(2,4(6(7))),4(1(2),6(7))),4(1(2,3),6(7),3(1(2))))

Trunk 5D Trunk Sub-tree: 3(1(2,4(5,6(7))),5(4(1(2),6(7))),4(1(2),5,6(7)))

Trunk 5E Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7),3(1(2),5))

Node 6 Local Sub-tree: 6(4(1(2,3(5)),5(3(1(2))),3(1(2),5)),7)

Trunk 6F Trunk Sub-tree: 4(1(2,3(5)),5(3(1(2))),6(7),3(1(2),5))

Trunk 6G Trunk Sub-tree: 7(6(4(1(2,3(5)),5(3(1)),3(1(2),5))))

Node 7 Local Sub-tree: 7(6(4(1(2,3(5)),5(3(1(2))),3(1(2),5))))

Trunk 7G Trunk Sub-tree: 6(4(1(2,3(5)),5(3(1(2))),3(1(2),5)),7)

For a call from node 2 to node 5, the node number sub-tree for node 2 is required:

2(1(4(5(3),6(7),3(5)),3(5(4(6(7))),4(5,6(7)))))

From this sub-tree and the destination node (5), the following routing digit set can be derived:

(2145, 21435, 2135, 21345)

This routing digit set gives all possible routes from node 2 to node 5, and this complete set of digits must be sent out by node 2, (followed of course by the station number) as the address digits for this call. On receiving a call in this scheme, a node will use the next node number in the digit sub-string to choose an outgoing dynamic trunk group, taking into account the length of the sub-string as an indication of the most direct route. The call is then routed to a trunk in that group if possible, and the routing digit set sent consists of the digits remaining in sub-strings having the chosen node after deleting the routing digits already used. An example will clarify:

At node 2, we have:

(2145, 21435, 2135, 21345)STN

Node 2 being the originating node, removes its node number before proceeding, leaving:

(145, 1435, 135, 1345)STN

Node 2 then uses the next digit (1) to choose an outgoing trunk group. There is no choice in this case, so a trunk to node 1 is chosen, and the following routing digit set is sent to node 1:

(45, 435, 35, 345)STN

Node 1 then uses the next digit (4) or (3) to choose an outgoing trunk group. Both sets of strings have the same length and so the routes have the same priority. Node 1 chooses a trunk to node 4, and the following routing digit set is sent to node 4: (5, 35)STN

Node 4 then uses the next digit (5) or (3) to choose an outgoing trunk group. Sub-string (5) is shorter than (35), so the direct route to node 5 has priority. But let us assume that all trunks in that dynamic group are busy. Node 4 will then chose a trunk to node 3, and the following routing digit set is sent to node 3:

(5)STN

Node 3 then uses the next digit (5) to choose an outgoing trunk group to node 5, and the following routing digit set is sent to node 5:

STN

Node 5 then routes the call to the station numbered STN. STN represents the station number or any other information required to properly identify the called address.

Algorithms for generating node number sub-trees and extracting routing digit sets from them have been incorporated into a network simulation program written in a structured BASIC language. The example node number generations and routing digit sets given above are in fact the output from that program. The program is given here, followed by a line-by-line description.

10 PRINT "Simulate network or run manual mode [S or M]";

20 INPUT LINE REPLY$

30 BIF LEFT(CVT$$(REPLY$,-1),1) = "M"

40 PRINT

50 WHILE 1

60 PRINT "Node number" ;

70 INPUT LINE NODE$

80 NODE$=CVT$$(NODE$,-l)

85 NODE_LEN=LEN(NODE$)

90 TREE$ = NODE$ + "("

100 PRINT

110 REPEAT

120 PRINT "Received node number sub-tree";

130 INPUT LINE STREE$

140 STREE$=CNT$$(STREE$,-1)

150 IF STREE$ = " " GO TO 180

160 TREES =TREE$+STREE$ + ","

170 UNTIL 0

180 TREES =LEFT(TREE$,LEN(TREE$)-1) + ")" 190 PRINT "Raw node number sub-tree: " ,, TREES

200 TREES =FNPRUNE$(TREE$)

210 PRINT "Pruned node number sub-tree: " ,TREE$

220 TREES =FNCLEANUP$(TREE$)

230 PRINT "Cleaned up node number sub-tree: " ,TREE$

240 PRINT

250 ENDWHILE

260 ELSE

270 NODE_l$ = " l "

275 NODE_LEN=LEN(NODE_l$)

280 NODE_2$= "2

290 NODE_3$= "3

300 NODE_4$= "4

310 NODE_5$ = "5

320 NODE_6$= "6

330 NODE_7$ = "7

340 GEN=0

350 REPEAT

360 STABLE = 1

370 PRINT

380 PRINT "Generation" ;GEN

390 PRINT

400 PRINT "Node 1 Local Sub-tree: ",NODE_l$

410 PRINT "Trunk 1 A Trunk Sub-tree: ",TRUNK_1_A$

420 PRINT "Trunk IB Trunk Sub-tree: ",TRUNK_1_B$

430 PRINT "Trunk IC Trunk Sub-tree :",TRUNK_1_C$

440 PRINT " Node 2 Local Sub-tree : " ,NODE_2$

450 PRINT "Trank 2A Trunk Sub-tree: ",TRUNK_2_A$

460 PRINT "Node 3 Local Sub-tree: ", NODE 3$ 470 PRINT "Trunk 3C Trunk Sub-tree : " ,TRUNK_3_C$

480 PRINT "Trunk 3D Trunk Sub-tree: ",TRUNK_3_D$

490 PRINT "Trunk 3H Trunk Sub-tree: " ,TRUNK_3_H$

500 PRINT "Node 4 Local Sub-tree: ",NODE_4$

510 PRINT "Trunk 4B Trunk Sub-tree: " ,TRUNK_4_B$

520 PRINT "Trunk 4E Trunk Sub-tree: " ,TRUNK_4_E$

530 PRINT "Trunk 4F Trunk Sub-tree: ",TRUNK_4_F$

540 PRINT "Trunk 4H Trunk Sub-tree: ",TRUNK_4_H$

550 PRINT "Node 5 Local Sub-tree: " ,NODE_5$

560 PRINT "Trunk 5D Trunk Sub-tree: ",TRUNK_5_D$

570 PRINT "Trank 5E Trunk Sub-tree :",TRUNK_5_E$

580 PRINT "Node 6 Local Sub-tree: ",NODE_6$

590 PRINT "Trunk 6F Trunk Sub-tree: " ,TRUNK_6_F$

600 PRINT "Trank 6G Trunk Sub-tree: ",TRUNK_6_G$

610 PRINT "Node 7 Local Sub-tree: ",NODE_7$

620 PRINT "Trunk 7G Trunk Sub-tree: ",TRUNK_7_G$

630 TRUNK_l_A$=NODE_2$

640 TRUNK_l_B$=NODE_4$

650 TRUNK_l_C$=NODE_3$

660 TRUNK_2_A$=NODE_l$

670 TRUNK_3_C$=NODE_l$

680 TRUNK_3_D$=NODE_5$

690 TRUNK_3_H$ = NODE_4$

700 TRUNK_4_B$=NODE_l$

710 TRUNK_4_E$=NODE_5$

720 TRUNK_4_F$ = NODE_6$

730 TRUNK_4_H$=NODE_3$

740 TRUNK_5_D$=NODE_3$

750 TRUNK 5 E$=NODE 4$ 760 TRUNK_6_F$ = NODE_4$

770 TRUNK_6_G$=NODE_7$

780 TRUNK_7_G$=NODE_6$

790

NNODE_l$=FNCLEANUP$("l(" +TRUNK_1_A$ + ", " +TRUNK_1_B$ + " , " +TRUNK_1_

C$+ ")")

800 NNODE_2$=FNCLEANUP$("2(" +TRUNK_2_A$+ ")")

810

NNODE_3$=FNCLEANUP$("3(" +TRUNK_3_C$ + "," +TRUNK_3_D$+ ", " +TRUNK_3_

H$+ ")")

820

NNODE_4$ = FNCLEANUP$( "4( " + TRUNK_4_B$ + " , " + TRUNK_4_E$ + " , " + TRUNK_4_

F$ + " , " +TRUNK_4_H$ + ") ")

830 NNODE 5S =FNCLEANUP$("5(" +TRUNK_5_D$ + " , " +TRUNK_5_E$ + ") ")

840 NNODE 6S =FNCLEANUP$("6(" +TRUNK_6_F$ + " , " +TRUNK_6_G$ + ")")

850 NNODE_7$ =FNCLEANUP$("7(" +TRUNK_7_G$ + ") ")

860 IF NNODE_l$ < > NODE_l$ THEN STABLE=0

870 IF NNODE 2S < > NODE_2$ THEN STABLE = 0

880 IF NNODE 3S < > NODE_3$ THEN STABLE = 0

890 IF NNODE 4S < > NODE_4$ THEN STABLE = 0

900 IF NNODE_5$ < > NODE 5S THEN STABLE = 0

910 IF NNODE_6$ < > NODE_6$ THEN STABLE=0

920 IF NNODE_7$ < > NODE_7$ THEN STABLE = 0

930 NODE_l$=NNODE_l$

940 NODE_2$=NNODE_2$

950 NODE_3$=NNODE_3$

960 NODE_4$=NNODE_4$

970 NODE_5$=NNODE_5$

980 NODE 6$= NNODE 6$ 990 NODE_7$=NNODE_7$

1000 GEN = GEN + 1

1010 UNTIL STABLE

1020 ENDIF

1030 PRINT

1040 PRINT "For Source Node 1 "

1050 PRINT " "

1060 X=FNROUTE(NODE_l$) 1070 PRINT "For Source Node 2"

1080 PRINT " "

1090 X=FNROUTE(NODE_2$) 1100 PRINT "For Source Node 3"

1110 PRINT " "

1120 X = FNROUTE(NODE_3$) 1130 PRINT "For Source Node 4"

1140 PRINT " "

1150 X=FNROUTE(NODE_4$) 1160 PRINT "For Source Node 5"

1170 PRINT " "

1180 X=FNROUTE(NODE_5$) 1190 PRINT "For Source Node 6"

1200 PRINT " "

1210 X=FNROUTE(NODE_6$) 1220 PRINT "For Source Node 7"

1230 PRINT " "

1240 X=FNROUTE(NODE_7$) 1250 GO TO 1860

1260 DEF FNCLEANUPS(NTREES) 1270 REPEAT 1280 TREES =NTREE$

1290

NTREES = FNREPL$(FNREPL$(FNREPL$(FNREPL$(FNPRUNE$(TREE$) , "() ", " "), "(, " , " (

1300 UNTIL NTREES =TREE$

1310 FNCLEANUP$= TREES

1320 FNEND

1330 DEF FNPRUNES(TREES)

1340 NODES =LEFT(TREE$,NODE_LEN)

1350 REPEAT

1360 POSl =INSTR(2,TREE$,NODE$)

1370 IF POS1 =0 GO TO 1510

1380 POS2 = POS 1 -fnode en

1390 ITEMS =MID(TREE$,POS2,l)

1400 BIF ITEMS = "("

1410 PLEV=0

1420 REPEAT

1430 IF ITEM$= "(" THEN PLEV=PLEV + 1

1440 IF ITEMS = ") " THEN PLEV = PLEV- 1

1450 POS2=POS2 + l

1460 ITEMS =MID(TREE$,POS2,l)

1470 UNTIL PLEV=0

1480 ENDIF

1490 TREES =LEFT(TREE$,POSl-l) +RIGHT(TREE$,POS2)

1500 UNTIL 0

1510 FNPRUNE$= TREES

1520 FNEND

1530 DEF FNREPL$(ITEM$,TEXT$,REPL$)

1540 REPEAT 1550 POS=INSTR(l,ITEM$,TEXT$) 1560 IF POS=0 GO TO 1590

1570 ITEM$=LEFT(ITEM$,POS-l)+REPL$+RIGHT(ITEM$,POS-r-LEN(TEXT$)) 1580 UNTIL 0

1590 FNREPL$=ΠΈM$

1600 FNEND

1610 DEF FNROUTE(TREES)

1620 FOR DEST = 1 TO 7

1630 DEST$=CVT$$(NUM$(DEST),2)

1640 POS = 1

1650 PRINT "Routes to Destination Node ";DEST$;": "

1660 PRINT

1670 X=FNRDIGSf ")

1680 PRINT

1690 PRINT

1700 NEXT DEST

1710 FNEND

1720 DEF FNRDIGS(DIGITSS)

1730 REPEAT

1740 NEW_DIG$=MID(TREE$,POS,NODE_LEN)

1750 POS=POS+NODE_LEN

1760 IF NEW_DIG$=DEST$ THEN PRINT DIGITS$;NEW_DIG$;",";

1770 DELIM$=MID(TREE$,POS,l)

1780 POS=POS + l

1790 BIF DELIM$= "("

1800 X=FNRDIGS(DIGITS$+NEW_DIG$+ " ")

1810 GO TO 1770

1820 ENDIF

1830 IF DELIMS = ") " THEN FNEND 1840 UNTIL DELIM$ < > "," 1850 FNEND 1860 REM END

The structured BASIC language in which the above program is written has certain built-in functions, which are relied upon in the above program. Therefore the built-in functions used in the above program will be described below.

It should be pointed out that the choice of BASIC to describe the algorithms of the present invention is an arbitrary one, and any language could have been employed. This use of BASIC should not therefore be taken in any limiting sense.

Brief definitions of the built-in BASIC functions used in the above program:

LEFT( stringS, length )

Returns a left sub-string consisting of the left "length" characters of "stringS".

CNT$$( stringS, -1 )

Returns a string consisting of "stringS", but with all spaces, tabs and special characters removed, and with lower case characters converted to upper case.

CVT$$( stringS, 2 )

Returns a string consisting of "stringS", but with all spaces and tabs removed.

LEΝ( stringS )

Returns the length of "stringS" .

INSTR( pos, stringlS, string2$ )

Returns the position of "string2$" within "stringlS", beginning the search at position "pos" within "stringlS". Returns 0 if "string2$" is not contained in "stringlS".

MID( stringS, pos, length )

Returns a sub-string of "stringS" which starts at position "pos" and consists of "length" characters.

RIGHT( stringS, pos ) Returns a right sub-string consisting of all characters of "stringS" starting at position "pos".

NUM$( number )

Returns the decimal character representation of "number" . For positive values a space precedes the number, and for negative numbers, a "-" precedes the number.

The following is a line-by-line description of the program:

Lines 10 - 30

Determine whether a network simulation (S) or a test of the algorithms using manual data entry (M) is requested.

Lines 40 - 250

Manual data entry mode. First, a node number is requested. Then node number sub-trees are requested. The sub-trees are separated by commas, enclosed in parentheses and appended to the node number as described earlier to obtain the raw local node number subtree. This is then pruned to remove any circular routing patterns, and then cleaned up to return the sub-tree to its canonical form. The results are then printed.

Lines 270 - 340

Network simulation mode. Seven nodes numbered 1 to 7 are created.

Lines 350 - 620

Network simulation mode. The current values of the local node number sub-trees are printed along with the sub-trees for each of the trunk groups leading to adjacent nodes.

Lines 630 - 780

Network simulation mode. The local node number sub-trees are assigned to the trunk groups, simulating the periodic sending of the local node number sub-trees to adjacent nodes. Lines 790 - 850

Network simulation mode. The next generation of the local node number sub-trees is produced by concatenating the received sub-trees separated by commas, enclosing the result in parentheses, appending the result to the local node number, and then cleaning up to return the resulting sub-trees to their canonical form.

Lines 860 - 1020

Network simulation mode. The new generation of local node number sub-trees is checked against the previous generation. If any sub-tree has changed, then the simulation loop will continue for another generation. Otherwise the sub-trees are stable, the entire network is represented by the current generation of sub-trees, and the simulation loop exits. Lines 1030 - 1250

Network simulation mode. The routing digit sets are computed for each source and destination route combination, and printed. The program then exits.

Lines 1260 - 1320

FNCLEANUP$( NTREES ) function. This function performs a cleanup of a raw node number sub-tree NTREES by eliminating any empty sub-tree components resulting from the pruning process. This returns the sub-tree to the canonical form to facilitate later parsing and prevents the sub-tree from growing in length on account of "junk" components.

Lines 1330 - 1520 FNPRUNE$( TREES ) function. This function prunes a node number sub-tree TREES to eliminate any sub-tree components which include the current node. This is done to prevent circular routing patterns from developing. When a component includes the current node number, then all characters of the component below the current parenthesis level are excised, and the result becomes the new node number sub-tree for the next loop iteration. The function returns when no component containing the current node number remains in the sub-tree.

Lines 1530 - 1600

FNREPL$( ITEMS, TEXTS, REPLS ) function. This function is used by the FNCLEANUPS function. It replaces all occurrences of the character string TEXTS found within the character string ITEMS with a replacement character string REPLS .

Lines 1610 - 1710

FNROUTE( TREES ) function. This function computes the routing digit sets to be sent for each of the 7 destination nodes in the simulation, given a local node number sub-tree TREES. For each destination node, another function, FNDIGS is called to print the routing digit set for that destination.

Lines 1720 - 1850

FNDIGS( DIGITSS ) function. TREES, POS and DEST$ are implicit arguments to this function. This function computes and prints the routing digit set for destination node DESTS, starting at character position POS within local node number sub-tree TREES. It loops for each comma-delimited node number in the sub-tree, comparing it with the destination node and printing it if it matches. When the final right parenthesis in the subtree is found, the function returns. If a compound sub-tree (i.e. one not consisting of a solo node number but rather a node number followed by a list of node numbers enclosed in parentheses), is encountered, then FNDIGS is called recursively to process the sub-tree. In this way, the entire local node number sub-tree is traversed, and all possible routes to the destination will be found and printed.

Consider "crankback" alternate routing

Crankback alternate routing is a method of increasing the probability of completing a call when all trunks to a destination are found busy in a given node by backing up to the preceding node and trying an alternate route there.

Crankback alternate routing is difficult to implement in the prior art due to a network node's lack of knowledge of the overall network topology. However, crankback alternate routing is easily provided in the ATRC scheme. When routing a call, a node simple retains the routing digit set for a call until it is known that the call has been successfully completed or abandoned. When a node finds all trunks busy in all available trunk groups to a destination, instead of returning a busy tone or indication to the caller, the node returns a crankback indication. The preceding node receives this indication and proceeds just as if all trunks had been busy in that group, choosing the next alternate route or returning a crankback indication to the preceding node if all alternatives have been tried.

Since each node continues to use the appropriate routing digit set to route the call, optimum routes can be chosen and circular routing avoided.

Consider now sending node number sub-trees and routing digit sets

Conventional signaling systems used in telephony have traditionally been limited in scope to sending the digits 0-9 and several additional control signals which vary from system to system. They are not usually capable of sending arbitrary ASCII (American Standard Code for Information Interchange) characters such as the open and close parentheses and comma used in the node number sub-tree and routing digits set notation as defined in the present invention. This problem can be avoided in several ways.

The first method would substitute the parentheses and comma characters in the notation with unique control characters chosen from the most common signaling system encountered. A better method is to retain the abstract notation as defined earlier, and substitute appropriate control characters for the particular signaling system as required when sending or receiving on a trunk. Two examples will serve to illustrate this process. The first shows a possible conversion of the node number sub-tree notation into DTMF (Dual Tone Multi-Frequency) signals. This is a commonly used signaling system which is also the standard for push button telephone sets:

4(1(2,3(5)),5(3(1(2))),6(7))

becomes

4*1*2A3*5##A5*3*1*2###A6*7##

The following example shows a routing digit set converted into DTMF:

(145, 1435, 135, 1345)1212

becomes

*145A1435A135A1345#1212

In born examples, the "(" was converted to the DTMF "*", the ")" to the DTMF "#", and the "," to the DTMF "A". Other conversions are of course possible. Consider reducing ATRC message traffic

The potentially high message bandwidth requirements of the ATRC scheme can be reduced by employing multiple message sending rates. For example, whenever the local node number sub-tree changes, a new set of outgoing messages is sent scheduled by timer A. But when several identical local node number sub-trees are calculated in succession, the outgoing messages can be scheduled by timer B, where B is a longer duration timer than A. In this way the message traffic can be reduced on average, but rapid response to the appearance of new nodes and trunks is retained.

Consider partitioning of a network

It is often desirable to partition a large network into sub-networks with gateway trunks connecting them. The advantage of this is the ability to restrict the information passed across the gateway to just the sub-network identification, thereby "blinding" the outside network from the network topology of the sub-network. This reduces the amount of ATRC information passed and effectively prevents the sub-network from being used by the outside network for tandem routing to other sub-networks.

To implement this, the concept of a node number is expanded to include additional digits representing network and/or sub-network identification. These could be entered by ADMIN at each node.

When a node receives an incoming node number sub-tree on an ATRC trunk, it will now compare the additional network identifying digits (part of the very first node number in the string) against its own. If they are the same, then the adjacent node is known to be part of the same sub-network, and the normal ATRC process described above is applied. If the subnetworks differ however, then the trunk is known to be an inter-network gateway trunk, and only the sub-network identifying digits are periodically sent instead of the local node number sub-tree.

Claims

1. A telecommunications system providing for self-configuring networks comprising a plurality of interconnected nodes each of said nodes being interconnected by trunk circuits, each said node having means for sending signaling messages associated with each of said trunks to the said other nodes, and each said node having means for receiving said signaling messages, and each said node having processing means for interpreting the said received signaling messages for determining the content of the signaling messages to be sent subsequently, and obtaining the trunk routing information by which calls can be routed in the network.

2. The system of claim 1 in which the initial content of the signaling messages is a uniquely identifying node number only, and in which received signaling messages for each trunk are stored as node number sub-trees, and in which subsequent signaling messages consist of said identifying node numbers followed by a list of concatenated node number sub-trees.

3. The system of claim 2 in which trunks receiving identical node number sub-tree signaling messages are placed into a common group for the purposes of trunk routing.

4. The system of claim 2 further comprising means for carrying out a pruning process on the concatenated node number sub-trees before the sending of the subsequent signaling messages, whereby to remove circular routing patterns.

5. The system of claim 2 in which said sending means is operative for sending of signaling information during the routing of individual calls which includes sending a routing digit set computed from the accumulated node number-sub-tree information at each node, which routing digit set guides the call routing through the network to avoid circular routing behavior.

6. The system of claim 5 in which crankback alternate routing is provided by retaining said routing digit set until said individual call has been successfully routed so that said call can be re-routed from the current node if a crankback signal is received on said call.

7. The system of claim 5 in which said node number sub-trees and said routing digit sets are converted into signals compatible with the signaling system used for signaling on particular said trunk circuits.

8. The system of claim 2 in which the rate of sending of said node number sub-tree signaling messages to said other nodes is reduced if the sub-trees are unchanging, said reduction in rate serving to reduce message bandwidth requirements.

9. The system of claim 2 in which said identifying node numbers incorporate a subnetwork identifying code to permit network partitioning by sending only the sub-network identifying code to said other nodes when the sub-network identifying codes mismatch, rather than sending said node number sub-tree.