Abstract:
A method for managing multi-layered data structures in a pipelined memory architecture, comprising the steps of: —providing a multi-level data structure where each level corresponds to a memory access; —storing each level in a separate memory block with respect to the other levels. In this way, a more efficient usage of memory is achieved.

Description:
This application is a national phase of International Application No. PCT/SE2010/050871 filed Jul. 28, 2010 and published in the English language. 
     TECHNICAL FIELD 
     The present invention relates to a method for managing multi-layered data structures in pipelined memory architecture. 
     BACKGROUND 
     To achieve a more efficient usage of memory, it is desirable that all different kinds of data structures require the same amount of memory from each level (layer). While this is not possible, the second best approach would be to ensure that a group of (say t instances) from a certain type of data structure uses a fixed amount of memory from each level. In fact, it would be even better if each group from each kind of structure occupies exactly the same amount of memory in each memory bank. 
     Thus, there is a demand to solve the problem with usage of memory of a multi-layered data structure. 
     SUMMARY OF THE INVENTION 
     An object of the present invention is to solve the problem(s) stated above. 
     To achieve this, we let t instances from each type of data structure will constitute a group of said type. Each instance within the group is referred to by a number between 0 and t−1, called the instance number and the group as a whole is referred to by a group pointer. The group pointer refers to the first memory block within each memory bank that contains data from one instance within the group. Preferably, the memory and groups are organized such that the first memory block of each group, in the different banks, begins at the same offset. Therefore, the group pointer is merely an offset from the beginning of the memory. 
     Further objects and advantages with the present invention will be described as follows in relations to embodiments of the present invention being described as follows. 
    
    
     
       BRIEF DESCRIPTION OF DRAWING FIGURES 
       The present invention will now be described in more detail referring accompanying drawing figures of which: 
         FIG. 1  illustrates three memory banks configured to store four instances of 2-structures. 
         FIG. 2  illustrates one instance of a 4-structure in the memory banks configured for 2-structures, wherein the  7  unused memory blocks are shown as crossed black squares. 
         FIG. 3  illustrates group consisting of four instances of four level 2-structures stored according to an embodiment of the present invention. 
     
    
    
     DESCRIPTION OF THE INVENTION 
     The purpose of the following invention is to manage layouts of multi-level data structures where each level corresponds to a memory access and is stored in a separate memory bank with respect to the other levels. Furthermore, the size (measured in some appropriate memory size unit such as bytes, memory blocks, cache lines etc.) of the memory of each level from each type or kind of data structure is completely determined by the order in which the levels are accessed. 
     Let S[0], S[1], . . . , S[t−1] be the size of level 0, 1, . . . , t−1 of a certain type of data structure. When lookup is performed in the data structure, level 0 is accessed in the first memory access, level 1 in the second memory access, and so forth until level t−1 is accessed in memory access t, which completes the lookup. 
     Now suppose that we store n instances of such data structures in a memory structure consisting of t memory banks 0, 1, . . . , t−1 of sizes M[0], M[1], . . . , M[t−1], respectively. 
     A straight forward approach is to organize this such that memory bank 0 contains level 0 from all instances, bank 1 contains level 1 from all instances, and so on until bank t−1 which contains level t−1 from instances. 
     In many cases, the sizes of the different levels in of one type of data structure are extremely different, in fact, it is not uncommon that the size is a function which is exponential in the level. That is, S[i]=B^i for some non-negative integer B. If only one type of data structure is used, this is not necessarily a problem (even though a hardware engineer would most likely argue that the size of each level should be the same.). However, if several different kinds of data structures needs to be stored, the sizes of each memory bank must be configured either to accommodate for one of the kind or for the other kind. 
     Now is referred to the drawing  FIGS. 1-3 . 
     In either case, there is a risk that a large part, or all, of the provided memory will store data structures of the other kind, rendering a large part of the memory unused. 
     To further illustrate this problem, consider two types data structures with B=2 and B=4. Let us refer to these as 2-structures and 4-structures, respectively. Furthermore, assume that both of these types each consists of three levels. 
     If the memory is configured for 2-structures we have that M[2]=2×M[1]=4×M[0] (see Drawing 1). Now, if we store a 4-structures instead of 2-structures, level 2 of a single 4-structure will occupy the entire bank 2 which means that we can only store one 4-structure. As a result, there will be unused memory in bank 0 and 1 (see Drawing 2). 
     From this organization, it follows that the memory occupied by each group in each memory bank is the exactly the same amount as required to store all levels from one instance of the type of data structure. That is each group will use S[0]+S[1]+ . . . +S[t−1] blocks of memory from each memory bank. 
     Instances are stored in the memory banks with level 0 from each instance stored at the beginning of the group memory (i.e. the memory location at offset group pointer from the beginning of the memory bank). Level 0 from instance number i is stored in memory bank i. This is followed by level 1 which is stored directly after level 0 in each bank such that level 1 from instance i is stored in bank (i+1) MOD t. This is continued until level t−1 from each instance is stored at the end of the group memory in the respective memory bank. 
     Drawing 3 shows an example of a group of four 2-structures, each of four levels, organized this way. Each instance is shown in a separate shade of gray. 
     The present invention is by no means limited to the particular embodiment described and illustrated in relation to  FIG. 3 . 
     As already disclosed above, it would be a great advantage if each group from each kind of structure occupies exactly the same amount of memory in each memory bank. This is accomplished by means of the present invention.