Editing protocol for flexible search engines

[0002] The present application is related to U.S. application Ser. No. 09/679,209 for “Fast Flexible Search Engine for Longest Prefix Match” filed Oct. 4, 2000, now U.S. Pat. No. 6,564,211 granted May 13, 2003, and is related to U.S. application Ser. No. 09/679,313 filed Oct. 4, 2000 for “Flexible Search Engine having Sorted Binary Search Tree for Perfect Match”, now U.S. Pat. No. 6,553,370 granted Apr. 22, 2003, both by Alexander A. Andreev and Ranko Scepanovic and assigned to the same Assignee as the present invention, both of which are specifically incorporated herein by reference.

[0003] This invention relates to search engines for searching large tables of data, and particularly to an improved protocol for insertion and deletion of items to the search table.

[0004] Lookup procedures are a major source of bottlenecks in high-performance compilers and routers, such as compilers used to search databases of cell designs for designing integrated circuits, and compilers used to lookup internet addresses (URLs) in network applications. Recently, there has been renewed interest in binary search trees, largely because the worst-case time required for basic dynamic set operations is O(log n), where n is the number of nodes or vertices in the tree. In application Ser. No. 09/679,313, we describe a sorted binary search tree that inherits the favorable attributes of prior binary search trees, but provides simpler solutions for insertion and deletion functions. However, that search tree requires considerable memory allocation, particularly for performing insertion and deletion functions. The insertion and deletion functions are important to the search tree because they maintain equal length to all search paths through the tree.

[0005] The present invention is directed to an improvement of the search tree described in our aforementioned applications, and particularly to an improved insertion and deletion technique that reduces memory requirements for the tree.

[0006] One aspect of the present invention is a process for changing the number of entries in a search tree by inserting or deleting entries into or from a vertex of a bottom level. The search tress has a top level, a bottom level and at least one hierarchy level between the top level and the bottom level. The bottom level has a plurality of vertices each containing at least one entry, with each bottom level vertex being a child vertex to a vertex of a hierarchy level and each vertex in the top and hierarchy levels being a parent to at least one vertex in a lower level. A vertex is selected and its level in the tree identified. If the level of the selected vertex is not the bottom level, the entries in the child vertices of the selected vertex are redistributed so that the child vertex having a maximal index contains a predetermined number of entries. In the case of a deletion, the predetermined number equals the maximum number H that a vertex may contain. In the case of an insertion, the predetermined number is less than the maximum number and is preferably H−1. If the level of the child vertex is the bottom level the entry is inserted or deleted on the child vertex having the maximal index. If the level of the selected vertex is the bottom level the entry is inserted or deleted on the selected vertex.

[0007] In preferred forms of the invention, the process of deleting an entry from the search tree is performed by repeating the steps of the process using the child vertex having the maximal index found during one iteration for the selected vertex during the next iteration, until a child vertex is found in the bottom level.

[0008] In preferred forms of the invention, if the level of the child vertex is not the bottom level, the process of inserting an entry to the search tree is includes redistributing entries between grandchild vertices of the selected vertex that are children of the child vertex having the maximal index so that the grandchild vertex having a maximal index contains the predetermined number of entries. If the level of the grandchild vertex is the bottom level the entry is inserted on the grandchild vertex having the maximal index. If the level of the grandchild vertex is not the bottom vertex, the process is repeated using the child or grandchild vertex having the maximal index found during one iteration for the selected vertex during the next iteration, until a child or grandchild vertex is found in the bottom level.

[0009] The selection of the child or grandchild vertex as the selected vertex depends on whether the child vertex contains the maximum number (H) of entries. If the child vertex contains less than the maximum number of entries (H−1), the process is repeated using the child vertex during the next iteration. If the child vertex contains the maximum number of entries (H), the process is repeated using the grandchild vertex during the next iteration.

[0010] Another aspect of the present invention resides in a search tree that includes instrumentalities to carry out the process of the invention.

[0011] Another aspect of the present invention resides in the provision of computer readable program code that is embedded in a computer usable medium. The computer readable program code includes computer code that causes a computer to define the search tree and computer code that causes the computer to insert and delete entries to and from bottom vertices of the tree.

[0012] FIG. 1 is a diagram of a balanced search tree in which the present invention is used.

[0013] FIG. 2 illustrates examples of Split and Merge edit processes used in the present invention.

