EP1889159A2

EP1889159A2 - Method for managing memories of digital computing devices

Info

Publication number: EP1889159A2
Application number: EP06742576A
Authority: EP
Inventors: Michael Roth
Original assignee: Rohde and Schwarz GmbH and Co KG
Current assignee: Rohde and Schwarz GmbH and Co KG
Priority date: 2005-06-09
Filing date: 2006-04-12
Publication date: 2008-02-20
Also published as: DE102005026721A1; JP2008542933A; CA2610738A1; US20080209140A1; WO2006131167A3; CN101208663A; CN101208663B; WO2006131167A2; KR20080012901A

Abstract

The invention relates to a method for managing memories. When carrying out a process, at least one stack (6, 7, 8, 9) is created for memory objects (10.1, 10.2, ... 10.k). A request for a memory object (10.k) from a stack (6, 7, 8, 9) is carried out by using an atomic operation, and a return of a memory object (10.k) to the stack (6, 7, 8, 9) is likewise carried out by using an atomic operation.

Description

Method for memory management of digital computing devices

The invention relates to a method for managing memory of digital computing device.

Modern computing facilities allow the use of complex programs due to the large existing memory and the enormous computing power. Through these programs, processes run on the computing device, within which several so-called threads are processed simultaneously. Because many of these threads are not synchronized with each other in time, multiple threads may simultaneously attempt to access memory management, potentially accessing a particular block of available memory. Such concurrent access can lead to system instability. However, intervention of the operating system can prevent such simultaneous access to a particular memory block. The prevention of access to a memory block already in access by another thread is described in DE 679 15 532 T2. In this case, simultaneous access is prevented only if the simultaneous access concerns the same memory block.

For example, in common memory management systems, so-called double-linked lists are frequently used to manage the entire storage volume in individual storage objects. With these doubly linked lists, access to a specific storage object takes place in several steps. It is therefore necessary to block the remaining threads with the first access to such a memory object, so that simultaneous access by another thread is not possible before the individual steps of the first access have been processed. This access locking is done with the help of the operating system through a so-called Mutex routine. By incorporating the Operating system and running the mutex routine, however, lost precious computing time. During this time, the remaining threads are blocked by temporarily being prevented from running by Mutex-based locking from the operating system.

It is the object of the invention to provide a method for managing memory of a digital arithmetic unit, in which in a multithreaded environment the concurrent access by concurrent threads to a particular memory block is impossible, but at the same time allows short memory access times.

The object is achieved by the method according to claim 1.

Instead of doubly linked lists, according to the invention a stack management is used for the available memory. For this purpose, at least one such stack is initially created in the available memory area. The inclusion and return of a storage object by a thread is then carried out by one atomic operation. By using such an atomic operation for the memory access together with a stack organization of the memory which only allows access to the last object of the stack, a further blocking of the remaining threads is not required. It is already ensured by the atomic operation that the access to the memory object takes place in only a single step, whereby an overlap with parallel steps of further threads can not occur.

Advantageous developments of the method according to the invention are claimed in the subclaims.

A preferred embodiment is shown in the figures and will be explained in more detail in the following description. Show it: Figure 1 is a schematic representation of a known memory management with double-linked lists.

Fig. 2 is a memory management means of stacking and atomic recording and return functions and

Fig. 3 is a schematic representation of the process sequence of the invention

Memory management.

In so-called double-linked lists, the memory is divided into a plurality of memory objects 1, 2, 3 and 4, which are shown schematically in FIG. Within each such memory object 1 to 4, a first field Ia and a second field Ib are applied. In this case, the first field 1a of the first memory object 1 refers to the position of the second memory object 2. Likewise, the first field 2a of the second memory object 2 refers to the position of the third memory object 3 and so on. , In order to enable the inclusion of any middle block, the position of the next storage object is not only indicated in the forward direction, but in the second field 2b, 3b and 4b of the storage objects 2, 3 and 4, the position of the respective preceding storage object 1, 2 and 3 indicated. In this way, it is possible to take out a memory object arranged between two memory objects and at the same time to update the fields of the adjacent memory objects.

