Method for prefetching recursive data structure traversals

• US 20050102294A1
• Filed: 01/03/2001
• Published: 05/12/2005
• Est. Priority Date: 01/03/2000
• Status: Active Grant

• Current Assignee: Digital Cache, LLC (Oso IP, LLC)
• Original Assignee: Paonessa Research LLC (Intellectual Ventures LLC)
• Inventors: Coldewey, Dirk
• Granted Patent: US 7,058,636 B2
• Time in Patent Office: Days
• US Class Current: 1/1
• CPC Class Codes: G06F 12/0862 with prefetch
• CPC Class Codes: G06F 16/9024 Graphs; Linked lists G06F16/9027 takes precedence
• CPC Class Codes: G06F 16/9027 Trees
• CPC Class Codes: G06F 8/4442 Reducing the number of cache misses; Data prefetching cache prefetching G06F12/0862
• CPC Class Codes: Y10S 707/99933 Query processing, i.e. searching

Abstract

Computer systems are typically designed with multiple levels of memory hierarchy. Prefetching has been employed to overcome the latency of fetching data or instructions from or to memory. Prefetching works well for data structures with regular memory access patterns, but less so for data structures such as trees, hash tables, and other structures in which the datum that will be used is not known a priori. In modern transaction processing systems, database servers, operating systems, and other commercial and engineering applications, information is frequently organized in trees, graphs, and linked lists. Lack of spatial locality results in a high probability that a miss will be incurred at each cache in the memory hierarchy. Each cache miss causes the processor to stall while the referenced value is fetched from lower levels of the memory hierarchy. Because this is likely to be the case for a significant fraction of the nodes traversed in the data structure, processor utilization suffers. The inability to compute the address of the next address to be referenced makes prefetching difficult in such applications. The invention allows compilers and/or programmers to restructure data structures and traversals so that pointers are dereferenced in a pipelined manner, thereby making it possible to schedule prefetch operations in a consistent fashion. The present invention significantly increases the cache hit rates of many important data structure traversals, and thereby the potential throughput of the computer system and application in which it is employed. For data structure traversals in which the traversal path may be predetermined, a transformation is performed on the data structure that permits references to nodes that will be traversed in the future be computed sufficiently far in advance to prefetch the data into cache.

Claims

1. A method for creating a linked list data structure to which prefetching can be applied in order to minimize the number cache misses endured during traversal, said method comprising the steps of:

creating a parallel data structure consisting of a plurality of partitions (N) consisting of a plurality of sublists (P), associating a state vector (S) with the data structure to maintain the state of the traversal of each sublist, and maintaining the state of the last sublist to which an element is added in a variable (H), whereby additions are made to the the head of the list by decreasing the list head index to H−

1 modulo P and adding new nodes to the head of the list indexed by the thus updated value of the head index.

pipelining the traversal across the N partitions of the data structure;

determining the prefetch distance required in order to traverse said data structure using the aforementioned pipelined traversal, said prefetch distance being determined experimentally by the programmer, computed using prior art, or by the compiler;

inserting prefetch instructions into the traversal loop body.

2. The method for creating a data structure according to claim 1 wherein the data structure is provided as part of a library.

3. The method for creating a data structure according to claim 1 wherein a data structure defined by an application is transformed by a compiler, said compiler performing the necessary steps to modify corresponding traversal code to perform software pipelined prefetching.

4. The method of creating a data structure according to claim 1 wherein the data structure is generated by a set of macros.

5. The method of creating a data structure according to claim 1 wherein the method of creating such a data structure is supplied as part of a class library in an object oriented system.

6. The method of creating a data structure according to claim 1 wherein the steady state loop is preceded by a prologue which performs no data structure traversal, but which does generate prefetch instructions.

7. The method of creating a data structure according to claim 1 wherein the steady state loop is followed by an epilogue in which no prefetch instructions are performed, but in which traversal of the data structure continues and possibly completes.

8. The method of constructing a linked list according to claim 1 wherein additions to the end of the list are added to the end of the sublist indexed by I modulo P and the list header index H updated to H +1 modulo P.

9. The method of constructing a linked list according to claim 1 wherein

a variable (I) holds the index of the last sublist to have an element inserted,

an array containing P pointers, said pointers linking to the tail of each sublist,

insertion at the tail of the list is performed by the method consisting of

updating the list tail index (T) to T+1 modulo P

and adding a node to the sublist indicated by the new value of T,

and whereby deletion from the tail of the sublist is performed by the method consisting of

updating the list tail index (T) to T−

1 modulo P

and deleting the node from the tail of the sublist indicated by the new value of T.

10. The method of traversing the linked list constructed according to claim 1 whereby the linked list is traversed by the method comprising the steps of

prefetching the head of each sublist;

initializing a vector (S) with the head of each sublist;

traversing the list in a software pipelined manner by

iterating over S and processing each node held in S,

performing the requested work on each node held in S,

updating each element of S to hold the next element in the corresponding sublist,

and issuing a prefetch for the next node in each sublist.

11. The method of traversing a tree according to the method of claim 1 wherein a tree is constructed as a forest of trees.

12. The method of constructing a pre-order traversal tree according to the method of claim 1 comprising

a plurality of trees (P);

an array in which to store a pointer to the root node of each tree;

a variable (T) holding the value of the last tree into which a node was inserted;

the method of adding a node to the forest by assigning the value T+1 modulo P to the variable T and using a normal insertion into the tree indexed by the value of T thus updated;

the method of traversing the forest in pre-order fashion.

13. The method of traversing a single tree by creating a forest of subtrees by the method comprising the steps of:

initiating a level-order traversal starting at the root,

maintaining an array of pointers to nodes in the tree in the course of the level-order traversal,

discontinuing the level-order traversal when a number of subtrees sufficient for effective software pipelined traversal has been achieved, the aforementioned array of pointers thereby containing the pointers to the roots of the trees of a forest to which software pipelined traversal can be applied,

then proceeding with a traversal wherein a tree is constructed as a forest of trees, wherein subtrees pointed to by the aforementioned array of subtrees constitute the forest across which software pipelined traversals are performed.

optionally updating the array of pointers to subtrees when additions and deletions to the tree that cause the tree to be modified beyond the addition of a new leaf node (such as rebalancing inherent to a red-black tree).

14. The method of traversing a single tree according to claim 13 wherein the children of each node encountered in the course of the level order traversal are prefetched.

15. The method of deconstructing a tree into a forest according to claim 13 whereby

a queue is used to hold the nodes of the current level of an in-order traversal of the tree, said node being added to said queue as they are encountered in the course of the traversal of each level,

a second queue is used to hold pointers to the children of the nodes at the current level,

said queues swap roles as the traversal transitions from one level to the next,

and the forest is constructed from the subtrees rooted at the nodes pointed to by the contents of the aforementioned two queues.

16. The method of traversing a single tree according to claim 15 wherein the children of each node encountered in the course of the level order traversal are prefetched.