[0014] FIG. 3 illustrates examples of Move_Up and Move_Down processes used in the present invention.

[0015] FIG. 4 is a flow chart of a redistribution process employed in an optional program code of the present invention.

[0016] FIG. 5 is a flow chart of an insertion process in accordance with the present invention.

[0017] FIG. 6 is a flow chart of a deletion process in accordance with the present invention.

[0018] FIG. 7 is a flow chart illustrating the general process of the invention as carried out by a program code of the present invention.

[0019] FIG. 1 is a diagram of the search tree described in application Ser. No. 09/679,313, and illustrates the environment of the present invention. The tree includes a top or root vertex 10 and a plurality of hierarchy vertices 12-18 arranged in a plurality of levels L3-L1, and a bottom level L0 containing a plurality of bottom vertices 20-34. There may be any number of levels, each containing vertices such that the vertices of a lower level are children to the vertices of the next higher level. Root vertex 10 and each hierarchy vertex 12-18 contains entries 36, with the root vertex containing a single entry 36 that is the entry point for searches to the tree. Each entry 36 contains a key field 40, a child vertex address field 42, and a designator field 44. The keys 40 are copies of the highest-valued key or entry of each child vertex in the next lower level. The designator field entry 44 identifies the number of entries in the respective child vertex, and the child vertex address field 42 identifies the address 52 of the child vertex containing the entry. The bottom vertices contain keys 50 and associated data entries 51.

[0020] In application Ser. No. 09/679,313, the number of entries in any hierarchy or bottom vertex is limited to between k and 2k−1, where k is an integer greater than or equal to 2 (k≦2). In the present invention, the maximum number of entries in a vertex on a level other than top level L3 is H and the minimum number is H−1, where H is an integer greater than or equal to 2 (H≧2). The maximum number of entries in the vertex on top level L0 is TH and the minimum number is one. The capacity CAP of the tree is the maximum number of entries in the bottom level.

[0021] Each level contains a maximum of LC(i) vertices, except the top level L3 contains one vertex. The capacity CAP of the tree is one more than the maximum number of vertices in the bottom level minus 1 (LC(0)−1), times the minimum number of entries in a vertex (H−1): CAP≦1+(H−1)·(LC(0)−1). The capacity cap of a level (other than the top level) is cap≦1+(H−1)·(LC(i)−1). Each lower level (i−1) contains no more vertices as the maximum number of entries as in the next higher level i: LC(i−1)≦1+(H−1)·(LC(i)−1). The number of levels NL is the minimum number for which cap (NL−2,H,CAP)≦TH, where NL−2 is the level below the top level (level L2 in FIG. 1). The maximum number in vertices in each level, other than the top level, is LC(i)=cap(i,H,cap) for i=0, 1, . . . , NL−2.

[0022] In addition, each level, other than the top level, has no more than one vertex containing less than H−1 entries. Therefore, normally vertices contain H or H−1 entries.

[0023] To maintain equal lengths of the paths, the tree may need to be re-structured as entries are added or deleted. This is accomplished through selective splitting and merging of vertices. For example, if the entry containing key “3609” is deleted from vertex 32, it would be necessary to move key “3639” from vertex 34 to vertex 32 to avoid the violation of the rule concerning minimum size of vertices. In addition, an entry in vertex 18 would need to be changed to reflect the change of top keys in both child vertices 32 and 34. It will be appreciated that if all of the child vertices 30-34 contained the minimum number of entries, the deletion of an entry from one of those vertices would require a merging of entries to reduce the number of vertices.

[0024] Similarly, insertion of entries may require operations of split and merger. For example, while an insertion to a bottom vertex that does not already contain the maximum number of entries may be accomplished without significant change to the tree, an insertion to a bottom vertex already containing the maximum number of entries may require splitting that vertex, or even of a parent vertex.

[0025] While the process described in the aforementioned application is quite effective and exhibits minimal latency, it also requires considerable memory allocation. The present invention is directed to protocols for editing the binary search tree of a search engine to permit insertion and deletion operations with minimal memory allocation and decreased frequency of such operations.

[0026] The present invention is directed to an improved edit protocol for insertion and deletion operations for use in the search engines of the binary search trees described in our aforementioned applications. The protocol reduces the frequency of insertion/deletion operations with nearly zero area increase, and hence provides an increased capacity of the engine. There are seven basic functions or procedures performed during insert and delete operations: Split, Merge, Move_Up, Move_Down, Normalize, Create_Max and Create_Min.