While such dual-linked lists allow for individual access to any storage object, they also have the disadvantage that in a multithreaded environment, concurrent access to multiple threads on a storage object is only to be prevented with slow operations. One possibility is the management of the already described in the introduction Accesses via the mutex function. The first memory object 1 in a list can be reached by a special pointer 5 and is also characterized in that a zero vector is stored in the second field Ib instead of the position of a preceding memory object. Accordingly, the memory object 4 is identified last by storing a zero vector instead of the position of a further memory object in the first field 4a of the memory object 4.

In contrast, FIG. 2 shows an example of a memory management according to the invention. In the case of the memory management according to the invention, at first an initialization preferably creates a plurality of stacks or stacks. These stacks are a special form of simply linked lists. 2, four such stacks are shown, which are designated by the reference numerals 6, 7, 8 and 9. Each of these stacks 6 to 9 comprises a plurality of memory objects of different sizes. Thus, in the first stack 6 objects up to a size of 16 bytes, in the second stack 7 objects up to a size of 32 bytes, in the third stack 8 objects up to a size of 64 bytes and finally in the fourth stack 9 Objects can be stored up to a size of 128 bytes. If larger elements to be stored occur, stacks with larger memory objects can also be created, with the size of the individual memory objects preferably being doubled in each case to the next stack. The division of such a stack into individual memory objects 10 i is shown in detail for the fourth stack 9. The fourth stack 9 consists of a series of memory objects 10.1, 10.2, 10.3 ... to 10.k, which are simply linked together. The last memory object 10.k of the fourth stack 9 is shown slightly offset in FIG. An access to the individual memory objects is possible on all stacks 6 to 9 only for the lowest memory object of the stacks 6 to 9, for example on stack 9 only for the memory object 10. In Fig. 2, therefore, upon request of memory z. B. the last memory object 10 k of the fourth stack 9 are used. If the memory object 10 k is freed again because it is no longer needed by a thread, it will be returned accordingly at the end of the fourth stack 9.

In FIG. 2, this is represented schematically by a number of different threads 11, by which a memory requirement is given in each case. For example, in the particular embodiment, a process in multiple threads 12, 13, and 14 requests storage volumes of the same size. The size of the requested memory results from the data to be stored. In the illustrated embodiment, the fourth stack 9 is selected as soon as there is a memory requirement of more than 64 bytes up to a maximum size of 128 bytes. If a storage volume of, for example, 75 bytes is required by the first thread 12, then that one of the stacks 6 through 9 is selected, which contains a free storage object of suitable size. In the illustrated embodiment, this is the fourth stack 9. Here, memory objects 10. I having a size of 128 bytes are made available. Since the memory object 10. K is the last memory object in the fourth stack 9, a so-called "pop" operation is processed on the basis of the memory request of the first thread 12 and thus the memory object 10. k is made available to the thread 12.

Such a pop routine is atomic or indivisible, i. H. the memory object 10. k is removed from the fourth stack 9 for the thread 12 in a single processing step. This atomic or atomic operation, which maps memory object 10.k to thread 12, prevents another thread, such as thread 13, from accessing the same memory object

10. k can access at the same time. Ie. as soon as a new one Processing step can be performed by the system. the processing with regard to the storage object 10 k is completed and the 10 th storage object is no longer part of the fourth stack 9. In the case of a further storage request by the thread 13, then the last storage object of the fourth stack 9 is the storage object 10 k -1. Again, an atomic pop operation is performed to transfer the memory object 10.k-1 to the thread 13.

Such atomic operations require appropriate hardware support and can not be formulated directly in normal programming languages, but require the use of machine language. According to the invention, these hardware-implemented, but usually not used for memory management so-called lock-free-pop calls or lock-free push calls are used to manage memory. For this purpose, for example, instead of the double-linked lists, as shown schematically in FIG. 1, a singly linked list is used in which memory objects can only be retrieved or returned at one end of the applied stacks.

