Methods and arrangements of representing the allocation of integers are discussed. Embodiments include transformations, code, state machines or other logic to represent the allocation of integers. An embodiment may involve representing a first allocation of integers via a set of nodes of a tree. In the representation, a data structure in a node may represent, for each integer in a set of integers, whether the integer is allocated or free. The embodiment may also involve representing a subsequent allocation. The representing may include adding a new node to the nodes of the tree for the first allocation. The subsequent allocation may consist of freeing of an integer allocated in the first allocation. The data structure of the new node may represent that the integer is free.
|
9. An apparatus to represent the allocation of integers, the apparatus comprising:
memory;
one or more processors; and
a module to represent the allocation of integers via a set of nodes of a tree, wherein:
a set of integers is generated;
the integers in the set of integers are either allocated or unallocated;
when an integer from the set of integers is allocated, the allocated integer represents a system resource of the apparatus;
a data structure in a node represents, for each integer in the set of integers represented by the node, whether the integer is allocated or unallocated (free);
the module comprising a node-adding submodule to add a new node to the set of nodes of a tree to represent the freeing of an integer; and
a data structure of the new node represents that the integer allocated in the first allocation is free, wherein nodes of the tree comprise nodes representing sets of integers that comprise an unallocated (free) integer and a minimum set of parent nodes required to preserve a structure of the tree with regard to linking nodes representing sets of integers that comprise an unallocated (free) integer, and wherein the tree does not comprise nodes representing sets of integers that comprise only allocated integers.
1. A method, in a data processing system, for representing the allocation of integers, the method comprising:
generating a set of integers, wherein integers in the set of integers are either allocated or unallocated, and wherein when an integer from the set of integers is allocated, the allocated integer represents a system resource of the data processing system;
representing a first allocation of integers, from the set of integers, via a set of nodes of a tree, wherein a data structure in a node represents, for each integer in the set of integers represented by the node, whether the integer is allocated or unallocated (free); and
representing a subsequent allocation, comprising adding a new node to the set of nodes of the tree, wherein:
the subsequent allocation consists of freeing of an integer allocated in the first allocation; and
a data structure of the new node represents that the integer allocated in the first allocation is free, wherein nodes of the tree comprise nodes representing sets of integers that comprise an unallocated (free) integer and a minimum set of parent nodes required to preserve a structure of the tree with regard to linking nodes representing sets of integers that comprise an unallocated (free) integer, and wherein the tree does not comprise nodes representing sets of integers that comprise only allocated integers.
13. A computer program product to represent the allocation of integers, the computer program product comprising a non-transitory computer useable medium having a computer readable program, wherein the computer readable program when executed on a computer causes the computer to:
generate a set of integers, wherein integers in the set of integers are either allocated or unallocated, and wherein when an integer from the set of integers is allocated, the allocated integer represents a system resource of the data processing system;
represent a first allocation of integers, from the set of integers, via a set of nodes of a tree, wherein a data structure in a node represents, for each integer in the set of integers represented by the node, whether the integer is allocated or unallocated (free); and
represent a subsequent allocation, comprising adding a new node to the set of nodes of the tree, wherein:
the subsequent allocation consists of freeing of an integer allocated in the first allocation;
a data structure of the new node represents that the integer allocated in the first allocation is free,
nodes of the tree comprise nodes representing sets of integers that comprise an unallocated (free) integer and a minimum set of parent nodes required to preserve a structure of the tree with regard to linking nodes representing sets of integers that comprise an unallocated (free) integer, and
the tree does not comprise nodes representing sets of integers that comprise only allocated integers.
2. The method of
the additional node is an ancestor of the new node;
the tree comprises a third node, a data structure of the third node representing that another integer is free;
the third node is a descendant of the additional node; and
the third node is not a descendant or an ancestor of the new node.
3. The method of
the third allocation consists of allocating an integer not allocated in the first allocation; and
the data structure of the deleted node represented that the integer was free.
4. The method of
before deletion of the first node and the additional node, the additional node was the parent of the first node in the tree; and
the integers represented by the subtree of the tree rooted at the first node are all allocated.
5. The method of
deleting the nodes of a first subtree from the tree, wherein the data structures of the nodes of the first subtree all represent free integers;
deleting the nodes of second subtree from the tree, wherein the data structures of the nodes of the second subtree all represent allocated integers; and
deleting the nodes of a third subtree from the tree, except for nodes of a subtree of the third subtree, wherein:
the data structures of the deleted nodes of the third subtree represent allocated integers; and
the data structure of at least one node of the subtree of the third subtree represents free integers.
6. The method of
7. The method of
8. The method of
10. The apparatus of
a node-deleting submodule to delete a first node from the set of nodes of a tree to represent the allocating of an integer free in the first allocation, wherein a data structure of the deleted node represented that an integer in the first allocation was free.
11. The apparatus of
the additional node is an ancestor of the new node;
the tree comprises a third node, a data structure of the third node representing that another integer is free;
the third node is a descendant of the additional node; and
the third node is not a descendant or an ancestor of the new node.
12. The apparatus of
before deletion of the first node and the additional node, the additional node was the parent of the first node in the tree; and
the integers represented by the subtree of the tree rooted at the first node are all allocated.
14. The computer program product of
the additional node is an ancestor of the new node;
the tree comprises a third node, a data structure of the third node representing that another integer is free;
the third node is a descendant of the additional node; and
the third node is not a descendant or an ancestor of the new node.
15. The computer program product of
the third allocation consists of allocating an integer not allocated in the first allocation; and
the data structure of the deleted node represented that the integer was free.
16. The computer program product of
before deletion of the first node and the additional node, the additional node was the parent of the first node in the tree; and
the integers represented by the subtree of the tree rooted at the first node are all allocated.
17. The computer program product of
delete the nodes of a first subtree from the tree, wherein the data structures of the nodes of the first subtree all represent free integers;
delete the nodes of second subtree from the tree, wherein the data structures of the nodes of the second subtree all represent allocated integers; and
delete the nodes of a third subtree from the tree, except for nodes of a subtree of the third subtree, wherein:
the data structures of the deleted nodes of the third subtree represent allocated integers; and
the data structure of at least one node of the subtree of the third subtree represents free integers.
18. The computer program product of
a computer readable program which when executed on a computer causes the computer to represent a first allocation of integers via a set of nodes of a binary tree.
19. The computer program product of
a computer readable program which when executed on a computer causes the computer to represent only the integers from 1 to the maximum free integer via the set of nodes of the tree.
20. The computer program product of
a computer readable program which when executed on a computer causes the computer to represent a first allocation of integers via a set of nodes of a binary tree, wherein the data structure in a node represents whether a set of 64 integers is allocated or free.
21. The method of
setting a value of a maximum allocated parameter to a highest value integer that has an allocated state;
setting a value of a maximum free parameter to a highest value integer that has an unallocated (free) state, wherein:
integers greater than the maximum allocated parameter value are not represented as nodes in the tree,
integers greater than the maximum free parameter value are not represented as nodes in the tree, and
the tree comprises nodes corresponding to one or more of integers that are less than the maximum free parameter.
|
The present invention is in the field of data structures for computing devices. More particularly, the present invention relates to methods and arrangements to represent the allocation of integers.
Many processes may require keeping track of the allocation of a set of integers. Each integer in the set may be in use (allocated) or not in use (free). An operating system, for example, may use integers to identify resources, such as lists of DLLs, used by programs running under the operating system. To keep track of the allocation, a process may use a tree structure. A tree consists of nodes and pointers. A node points to its child nodes. The initial node is called the root. To represent an allocation with a tree, the nodes of the tree may contain data structures, each representing the allocation of a subset of the set of integers.
One type of tree is a binary tree. In a binary tree, each node has at most two children, but may have zero or one. A binary tree may be ordered. The nodes of the binary tree may be may be numbered or otherwise labeled so that the left children of a node have a label which is less than the label of the node, and the right children have a label which is greater than the label of the node. One type of ordered binary tree is numbered in preorder: The nodes of a left subtree are numbered, a node is numbered, and the nodes in the right subtree are numbered.
A method and arrangement of representing the allocation of integers is presented. One embodiment provides a method of representing the allocation of integers. The embodiment may involve representing a first allocation of integers via a set of nodes of a tree. In the representation, a data structure in a node may represent, for each integer in a set of integers, whether the integer is allocated or unallocated (free). The embodiment may also involve representing a subsequent allocation, in which an integer allocated in the first allocation is freed. The representing may include adding a new node to the nodes of the tree for the first allocation. The data structure of the new node may represent that the integer is free.
An explanation of the invention will become apparent upon reading the following detailed description and upon reference to the accompanying drawings in which like references may indicate similar elements:
The following is a detailed description of embodiments of the invention depicted in the accompanying drawings. The embodiments are in such detail as to clearly communicate the invention. However, the amount of detail offered is not intended to limit the anticipated variations of embodiments; but on the contrary, the intention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the present invention as defined by the appended claims. The detailed descriptions below are designed to make such embodiments obvious to a person of ordinary skill in the art.
Generally speaking, methods and arrangements of representing the allocation of integers are contemplated. Embodiments include transformations, code, state machines or other logic to represent the allocation of integers. The embodiments may receive a request to allocate an integer. In response, the embodiments may provide an integer for allocation and may update the representation of the allocation of integers. In addition, the embodiments may receive a specification of an integer that has been unallocated (free), and may update the representation of the allocation of integers.
An embodiment may involve representing a first allocation of integers via a set of nodes of a tree. In the representation, a data structure in a node may represent, for each integer in a set of integers, whether the integer is allocated or free. The embodiment may also involve representing a subsequent allocation. The representing may include adding a new node to the nodes of the tree for the first allocation. The subsequent allocation may consist of freeing of an integer allocated in the first allocation. The data structure of the new node may represent that the integer is free.
Some embodiments may involve deleting a node to represent allocating a currently free integer. In many embodiments, the representation may keep track of the largest allocated integer and the largest free integer less than the largest allocated integer. The tree representing an allocation may represent only the integers less than or equal to the largest free integer. In several embodiments, the method may include representing the allocation of integers via a binary tree labeled in preorder. In further embodiments, the data structure of a node may represent the allocation of multiple integers. For example, a 64-bit number may represent the allocation of a sequence of 64 integers. A 1 bit may represent that the corresponding integer is free and a 0 bit may represent that the corresponding integer is allocated.
Turning to
Initially, in the allocation represented by tree 110, none of the integers from 1 to 15 are allocated. Max_free=max_allocated=0. The allocation tree 110 is empty (contains no nodes). Next, one by one, the integers from 1 to 15 are allocated. In the example, whenever an integer is needed for allocation, the smallest free integer is selected. At this point, max_allocated=15. Max_free=0, since no integers less than 15 are free. Accordingly, the representational tree is empty. Thus, tree 110 represents each of these allocations.
Next, in the allocation represented by tree 120, node 13 is freed. Tree 120 contains a single node, node 13, with the label “F”. Max_free=13, and max_allocated=15. To represent the freeing of an integer, a node was added to tree 110. Next, in the allocation represented by tree 130, node 3 is freed. To represent this, node 2 is added to the existing node 13 of tree 120. In addition, node 8 is added, to preserve the tree structure. Max_free=13, and max_allocated=15.
Tree 130 represents the same allocation of the integers from 1 to 15 as does tree 100 of
Next, in the allocation represented by tree 140, another integer is allocated. Since 3 is the smallest free integer, it is selected for allocation. To represent the allocation, node 2 is deleted from the tree. In addition, node 8 is no longer needed to preserve tree structure, and is deleted. The resulting tree, tree 140, contains the single node 13. Max_free=13, and max_allocated=15. Finally, in the tree represented by tree 150, another node is allocated. Node 13 is selected, since it is the smallest free integer. To represent the allocation, node 13 is deleted from tree 140 and the representational tree, tree 150, is empty. Max_free=0, and max_allocated=15.
In the representations of
Operating system 210 is a layer of system software that may make system resources, including memory, input/output resources, and processors, available to other programs. Operating system 210 may also control allocation and authorization for access to computer resources. Operating systems may perform low-level, basic tasks, such as recognizing input from a keyboard, sending output to a display screen, keeping track of files and directories on a magnetic disk drive, and controlling peripheral devices such as disk drives and printers. The operating system is also responsible for security, ensuring that unauthorized users do not access the system.
Operating system 210 includes integer allocator 225. Integer allocator 225 may record the allocation and freeing of integers in the process of performing system operations. Integer allocator 225 may represent the allocation of integers by means of a tree structure. Data structures of the nodes may represent whether integers are allocated or free. In some embodiments, the representation of integer allocations may be a sparse representation.
Operating system 210 may include UNIX™, Linux™, Solaris™, Microsoft Windows XP™ and Vista™, AIX™, IBM's i5/OS™ and other operating systems useful for representing the allocation of integers as will occur to those of skill in the art. The modules shown in RAM 205 are for explanation, not for limitation. In other embodiments, modules other than an operating system may provide for the allocation of integers.
Application programs 1 (210) and N (215) and operating system 220 are shown in RAM 205 in
Non-volatile computer memory 240 may be implemented as a hard disk drive 242, optical disk drive 244, electrically erasable programmable read-only memory space (EEPROM or Flash memory) 246, RAM drives (not shown), or as any other kind of computer memory as will occur to those of skill in the art. Communications adapter 250 may implement the hardware level of data communications through which one computer sends data communications to other computers, such as other computers 255, directly or through a network. Communications adapter 250 may provide an interface to operating system 210 and other modules utilizing it. The interface may specify the form in which data is to be passed to the communications adapter, and the form in which data is received from the communications adapter. Examples of communications adapters include modems for wired dial-up communications, Ethernet (IEEE 802.3) adapters for wired network communications, 802.21a/b/g/n adapters for wireless network communications, and mobile broadband cards.
I/O interface adapter 260 implements user-oriented I/O through, for example, software drivers and computer hardware for controlling output to display devices such as display device 265 and audio output device 270 as well as user input from user input device 275 and audio input device 280. User input device 275 may include both a keyboard and a mouse. Some embodiments may include other user input devices such as speech interpreters, bar code scanners, text scanners, tablets, touch screens, and/or other forms of user input devices. Audio output 270 may include speakers or headphones and audio input device 280 may include a microphone or other device to capture sound.
The computer and components illustrated in
The initializing of element 305 may include initializing global variables to describe the state of the allocation (element 315). In some embodiments, the global variables may specify the greatest integer allocated (max_allocated) and the greatest unallocated integer that is less than max_allocated (max_free). All integers greater than max_allocated in the set of integers available for allocation may be free. The following diagram represents the division of the integers available for allocation into segments based upon max_free and max_allocated:
##STR00001##
As shown by the diagram, the specification of max_free and max_allocated may divide the set of integers available for allocation into three or fewer segments. The integers in the first segment (mixed), {n: n≦max_free}, may be either free or allocated. The integers in the middle segment (allocated), {n: max_free<n≦max_allocated}, are all allocated. The integers in the third segment, {n: n>max_allocated} are all free. Initially, max_free and max_allocated are set to 0, and all integers are in the “free” segment. As integers are allocated, max_allocated may be incremented. As integers are freed, max_free may be incremented. In addition, if max_allocated is freed, then it is decremented.
The use of max_free and max_allocated may reduce the size of the tree representing an allocation of integers. It is only necessary for the tree to represent the integers from 1 to max_free, the integers in the first segment of the above diagram. The status of allocation of integers in the second and third segments is known.
The method of flowchart 300 may include representing the freeing of an integer (element 320). The representation may include revising data structures to represent the freed integer (element 325), such as the data structure of a node. For example, in the representation of
The representation the freeing of an integer may also include revising the tree structure (element 330). When the tree does not contain a node representing the freed integer, a node may be added to the tree, as in the examples of
In some embodiments, additional nodes may be added to preserve the tree structure. Thus, in the example of
Traverse the tree upward from the newly-added node executing the following steps:
Turning to
The process begins by testing whether the newly-added node, node 13, is the root (line 2). It is not, and current node is set to 13 (line 3). Next, the loop of line 4 is started. The current node is reset to node 14, the parent of node 13. In the diagram of
Revising the tree structure (element 330) may also include deleting a subtree representing only free integers and replacing it with a pointer to indicate a uniformly free subtree. In some embodiments, a subtree may be collapsed by the following steps:
In
Next, the subtree rooted at node 30, consisting of nodes 30, 29, and 31 is checked (lines 8-9). All the nodes represent only free integers. Thus, the subtree is uniformly free and is replaced by a pointer. The process is continued, going up the tree to node 28, the parent of node 30 (lines 10-11). The subtree rooted at node 28 is uniformly free, because the node is uniformly free, and its two subtrees, rooted at nodes 26 and 30, are uniformly free. Continuing upward to parents, the subtrees rooted at 24 and 26 are also uniformly free. Each node is replaced by a pointer to the subtree (lines 10-11). The process stops with node 32, which is not all-free (line 12). The “A” in data structure of node 32 indicates that the integer 63 is allocated.
Returning to
Tree 650 of
In performing the first step, nodes 10, 11, 12, 16, 24, and 28, and subtrees 14, 20, 26, and 30 are removed from tree 600. The result left node 9 unconnected to an ancestor. In tree 650, node 9 is connected to its nearest remaining ancestor, node 8, since nodes 10 and 12 were deleted. Node 8 is no longer connected to an ancestor in tree 650. Node 16 was removed and no ancestors remain. Accordingly, node 8 becomes the root of tree 650.
In embodiments that follow an algorithm similar to the tree-pruning algorithm described above, the pruning process may completely collapse the tree when all integers are freed and none are allocated. In that case, max_allocated and max_free are both set to 0, and the tree representing the allocation is empty. This method of representing a tree after all the allocated integers are free may save memory. In contrast, other algorithms may maintain all free integers in the tree. As a result, the size of the tree representing the allocation is proportional to the number of integers ever allocated.
Returning to
The method of flowchart 300 also includes representing the allocating an integer (element 340). In the embodiment of
The representation of allocating the integer may also include revising the tree structure (element 350). In many cases, the process is the reverse of the revision of the tree structure used to represent the freeing of an integer. Thus, a node may be deleted when it represents only allocated integers. For example, in
The process is the reverse of the process of adding structural nodes discussed in connection with
The process continues by locating the nearest ancestor of node 13 in the representation tree. In the diagram of
Revising the tree structure for the allocation of an integer (element 350) may also include expanding a uniformly free subtree when an integer represented by the subtree is allocated. The expansion may, for example, transform tree 550 of FIG. B to tree 500 of FIG. A. The process may be carried out by proceeding downward from the root of the subtree to the node representing the integer. At each step:
Suppose tree 550 of
In many embodiments, the reversing of the pruning of
Returning to
In these further embodiments, then max_free is allocated only if it is the only free integer less than max_allocated. In such case, after it is allocated, there are no free integers below max_allocated, and max_free is set to 0. If there additional allocations or freeing of integers (element 360), elements 320 through 340 of
The elements of flowchart 300 are for illustration and not for limitation. In alternative embodiments, additional elements may be included, some of the elements of flowchart 300 may be omitted, or the elements may be performed in a different order. In other embodiments, the tree used to represent allocations may be other than binary. The tree may have 3 or more branches from some of the nodes. In several embodiments, an order of the nodes other than preorder may be used. In a few embodiments, data structures other than alphanumeric labels and binary numbers may be used to represent the allocation of integers. In many embodiments, a node may represent the allocation of a different number of integers than 1, 3, or 64. In some embodiments, the relationship between node number and integer number may differ from the relationships illustrated by the above discussions. In further embodiments, the nodes may be labeled with labels other than numbers.
In particular, the algorithms described above in connection with
Turning to
Integer allocator 700 includes data structure initialization module 702 to initialize the data structures used to represent the state of an allocation of integers. The data structures may include a tree structure whose nodes represent the state of allocations of integers. Data structures associated with each node may represent the state of allocations of a subset of the integers available for allocation. In some embodiments, for example, the data structures of a node may represent the state of allocations of a consecutive set of 64 integers. The data structures may also include global variables. In a few embodiments, the variables may include a variable to represent the largest integer which has been allocated (herein designated as max_allocated), and a variable to represent the largest integer available for allocation less than max_allocated (herein designated as max_free). In these embodiments, all integers n, for which max_free<n≦max_allocated, may be allocated; and all integers n, for which n>max_allocated may be free.
Integer allocator 700 includes free integer module 705, for representing the freeing of an integer, and allocate integer module 710, for representing the allocating of an integer. When an allocated integer is freed, free integer module 705 may update the data structures to represent the new state of the allocation. In particular, it may update a data structure in a node representing the state of allocation of the integer. In addition, free integer module 705 may update the tree structure to represent the new allocation. Node adding module 715 may add nodes to a tree structure. Integer node 720 may add a node representing the freed integer. In
Tree compression module 730 may compress a tree structure after the revising of data structures to represent the freeing of an integer. Uniform subtree module 735 may compress a subtree consisting uniformly of free integers, such as subtree 16 of tree 550 of
When an integer is allocated, allocate integer module 710 may update the data structures to represent the new allocation. In particular, it may update the state of a data structure in a node representing the state of allocation of the integer. In addition, allocate integer module 710 may update the tree structure to represent the new allocation. Node deleting module 745 may delete nodes from a tree structure when all of the integers represented by the nodes have been allocated. Integer node 750 may delete the node referencing the newly allocated integer. In the example of
Tree restructuring module 760 may further restructure a tree after the allocation of an integer. Uniform subtree module 765 may eliminate a subtree consisting uniformly of allocated integers. Split uniform subtree module 770 may split up a subtree uniformly representing free integers. After the allocation of one of the integers, the subtree may be replaced by ordinary nodes. This splitting up of a uniform subtree was illustrated by the transformation from tree 650 of
The module of
As will be appreciated by one skilled in the art, the present invention may be embodied as a system, method or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, the present invention may take the form of a computer program product embodied in any tangible medium of expression having computer usable program code embodied in the medium.
Any combination of one or more computer usable or computer readable medium(s) may be utilized. The computer-usable or computer-readable medium may be, for example but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, device, or propagation medium. More specific examples (a non-exhaustive list) of the computer-readable medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CDROM), an optical storage device, a transmission media such as those supporting the Internet or an intranet, or a magnetic storage device. Note that the computer-usable or computer-readable medium could even be paper or another suitable medium upon which the program is printed, as the program can be electronically captured, via, for instance, optical scanning of the paper or other medium, then compiled, interpreted, or otherwise processed in a suitable manner, if necessary, and then stored in a computer memory. In the context of this document, a computer-usable or computer-readable medium may be any medium that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device. The computer-usable medium may include a propagated data signal with the computer-usable program code embodied therewith, either in baseband or as part of a carrier wave. The computer usable program code may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc.
Computer program code for carrying out operations of the present invention may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).
The present invention is described above with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and/or block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable medium that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable medium produce an article of manufacture including instruction means which implement the function/act specified in the flowchart and/or block diagram block or blocks.
The computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
A data processing system suitable for storing and/or executing program code will include at least one processor coupled directly or indirectly to memory elements through a system bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution.
Input/output or I/O devices (including but not limited to keyboards, displays, pointing devices, etc.) can be coupled to the system either directly or through intervening I/O controllers.
Network adapters may also be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modem and Ethernet cards are just a few of the currently available types of network adapters.
It will be apparent to those skilled in the art having the benefit of this disclosure that the present invention contemplates methods and arrangements for representing the allocation of integers. It is understood that the form of the invention shown and described in the detailed description and the drawings are to be taken merely as examples. It is intended that the following claims be interpreted broadly to embrace all the variations of the example embodiments disclosed.
Although the present invention and some of its advantages have been described in detail for some embodiments, it should be understood that various changes, substitutions and alterations can be made herein without departing from the spirit and scope of the invention as defined by the appended claims. Although an embodiment of the invention may achieve multiple objectives, not every embodiment falling within the scope of the attached claims will achieve every objective. Moreover, the scope of the present application is not intended to be limited to the particular embodiments of the process, machine, manufacture, composition of matter, means, methods and steps described in the specification. As one of ordinary skill in the art will readily appreciate from the disclosure of the present invention, processes, machines, manufacture, compositions of matter, means, methods, or steps, presently existing or later to be developed that perform substantially the same function or achieve substantially the same result as the corresponding embodiments described herein may be utilized according to the present invention. Accordingly, the appended claims are intended to include within their scope such processes, machines, manufacture, compositions of matter, means, methods, or steps.
The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.
The corresponding structures, materials, acts, and equivalents of all means or step plus function elements in the claims below are intended to include any structure, material, or act for performing the function in combination with other claimed elements as specifically claimed. The description of the present invention has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the invention. The embodiment was chosen and described in order to best explain the principles of the invention and the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.
Patent | Priority | Assignee | Title |
Patent | Priority | Assignee | Title |
6567815, | Aug 01 2000 | GOOGLE LLC | Technique of clustering and compaction of binary trees |
6681200, | Feb 26 2001 | CLUSTER, LLC; Optis Wireless Technology, LLC | Method for measuring system clock signal frequency variations in digital processing systems |
6934907, | Mar 22 2001 | International Business Machines Corporation | Method for providing a description of a user's current position in a web page |
6976021, | Jul 19 2001 | Riverstone Networks, Inc. | Method, system, and computer program product for managing a re-usable resource with linked list groups |
7225186, | Mar 26 2004 | Kyocera Corporation | Binary search tree system and method |
7624304, | Oct 07 2004 | Microsoft Technology Licensing, LLC | Defect detection for integers |
20020138515, | |||
20020198886, | |||
20050050060, | |||
20050216445, | |||
20060271541, | |||
20080304421, | |||
20080313196, |
Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
Oct 09 2008 | PECKHAM, STEPHEN B | International Business Machines Corporation | ASSIGNMENT OF ASSIGNORS INTEREST SEE DOCUMENT FOR DETAILS | 021683 | /0313 | |
Oct 10 2008 | International Business Machines Corporation | (assignment on the face of the patent) | / |
Date | Maintenance Fee Events |
Aug 05 2016 | REM: Maintenance Fee Reminder Mailed. |
Dec 25 2016 | EXP: Patent Expired for Failure to Pay Maintenance Fees. |
Date | Maintenance Schedule |
Dec 25 2015 | 4 years fee payment window open |
Jun 25 2016 | 6 months grace period start (w surcharge) |
Dec 25 2016 | patent expiry (for year 4) |
Dec 25 2018 | 2 years to revive unintentionally abandoned end. (for year 4) |
Dec 25 2019 | 8 years fee payment window open |
Jun 25 2020 | 6 months grace period start (w surcharge) |
Dec 25 2020 | patent expiry (for year 8) |
Dec 25 2022 | 2 years to revive unintentionally abandoned end. (for year 8) |
Dec 25 2023 | 12 years fee payment window open |
Jun 25 2024 | 6 months grace period start (w surcharge) |
Dec 25 2024 | patent expiry (for year 12) |
Dec 25 2026 | 2 years to revive unintentionally abandoned end. (for year 12) |