[0027] 1. Split Function

[0028] The Split function has a format of Split(V,ind,p), where V is the vertex whose child vertex is being split, ind is the index of the child vertex being split, and p is a parameter that is smaller than the number of entries in the ind-th child vertex. This operation creates a new child vertex of vertex V and inserts it at an (ind+1)-th position. The entries in the ind-th child vertex are split between it and the new (ind+1)-th child vertex. The ind-th child vertex obtains the lower p entries, whereas the (ind+1)-th child vertex obtains the remaining entries (commencing with p+1). For example, if child vertex i contains 3 entries (where H=3), a Split(V,i,2) operation will create a new child vertex i+1, and will split the three entries previously in child vertex i so that child vertex i contains entry p and p−1 and child vertex i+1 contains entry p+1. This is diagrammatically illustrated in FIG. 2 where the operation Split(A,1,2) is performed to split child vertex B₁that contained three entries C₀, C₁and C₂into two vertices B₁and B₁′ with vertex B₁containing entries C₀and C₁and vertex B₁′ containing entry C₂.

[0029] 2. Merge Function

[0030] The Merge function has a format of Merge(V,ind), where V is the vertex having two child vertices being merged and ind is the index of the child vertex into which entries of the next higher child vertex are being merged. This operation is the reverse of the Split operation and eliminates the (ind+1)-th child vertex of vertex V and inserts its entries into the ind-th child vertex. For example, if child vertex i contains 2 entries and child index i+1 contains 1 entry (where H=3), a Merge(V,i) operation will insert the entry previously found in child vertex i+1 and insert it in child vertex i, and will eliminate child vertex i+1. This is also diagrammatically illustrated in FIG. 2 where the operation Merge(A,1) is performed to merge child vertex B₁that contained two entries C₀and C₁with child vertex B₁′ that contained entry C₂into a single vertex B₁containing entries C₀, C₁and C₂.

[0031] 3. Move_Up Function

[0032] The Move_Up function has a format of Move_Up(V,ind,p), where V is the vertex whose child vertices contain entries that are being moved from one child vertex to another, ind is the index of the child vertex whose entries are being moved to child vertex (ind+1), and p is a parameter that is smaller than the number of entries in the ind-th child vertex. This operation moves p entries from the ind-th child vertex to the (ind+1)-th child vertex of vertex V. For example, if child vertex i contains 3 entries (where H=3), a Move_Up(V,i,2) operation will move the two highest entries in child vertex i to child vertex i+1. This is diagrammatically illustrated in FIG. 3 where the operation Move_Up(A,0,2) is performed to move entries C₁and C₂from vertex B₀into vertex B₁.

[0033] 4. Move_Down Function

[0034] The Move_Down function has a format of Move_Down(V,ind,p), where V is the vertex whose child vertices contain entries that are being moved from one child vertex to another, ind is the index of the child vertex which will receive entries from child vertex (ind+1), and p is a parameter that is smaller than the number of entries in the (ind+1)-th child vertex. This operation moves p lower entries from the (ind+1)-th child vertex to the ind-th child vertex of vertex V. For example, if child vertex i+1 contains 3 entries (where H=3), a Move_Down(V,i,2) operation will move the two lowest entries in child vertex i+1 to child vertex i. This is also diagrammatically illustrated in FIG. 3 where the operation Move_Down(A,0,2) is performed to move entries C₁and C₂from vertex B₁into vertex B₀.

[0035] 5. Normalize Function

[0036] The Normalize function has a format of Normalize(V), where V is a vertex that is not in the bottom level. The goal of this function is to distribute entries between the child vertices of vertex V so that the size of the child vertices, Size(Child(V,i)), does not increase as a function of the child index i, and the number of child vertices having H−1 entries is maximized. This function is accomplished by identifying SumSize(V) as the total of the number of entries in all child vertices of vertex V and identifying a parameter d.

[0037] If SumSize(V)≧H·(H−1), set d=SumSize(V)−H·(H−1)

[0038] If (H−1)·(H−1)≦SumSize(V)<H·(H−1), set d=SumSize(V)−(H−1)·(H−1).