In FIG. 2, it is further shown for a number of threads 15, as after a delete call of a thread, the respective released memory object is given back to the appropriate stack. In each of the memory objects 10. I, there is a header 10. I _head , as shown for the memory object 10. K in FIG. 2, in which the assignment to a particular stack is coded. For example, the assignment to the fourth stack 9 is contained in the header 10.k _head . If a delete function is now called by a thread 16, which was assigned the memory object 10.k due to a corresponding lock-free-pop operation, then the memory object is activated by a corresponding, likewise atomic lock-free push operation 10. k returned. The storage object 10. k is appended to the last memory element 10 k belonging to the fourth stack 9. Thus, depending on the order in which different threads 16, 17, 18 return the memory objects 10.sub.i, the order of the memory objects 10.sub.i in the fourth stack 9 is changed.

It is crucial that these so-called lock-free-pop and lock-free-push calls are atomic and can therefore be processed extremely quickly. The speed advantage is crucially based on the fact that the use of an operating system operation, such as Mutex, is not required to exclude additional threads from concurrent access to a specific storage object. Such an exclusion for concurrent access by further threads is due to the atomic property of the pop. Push calls not required. In particular, the operating system does not have to perform a thread change in the case of an actually simultaneous access to the memory management (so-called contention case), which requires much more computation time than the memory operation itself.

With such management of stacks and accesses using lock-free-pop and lock-free-push calls, it is inevitable that part of the existing storage volume will be wasted. This waste is caused by the size of the individual stacks or their storage objects, which is not ideally adapted. If a certain size structure of the data to be stored is known, however, the distribution of the memory object sizes of the individual stacks 6 to 9 can be adapted to this.

According to a particularly preferred form of the memory management according to the invention, it is provided that at the beginning of a process, for example after a program start, the stacks 6 required for the process flow 9 are merely initialized, but at this point in time there are no memory objects 10. If a memory object of a certain size is needed for the first time, for example a memory object of the third stack 8 for a 50-byte element to be stored, this first memory request is processed via the slower system memory management and the memory object is made available therefrom. Concurrent access is prevented in the illustrated example of doubly linked lists as system memory management by a slow mutex opertation. However, the memory object made available in this way to a first thread is not returned again via the slower system memory management after a delete call, instead the third stack 8 is locked onto a corresponding stack, in the exemplary embodiment described by a lock-free push Operation filed. For the next invocation of a storage object of this size, therefore, this storage object can be accessed with a very fast lock-free-pop operation.

This procedure has the advantage that it is not necessary to allocate a fixed number of storage objects to the individual stacks 6, 7, 8 and 9 at the start of a process. Rather, the memory requirement can be dynamically adapted to the running process or its threads. For example, if a process runs in the background with few concurrent threads and has little need for memory objects, then resources are significantly reduced in such an approach.

The method is shown schematically once again in FIG. First, in step 19, a program is started, thus generating a process on, for example, a computer. At the beginning of the process, multiple stacks 6 through 9 are initialized. The initialization of the stacks 6-9 is shown in step 20. In the in 3 illustrated embodiment of the process flow initially only individual stacks 6-9 are created, but without filling them with a certain predefined number of memory objects. In the case of a memory request by a thread occurring in method step 21, a corresponding stack is first selected on the basis of the object size defined by the thread.

If, for example, a 20-byte memory object is required, the second stack 7 is selected in the stack selection of FIG. Subsequently, in step 23, the atomic pop operation is performed a query. Part of this atomic operation is a query 26, whether in the second stack 7, a memory object is available. In the event the stack 7 having a size of 32 bytes per storage object is merely initialized but does not yet contain an available memory object, a null vector ("NULL") is returned and a memory object is accessed through a system call in step 24 through slower system memory management Size 32 bytes provided. However, the size of the provided storage object is not determined directly by the thread in step 21, but via the selection of a particular object size in step 22, taking into account the initialized stack.

Thus, in the described embodiment, the memory request is changed to request a memory object of size 32 bytes. In order to prevent concurrent access to this memory object during recording by the thread, would