[0039] If SumSize(V)<(H−1)·(H−1), set d=0.

[0040] Starting at the child vertex having the lowest index, i=0, the size of each child, in terms of the number of entries, is examined. More particularly, if the sum of the sizes of the children vertices at indexes i and i+1, where i<d, is greater than H, a Move_Down procedure is performed to move the lower p entries from the child vertex whose index is i+1 to child vertex whose index is i, where p is equal to H minus the size of child vertex i:

[0041] if Size(Child(V,i))+Size(Child(V,i+1))>H

[0042] perform Move_Down(V,i,H−Size(Child(V,i))).

[0043] If the sum of the sizes of the children vertices i and i+1, where i<d, is equal to H, a Merge procedure is performed to move all entries from child vertex i+1 to child vertex i, and delete child vertex i+1:

[0044] if Size(Child(V,i))+Size(Child(V,i+1))==H,

[0045] Merge(V,i).

[0046] If the size of child vertex i is equal to H−1, the process continues to the next child vertex i+1.

[0047] For each child i, where i is smaller than the size of vertex V minus 1, i<Size(V)−1, a similar set of operations can be performed:

[0048] if Size(Child(V,i))>H−1, Split (V,i,H−1);

[0049] if Size(Child(V,i))+Size(Child(V,i+1))>H−1, Move-Down(V,i,H−1−Size(Child(V,i)));

[0050] if Size(Child(V,i))+Size(Child(V,i+1))==H−1, Merge(V,i);

[0051] if Size(Child(V,i))==H−1, the level i is advanced by one.

[0052] The process continues for all levels above the bottom level and the entries in each child vertex are re-distributed. The result of the re-distribution is that the first d child vertices of a vertex V will each have H entries. All other child vertices will have H−1 entries, with the possible exception of the last vertex. In the event that SumSize(V)<(H−1)·(H−1), the last child may have less than H−1 entries.

[0053] 6. Create_Max Function.

[0054] The Create_Max function has the format Create_Max(V,E), where E is the search object and V is a vertex that is not in the bottom level. There are two cases. A “regular” case is where vertex V has H child vertices each having at least H−1 entries, and an “exception” case where either vertex V has less than H child vertices or vertex V has H child vertices but the last of them contains less than H−1 entries. The goal of this function is to distribute the entries of the child vertices so that the last or maximal child vertex, whose index is Comp_Ind(V,E) has H entries. One exemplary algorithm to perform this function is described as follows:

[0055] For the “regular” case where vertex V has H child vertices each having H−1 entries, for (i=0;i<Size(V)−1;i++),

[0056] Move_Down(V,i,H−Size(Child(V,i))), and

[0057] Merge(V,Size(V)−1).

[0058] The result will be that all child vertices of vertex V will have H entries.

[0059] For the “exception” case where some p-th child vertex of vertex V has H entries, two conditions can occur:

[0060] a) If p<ci, where ci is Comp_Ind(V,E), then

[0061] for(i=ci;i<p;i++), Move_Down(V,i,1); or

[0062] b) If p>ci, then

[0063] for (i=p;i<ci;i++), Move_Up(V,i,1).

[0064] (If p=ci, the maximum child vertex has less than H−1 entries, which is one of the next exception cases.)

[0065] In the “exception” case, where Vertex V has less than H child vertices, or has H child vertices but the maximum child vertex has less than H−1 entries. This can only occur at the last vertex of the level, and all child vertices, except the last, will have either H or H+1 entries. For (i=0;i<Size(V);i++), do

[0066] if (Size(Child(V,i))+Size(Child(V,i+1))>H, Move_Down(V,i,H−Size(Child(V,i))), or

[0067] otherwise, Merge(V,i).

[0068] In this “exception” case, if Comp_Ind(V,E) is the last vertex index of the level, the original goal might not be achieved. More particularly, the Comp_Ind(V,E)-th vertex might not contain H entries. In this case, however, this is an acceptable result.

[0069] 7. Create_Min Function.

[0070] The Create_Min function has the format Create_Min(V,E), where E is the search object and V is a vertex that is not in the bottom level. There are two cases. A “regular” case is where vertex V has H−1 child vertices each having at least H−1 entries, and an “exception” case where either vertex V has less than H−1 child vertices or vertex V has H−1 child vertices but the last of them contains less than H−1 entries. The goal of this function is to distribute the entries of the child vertices so that either S1 or S2 has H−1 entries, where S1 is the child of vertex V having the maximum index and S2 is the child of vertex S1 having the maximum index:

[0071] S1=Child(V,Comp_Ind(V,E)), and

[0072] S2=Child(S1,Comp_Ind(S1,E)).

[0073] One exemplary algorithm to perform this function is described as follows, where p is the minimal index of the child vertex containing H−1 entries:

[0074] for (i=p−1;i>ci;i—), Move_Up(V,i,1).

[0075] If p<Size(V)−1, that is, p is smaller than the size of vertex V minus 1 and vertex V has at least two child vertices with H+1 entries,

[0076] for (i=p;i≧ci;i—), Move_Up(V,i,1).

[0077] This redistributes the entries so that Comp_Ind(V,E) is either ci or ci+1, and the Child(V,Comp_Ind(V,E)) vertex has H−1 entries.

[0078] If p==Size(V)−1, only the Comp_Ind(V,E)+1 child of vertex V has H−1 entries. If the level of vertex V is at least 2, the process illustrated in FIG. 4 is applied. More particularly, the procedure Normalize(Child(V,Comp_Ind(V,E))) is performed at step 100. If Size(Child(Child(V,Comp_Ind(V,E)),H−1)) is smaller than the maximum number of entries in a vertex (H), as determined at step 102, the Move_Up(V,Comp_Ind(V,E),1) procedure is carried out at step 104. Otherwise, the Split(Child(V,Comp_Ind(V,E)),H−1,1) procedure is carried out at step 106 before carrying out the procedure at step 104. Now, if Size(Child(Child(V,Comp_Ind(V,E)),H−1)) is smaller than the maximum number of entries in a vertex (H), as determined at step 108, the process ends. Otherwise, a Normalize(Child(V,Comp_Ind(V,E)) is carried out at step 110.

[0079] The result of the process of FIG. 4 is the redistribution of the entries so that Comp_Ind(V,E) is either ci or ci+1 and the grandchild vertex Child(Child(V,ci+1,0) has H−1 entries. The Child(V,ci) vertex has H−1 entries (if Size(Child(Child(V,ci),H−1))<H, or each of its child vertices (grandchildren to vertex V) has H−1 entries (if Size(Child(Child(V,ci)),H−1))==H.

[0080] If S1=Child(V,Comp_Ind(V,E)) and S2=Child(S1,Comp_Ind(S1,E)), then either

[0081] Comp_Ind(V,E)=ci, or

[0082] Comp_Ind(V,E)=ci+1 and Comp_Ind(S1,E)=0.

[0083] In the first case if Size(Child(Child(V,ci)),H−1))<H, S1 has H−1 entries. If Size(Child(Child(V,ci)),H−1))==H, then S2 has H−1 entries (because any child of S1 has H−1 entries in this case). In the second case, S2 has H−1 entries.

[0084] Insertion Procedure

[0085] FIG. 5 is a flow chart illustrating the process of inserting an object E into a bottom vertex VB. The process commences at step 150 at the top or root of the tree VH. At step 152, level number is identified. If the level number is 0, indicating that the level is the bottom level (meaning that the tree is a single level tree), a BOT_INS(V,E) process is performed at step 154 to insert object E into bottom vertex VB in the manner described in application Ser. No. 09/679,313, and the process ends. If the current level V is not the bottom level at step 152, then a Create_Min(VE) operation is performed at step 156 to distribute the entries in either a child vertex S1 or a grandchild vertex S2 so that the child or grandchild vertex has H−1 entries. Vertex S1 is the child of vertex V having a maximal index number. Vertex S2 is the child of vertex S1 having a maximal index number. At step 160, a determination is made as to whether the level of vertex V is greater than level 1. If it is not, meaning the current level is level 1, there can be no grandchild vertex, and the process continues at step 162 to insert the object into vertex S1, which is in the bottom level. At step 164, a determination is made whether the size of the bottom vertex S1 is greater than H. If Size(S1)≦H, the process ends. Otherwise, a Move_Up process is performed at step 166 to move one entry from the child index next lower from the maximal index into the child vertex having the maximal index, i.e., Move_Up(V,ci,1). Thus, for vertex V in the level under consideration, one entry is moved from the child vertex whose index is ci−1 to the child vertex whose index is ci.

[0086] If at step 160, the level of vertex V is greater than 1, meaning there is a grandchild level, a determination is made at step 168 whether the size of child vertex S1 is smaller than H. If the size of vertex S1 is smaller than H (Size(S1)<H), vertex S1 is set to vertex V and the process loops back to step 152 to repeat using vertex S1 as vertex V. Otherwise, if the size of vertex S1 is not smaller than H, Size(S1)≧H, the grandchild vertex S2 is identified at step 172, which is the child of vertex S1 having the maximal index. At step 174, vertex S1 is set to V, and the process loops back to step 152 to repeat the process using vertex S2 for vertex V. The process continues until either the bottom level is reached at step 152, or level 1 is reached at step 160, in which case the object is inserted into the bottom level at S1 or S2, as the case may be, and the process ends. As described in application Ser. No. 09/679,313, the insertion operation may require use of a split operation.

[0087] Deletion Procedure

[0088] FIG. 6 illustrates the process of deleting object E from a bottom vertex V. As in the case of the insertion procedure, the process commences at the root or top level VH of the tree at step 200. At step 202, a determination is made as to whether the vertex in question is greater than the zero level. If the level is not greater than 0, indicating that the vertex is in the bottom level, a Bot_Del(V,E) process is formed at step 202 as described in application Ser. No. 09/679,313, and the process ends.

[0089] If vertex V is not in the bottom level, a Create_Max(V) procedure is performed at step 206 to distribute the entries between the children vertices of vertex V so that the child vertex having a maximal index has H entries. At step 208, the child vertex is set to the current vertex, and the process loops back to step 202. The process continues to iterate until the bottom level is reached at step 202, whereupon the deletion process described in application Ser. No. 09/679,313, is performed at step 204. As described in application Ser. No. 09/679,313, the deletion operation may require use of a merge operation.

[0090] The present invention thus provides an efficient technique for inserting and deleting entries to a search tree that allows the search engine to reach nearly 100% of memory utilization. More particularly, by limiting the number of vertices having less than H−1 entries to a maximum of one vertex on each level, the computer memory storing the tree is more fully utilized. While the complexity of the insertion and deletion processes is increased over that described in application Ser. No. 09/679,313, the order of magnitude of the complexity remains unchanged, namely equal to the logarithm of the capacity. The frequency of insertion and deletion operations is reduced by the present technique due to the use of a minimum capacity of H−1 (so each vertex has a capacity of either H or H−1) and the more complex operations.

[0091] In summary, and as illustrated in FIG. 7, using a search tree having a distribution of entries, such as one described in the above identified applications, a vertex of the tree is selected at step 250. If the vertex is in the bottom level, as identified at step 252, an insert or delete operation is performed at step 254 as described in connection with FIG. 5 or 6 as the case may be. If the vertex is not in the bottom level at step 252, a redistribution process is performed at step 256 on descendant vertices as described in connection with FIG. 4. The redistribution process redistributes the entries of descendant vertices at a given level so that a descendant vertex (for example the child or grandchild vertex) having the maximal index contains a predetermined number of vertices (e.g., H−1). If at step 258 the descendant vertex is in the bottom level, the process ends at step 254 with an insertion or deletion operation on the descendant vertex having the maximal index. Otherwise, the process iteratively redistributes entries among vertices at successive descendant levels (e.g. child or grandchild vertices) of the vertex found in the previous iteration having the maximal index until a descendant vertex is found in the bottom level, whereupon step 254 is performed.

[0092] The present invention provides a protocol that allows maximum utilization of the computer memory by the search engine. Consequently, the protocol is more efficient than that described in application Ser. No. 09/679,313. However, the increased efficiency of the present invention is achieved at a cost of increased latency. For this reason, and to minimize latency, it may be desirable to employ the protocol described application Ser. No. 09/679,313 in some cases.

[0093] The invention is carried out in a computer operated by a computer readable program code that performs the insertion and deletion of the search tree as described herein. More particularly, the computer readable program code is embedded in a computer, readable memory, such as the hard disk of the computer, and is executed by the computer to cause the computer to construct the search tree and manage the search tree entries as herein described.

[0094] Although the present invention has been described with reference to preferred embodiments, workers skilled in the art will recognize that changes may be made in form and detail without departing from the spirit and scope of the invention.