Example of system memory management using dual-linked lists through the operating system, a mutex

Operation started.

On the other hand, if the required storage object is an already returned during the process Memory object, this is already in the second stack 7 before. The query in step 26 would therefore have to be answered with "yes" and a storage object is immediately delivered. For the sake of completeness, the return of the same on the basis of a delete call is shown in the further course of the method both for a memory object made available by means of a lock-free-pop call and via the system memory management. The process following a thread's delete call is the same for both situations. Ie. In this case, no account is taken of the way in which the storage object was made available. In Fig. 3, this is schematically represented by the two parallel paths, wherein on the right side painted reference numerals are used.

First, a thread starts a delete call. The corresponding memory object is assigned to a specific stack by evaluating the information of the header of the memory object. Consequently, in the described embodiment, the memory object of size 32 bytes is assigned to the second stack 7. The return of the memory object to the second stack 7 takes place in both cases via a lock-free-push operation 29 or 29 '. The last method step 30 indicates that the memory object of the second stack 7 returned in this way is thus available for a next call. This next call can then, as already explained, be made available to a thread by a lock-free-pop operation.

As already described, in the initialization of stacks 6 through 9, a reduction in memory waste can be achieved by creating frequency distributions for requested object sizes. This can also be defined during the execution of different processes for the individual processes. Will such a process with his concurrent threads are started once again, the previously determined frequency distribution from the previous process run is used to allow an adapted size distribution of the stacks 6 to 9. The system can be self-learning, ie with each new pass, the knowledge gained about the size distributions of the memory requirement is updated and the updated data are used each time the process is called.

The invention is not limited to the illustrated embodiment. Rather, any combinations of the individual explanatory features are possible.

Claims

claims

1. A method for managing memory with the following method steps: - creating at least one stack (6, 7, 8, 9) for memory objects (10.1, 10.2, ... 10k);

Executing a request for a memory object (10.k) from a stack (6, 7, 8, 9) by means of an atomic operation and - returning a memory object (10.k) to the stack (6, 7, 8, 9) an atomic operation

2. The method according to claim 1, characterized in that a plurality of stacks (6, 7, 8, 9) for each different memory object sizes (16 bytes, 32 bytes, 64 bytes, 128 bytes) are created.

3. The method according to claim 1 or 2, characterized in that prior to the recording of a memory object (10.k) of the respective stack (6, 7, 8, 9) with respect to a memory requirement next larger memory object size (16 bytes, 32 bytes, 64 Byte, 128 bytes) is selected.

4. The method according to any one of claims 1 to 3, characterized in that after initialization of the stack (6, 7, 8,9) in the stacks (6, 7, 8, 9) initially no memory objects (10.i) exist and a storage object is requested via a system memory management in each case for a first-time storage volume request, and this storage object is assigned to a stack (6, 7, 8, 9) when it is returned.

5. The method according to claim 4, characterized in that before the request of the memory object on the

System memory management the size of the memory object is determined by the size of the initialized stacks (6, 7, 8, 9) and the current storage volume requirement.

6. The method according to any one of claims 1 to 4, characterized in that for determining the sizes of the memory objects (lO.i) of the stack (6, 7, 8, 9) a Häfugkeitsverteilung the memory object sizes is updated during a process and at one again Execution of the process based on the updated frequency distribution on the initialization of the stack (6, 7, 8, 9).

7. A digital storage medium with electronically readable control signals, which can cooperate with a programmable computer or digital signal processor of a telecommunication device, that the method according to one of claims 1 to 6 is executed.

A computer program product having program code means stored on a machine-readable medium for carrying out all the steps according to any one of claims 1 to 6 when the program is executed on a computer or a digital signal processor of a telecommunication device.

A computer program comprising program code means for carrying out all the steps according to any one of claims 1 to 6 when the program is executed on a computer or a digital signal processor of a telecommunication device.

A computer program with program code means for performing all the steps according to one of claims 1 to 6 when the program is stored on a machine-readable medium.