DE102004013180A1 - Garbage collection for smart cards - Google Patents

Abstract

The invention provides a method of searching dynamically allocated heap memory for referenced or unreferenced objects, wherein a heap memory scan is performed using an algorithm that operates without recursion. The method is particularly useful in automatic garbage collection. For the recursion-free algorithm, the memory requirement for executing the algorithm can be determined before the runtime. Therefore, the method is particularly for computer systems with limited storage resources such. B. Smart Card suitable. Also indicated is a corresponding data carrier, in particular smart card, z. B. Java Card in which the method is implemented.

Description

The The invention relates to a method for automatic garbage collection (Garbage Collection), in particular a Tracing Collector, and a method used to search dynamically allocated Heap memory for referenced or unreferenced objects, especially for Computer systems with low system resources (data carriers), such as e.g. Smart cards (chip cards), as well as a corresponding data carrier.

One disk, In particular smart card, in particular Java Card, typically has a microprocessor, multiple memories, e.g. ROM, EEPROM and RAM, where ROM and / or EEPROM partially or entirely by flash memory can be replaced and one or more interfaces.

One on a computer system running program (computer program) allocates memory, i. allocates memory, in which executes the program's individual program code instructions.

Of the Memory leaves into a statically allocated memory and a dynamic one Divide allocated heap memory. The statically assigned Memory is allocated before the program expires, e.g. during the Compiling or linking the program, whereas the dynamic allocated heap memory while assigned to the duration of the program, i. while the program code expires.

To the statically allocated memory counts - at least partly - the Stack memory, on the e.g. Variables when calling methods (e.g., algorithms) be created. Such methods can, for example, methods be, which have an automatic garbage collection to the object (see below).

Object-oriented programming languages, such as Java ^TM from Sun Microsystems, dynamically allocate memory during program runtime in such a way that objects are created in the heap memory (in the case of Java Cards usually in the EEPROM or possibly Flash memory).

each Object can contain one or more references to other objects, which in turn can have references to other objects. By the references of objects to other objects have the objects in the heap memory among each other a tree-like organization structure (Tree structure).

Such a tree-like organization structure, which is also called heap structure, is in 1 shown. At the root, or in other words at the zeroth hierarchical level of the organizational structure, the root object is located in 1 So the object with the number one ( 1 ). In the case of differently structured heap structures, there may alternatively be several root objects, which are also referred to as start objects, with each root object or start object starting its own tree-like organizational structure. Any reference to an object from the root object represents the input to a branch of the tree. In the heap structure of 1 are starting from the root object 1 six objects 2 . 20 . 14 . 26 . 25 and 35 so that the heap structure has six branches. All objects that are connected to the root object directly or indirectly (ie via further objects) via the tree-like organization structure (called referenced objects) can be reached from the root object. Non-referenced objects, ie objects that have no connection via references to the root object, are not accessible from the root object. In 1 are eg the objects 31 . 32 . 33 . 29 . 30 . 23 and 24 not referenced and therefore not reachable from the root object.

The objects directly referenced from the root object form the objects of the first hierarchy level. The objects referenced by objects of the first hierarchical level form objects of a second hierarchical level, and so on. Each branch of the tree has a depth equal to the number of levels below the zeroth hierarchical level (root level) in that branch. In 1 Eg is the depth of the branch of object 1 to object 5 four, the depth of the branch of object 1 to object 7 also equal to four, the depth of the branch of object 1 to object 8th equal to three etc.

With reference to 1 a forward-looking heap structure is organized such that for each given object (eg, object of an i-th hierarchy level) each of the given object re The identified object (hence object of the (i + 1) -th hierarchical level) has a larger index than the given object of the i-th hierarchy level. However, it may happen that a heap structure with backward references is created. A backward reference is distinguished in that an object (an i-th hierarchical level) has a higher index than an object referenced by that object (the underlying (i + 1) -th hierarchical level). Out in the heap structure 1 lies, for example, between the pair of objects ( 9 . 6 ) provide a backward reference. Because the object no. 9 The second hierarchical level has a higher index than that of object no. 9 referenced object no. 6 the underlying third hierarchical level. Likewise, between the object pairs ((i), (i + 1)) = ( 9 . 8th ) 40 . 37 ) 40 . 38 ) 38 . 36 ) 35 . 34 ) and ( 34 . 19 ) of referencing object (i) and referenced object (i + 1) each provide a backward reference.

Not more used heap memory (dynamically allocated memory) must be released (deallocated) again for new objects again heap memory to disposal stands. Object-oriented programming languages can and should in particular the one occupied by non-referenced objects Space will be freed up because these objects are not are more accessible and thus "garbage" (garbage) are.

A Series of object-oriented programming languages, for example Java, Smalltalk, Eiffel, Oberon, Perl, Python, Visual Basic and more, have automatic garbage collection, in which non-referenced objects are detected and by it automatically re-allocated dynamically allocated heap memory becomes.

The The simplest form of automatic garbage collection is the Reference Counting Garbage Collection or the Reference Counting Collector, where each object contains a reference counter. The counter reading of the reference counter gives how many references are directed to the object. For every reference generated on the object is the count counted up by one, and for every one deleted Reference to the object, the count is counted down by one. objects their reference counter a meter reading has zero, are classified as garbage and deleted or The space occupied by the garbage objects becomes free available Allocated heap memory.

Next Reference Counting Collectors, there are the Tracing Collectors, at which references from the root class (root class) of the heap memory to be traced ("traced").

at the garbage collections of type Tracing Collector makes the mark-and-sweep collector the most fundamental Algorithm. At the mark-and-sweep Collector will first, in the so-called mark phase, the heap memory searches for references, taking objects to which no references were found, identified and marked. The search for References starts at the root object of the heap memory and works from there hierarchically through the entire heap memory by. The marked in the Mark phase objects are in the following Sweep phase cleared.

at two other forms of automatic garbage collection (garbage Collection) of type Tracing Collector, the Compacting Collectors and the Copying Collectors, the heap memory is at garbage collection additionally defragmented.

Either Compacting Collectors and Copying Collectors start with one Search the heap for references, except that not here the unreferenced "dead" objects sought but the "living" objects to which still references are directed (referenced objects).

at Compacting Collectors become the found referenced objects ("living" objects) to one Moved towards the end of the heap memory and compacted there. Thereby At the opposite end of the heap memory, a large coherent arises Storage area. Subsequently all references to moved objects are updated.

at Copying Collectors will find all referenced ("live") objects of theirs previous old storage area into a new storage area copied and without gaps joined. Thereby the new storage area is contiguous, that is defragmented. The old memory area is declared as a freely available memory area.

So far, methods for automatic garbage collection - with exceptions - are mostly limited to large computer systems. For computer systems with low system resources such as Smart cards often do not provide enough memory for automatic garbage collection.

In the common, in 1 In the method of searching the heap memory for referenced objects used in mark-and-sweep garbage collection, starting from the root object, each branch of the heap structure is sequentially searched for referenced objects, each referenced being found Object is marked as referenced (and therefore reachable) object. According to 1 For searching and marking, first a corresponding search and marking algorithm is called for the root object and the root object (in 1 object 1 ). Then, one by one for each branch, the search and mark algorithm is called recursively for all hierarchy levels below the zeroth hierarchical level (root level) until the end of the branch is reached. In 1 For example, for the first branch, the search and mark algorithm is called recursively for the object 2 the first hierarchy level, for the object 3 the second hierarchy level, for the object 4 the third hierarchy level and finally for the object 5 the fourth hierarchical level. Subsequently, in the example of 1 that searches sub-branch, which is different from object 2 to object 7 extends, recursively calling the algorithm again. To last, in the example of 1 searching the branch, which differs from object 1 to object 19 extends. The maximum depth of the tree 1 is equal to five and is realized in the branch that is different from object 1 to object 36 extends.

In the example off 1 are the objects 31 . 32 . 33 . 29 . 30 . 23 and 24 not referenced and therefore "garbage".

Of the Storage requirements for a recursive algorithm like the one described above, where the algorithm is repeated again and again within the algorithm is called, lets do not determine in advance, as set out below. This is one of the reasons why the conventional one recursive algorithm usually does not readily work on a computer system with low system resources such as a smart card transferable is.

each Object needed in a tree structure a single bit, ie 1/8 byte, for a flag marked with whether the object is referenced or not. A tree structure needed with n objects thus n / 8 bytes of memory (statically allocated RAM) for the tag of the objects as referenced or not referenced. In the application of the search and mark algorithm becomes a branch of the tree structure for each Call the algorithm and thus for each hierarchy level a number from v bytes for used local variables. For becomes a branch of the depth d ' hence a number of d '· v bytes at memory for Variables needed. To be considered Here is that the variables of an already fully searched branch overwritten again can be if the next one Branch of the tree is searched as the individual objects the searched branch already referenced or not referenced are marked. Relevant for the memory requirement for Variables is thus the depth of the branch of the tree structure with the maximum depth d.

n:

= Anzahl der Objekte in der Baumstruktur

d:

= maximale Tiefe der Baumstruktur

v:

= Anzahl von Bytes, die bei dem Algorithmus für lokale Variablen verwendet werden (konstant pro Algorithmus-Aufruf)

rc:

= Speicherbedarf in Byte.

So be for a tree like the one in 1 illustrated

n:

= Number of objects in the tree structure

d:

= maximum depth of the tree structure

v:

= Number of bytes used in the local variable algorithm (constant per algorithm call)

rc:

= Memory required in bytes.

Then the memory requirement rc of the algorithm in bytes, rc = n / 8 + dv (1)

Of the Memory requirement of the recursive search and mark algorithm depends thus from the maximum depth of the tree, which is still unknown is as long as the tree structure has not been completely searched. Consequently lets the memory requirements of the conventional recursive search and mark algorithm, e.g. in the conventional Mark-and-sweep garbage collection is used, not in advance, before searching the tree structure and thus before the runtime of the algorithm.

at Computer systems with generously sized System resources (memory and / or computational power) such as e.g. PCs, Workstations or servers use a recursive search and mark algorithm in doubt, over-abundant Memory, especially stack memory allocated.

In front everything for Computer systems with low system resources, e.g. Smart Cards, the total available Memory may be not enough to be overflowing in case of doubt Allocate memory. Therefore it is desirable to have the memory required an algorithm for to know in advance the automatic garbage collection to determine whether the algorithm is executable on the computer system at all, i.e. accomplished and to prevent the memory from overflowing and in a row when running of the algorithm errors occur in the program flow.

outgoing From this, the invention is based on the object, a method for automatic garbage collection and on method used thereby to search dynamically allocated Heap memory for referenced or unreferenced objects to create in which the memory requirement (memory requirement) for the execution the garbage collection in advance, before the execution of the method, determined is.

The Task is solved by a method according to the independent method claim. Advantageous embodiments of the invention are specified in the dependent claims.

at the method according to the invention according to claim 1 objects are created in dynamically allocated heap memory. Unreachable objects on the heap memory are meant to be the method according to the invention which systematically searches the heap memory for this purpose. According to the independent claim 1, the search of the heap memory is performed by means of an algorithm which works without recursion.

Thereby, that no recursion was performed is, the algorithm is called only once, without that he nested within the algorithm called again becomes. The number of bytes required by the local variable algorithm becomes set in advance as needed and is therefore already before calling the algorithm known. Because the algorithm only once is called, needed the algorithm for local variables total a number of only exactly one time v bytes (instead of maximum tree depth times v bytes in the conventional recursive procedure). Therefore, in the method according to the invention the memory required to run the algorithm known in advance.

Therefore is according to claim 1 provides a method in which the memory requirement (demand for Memory), in particular the need for statically assigned or allocate memory (memory) for the procedure, in advance, before the execution the process, which is specific to systems with limited storage resources, such as. Smart Cards, is very beneficial.

through The referenced objects found in the algorithm preferably become marked, so that in a subsequent step the left over not referenced objects deleted can be e.g. by taking up the space occupied by the unreferenced objects as freely available Heap space is declared. Deleting the unreferenced ones Objects or releasing the memory occupied by them can in a sweep step as in the mark-and-sweep method. Alternatively you can the found referenced objects are saved, as with the Compacting Collector or Copying Collector, and the remainder Memory as freely available Heap memory to be declared. Optionally, the memory is added the garbage collection in addition defragmented.

Preferably each object is assigned a unique object index, by the object indexes of all heap memory objects are unique Order of objects is set. According to the algorithm, the Objects of the heap memory scanned in the order of their object indexes, regardless of a possibly underlying heap structure. The object index can e.g. a number or an alphabetical letter or a linear address his or another index, with further numbers, alphabet letters etc. forms a unique order.

Preferably the objects are numbered in the heap memory and are in the Scanned order of their numbering. By the numbering Each object has a unique object index assigned to it the object is uniquely addressable. In addition, every object index has a unique successor, so that through the object indexes of all Objects of the heap structure have a unique order of objects is fixed.

For the algorithm with objects with object index or numbering, the search of the He ap memory is performed strictly according to the object index or numbering of the objects, regardless of whether a branch of the heap structure is searched to the end or not. In contrast, in the conventional algorithm conventionally used, searching the heap memory in each branch of the heap structure according to which the heap memory is organized is performed until the end of the respective branch before starting to search the next branch, regardless of a numbering or indexing of the individual objects.

If the heap memory is free of backward references - in other words, if the heap memory is strictly forward - it is sufficient to search the memory once in the order of the object indexes or the numbering of the objects, preferably starting with the Root object used in a startup object, in an embodiment like the one in 3 shown eg with the number 1 , up to a last object, according to 3 for example, with the number 40 , If the root object has the highest number, the search is started, for example, at the highest number and performed to the object with the lowest number (eg one or zero). Found referenced objects are preferably marked in this case so that the non-referenced objects are left over. Subsequently, as described above, a cleanup step may follow.

alternative becomes a heap store that re the object indexes are forwarded according to the algorithm searched twice, the second time browsing being carried out for verification, that the algorithm can be terminated.

Provided the heap memory has one or more backward references, i. if the heap memory is relative the object indexes or numbering of its objects at least one Pair of referencing object (i) and referenced object (i + 1) which are mutually a backward reference (Backward Reference relationship) preferably the heap memory is searched at least twice.

Preferably the heap memory is in case he has at least one backward reference has searched one after the other at least once forward and once backwards.

alternative becomes a heap store that re the object indexes or numbering of its objects at least one Pair of referencing object ((i)) and referenced object ((i + 1)) having a backward reference to each other, at least searched three times, the last time (e.g., the third time) of the Searching for verification is performed that the algorithm can be terminated.

each referenced current object found by the algorithm (current object, unlike objects, by this current Object referenced) is preferably marked. That's it more preferably that the process is terminated once a run searching the entire heap memory is where no marking has been made. Optional will be after a pass in which no mark is made a re-run browsing pass as a scan pass made to check if indeed no markings are to be made. In both cases will in other words, that, an idle has been done in which no markings have been made, recognized that the procedure can be ended. In a strictly forward direction Heap memory is the re-run, i. the test run, preferably the second Run. For a heap memory with at least one backward reference the re-run, i. the test run, for example, the third pass of heap memory scanning, more common the last pass. Thereby the heap memory becomes according to need several times forward alternately and searched backwards. Each time you search, the algorithm will only be used once called, so the memory requirements (need for statically assigned Memory, especially stack memory) for the algorithm in advance can be determined. Each re-run of the search can the space the algorithm used in the previous run has occupied, again overwritten become. Therefore increased the memory requirement does not match the number of passes made by the Searching the store. In particular, backward references in heap memory, a multiple search of the heap memory, alternating forward and backwards, required do not make an increase the memory requirement.

Further Preferably, the marking of an object is in each case using carried out in a memory provided marking field, the for example, a predetermined number of bits or bytes in one Memory used for the algorithm accessible is, e.g. in the statically allocated stack memory.

According to one preferred embodiment has the check box for the current object a first data field and a second data field on, where the first data field (valid) is marked, if that current (found) object is referenced, and where the second Data field (scanned) is marked, if all of the current one Object outbound referenced objects thereby referenced are marked, that with these referenced objects the first Data field (valid) is marked. Each data field can e.g. as a Flag be formed. The flag is switched to mark the object, So depending on the implementation set or deleted.

The tag field according to the invention is preferably provided in RAM (Random Access Memory), unlike conventional methods for searching a heap memory. In conventional methods for searching a heap memory, to flag an object as referenced, a flag in the header of the object is set (switched) as by 2 is illustrated schematically. Since the header of the object is conventionally usually provided in the EEPROM, the conventional flag is also provided in the EEPROM. As a result, the conventional flag is slow and burdensome for the storage resources of a data carrier (smart card, chip module, chip, etc.) to which the method is applied (EEPROM can only be overwritten a limited number of times). The method with the preferred marking field according to the invention in RAM therefore has the additional advantage that it is particularly fast, since the writing time of a RAM is significantly lower than that of an EEPROM. In addition, the method with the preferred marking field according to the invention in RAM is particularly gentle on the memory resources of a data carrier in which the method is used.

Further Preferably, objects found by the algorithm are found which no or no reference was found, not marked. The algorithm overrides Any such object is easy, if necessary, until it re-searches again hits the object.

The Method is preferably used in a data carrier such as a smart card, in particular a Java Card, or an arbitrarily shaped token used or in a chip module for installation in a data carrier or other object or in a chip for installation in a chip module or a data carrier, etc. The disk or the chip module or the chip preferably has a microprocessor and several memories (ROM, EEPROM, RAM, possibly Flash). The algorithm is preferably in ROM; if necessary alternatively in a flash memory, implemented. The algorithm is preferably a working memory, in particular a stack memory in the RAM of the disk, static assigned, the required size in the inventive method calculates before the runtime. The checkbox is preferably implemented in RAM, preferably in the stack memory.

in the The following is the invention with reference to embodiments and below Reference to the drawing closer explains in the show:

1 a tree-organized heap structure illustrating the mark phase of a prior art garbage collection method;

2 a schematic representation of an EEPROM stored in a Java Card object header, are stored in the references to also stored in the EEPROM data, according to the prior art;

3 one to the in 1 shown analog tree-like organized heap structure, using the Mark phase of a garbage collection method is illustrated according to an embodiment of the invention, to a first state of the process during the search of the heap memory;

4 a check box with two data fields "Valid" and "Scanned" for each object in 3 shown heap structure, with markings in the 3 process state shown correspond;

5 the heap structure out 3 to a second state of the process while searching the heap memory;

6 the checkbox 4 , with markings corresponding to the in 5 process state shown correspond;

7 the heap structure out 3 to a third state of the process while searching the heap memory;

8th the checkbox 4 , with markings corresponding to the in 7 process state shown correspond.

3 1 shows a tree-like organized heap structure, which is used to search a heap memory for references, in particular during the mark phase of a garbage collection process, according to an embodiment of the invention, to a first state of the process during the search of the heap. memory.

The heap memory points 40 Objects on continuously from 1 to 40 numbered with the number "1" being the root object For each object, two data fields are provided to mark the object, namely a "valid" data field and a "scanned" data field.

At the Algorithm according to the preferred embodiment, in which the objects are searched in the order of their numbering be, lets to determine the memory requirements before the algorithm expires, such as shown below.

n:

= Anzahl der Objekte in der Baumstruktur

v:

= Anzahl von Bytes, die bei dem Algorithmus für lokale Variablen verwendet werden (konstant pro Algorithmus-Aufruf)

rc:

= Speicherbedarf in Byte.

So be for a tree like the one in 3 illustrated

n:

= Number of objects in the tree structure

v:

= Number of bytes used in the local variable algorithm (constant per algorithm call)

rc:

= Memory required in bytes.

Then, for the memory requirement rc of the preferred algorithm according to the invention in bytes, rc = (2n + 8) / 8 + v (2)

there is the term (2 · n + 8) the number of bits (1/8 bytes) required for the "valid" and "scanned" data fields (valid flags and scanned flags) for the n objects of the heap structure are required. The term v gives the Memory required in bytes for local variables and only appears once, given the algorithm only one single pass per pass of heap memory scanning Time is called.

From equation (2) it is possible to determine in advance the maximum number n _max of objects that can be accommodated in a memory of size rc: n Max = 4 · (rc - v - 1) (3)

The following is an exemplary recursion-free algorithm 1 in which the inventive method for searching a heap memory and for marking found referenced objects is implemented. Let n be the number of objects in the heap memory. In addition, create an object list in which a check box (schematically in 4 ) are provided with two data fields, namely a data field for a valid flag and a data field for a scanned flag. Then the example search and mark algorithm is:

(Algorithm 1)

In the foregoing Algorithm 1, the two data fields of the check box are executed as a valid flag and a scanned flag (see FIG. 4 ). The valid flag of an object is always set if the object is referenced. The scanned flag is set whenever all references from this object have been scanned. The objects are from 1 Numbered to n, with the 1 numbered object is the root object (start object). After running the algorithm, the object list has the in 4 shown figure and the heap structure in 3 illustrated figure.

The Root object (i = 1) is always referenced and becomes Start set as valid. Optionally, it can have multiple root objects give. In this case, all root objects are considered valid at the beginning set.

Subsequently, in the "j" loop, all through the root object referenced objects are set as valid to mark that these objects are referenced.

following set the scanned flag of the root object (i = 1) to mark that all references originating from the root object are scanned (scanned) have been.

Algorithm 1 now proceeds from the root object (i = 1, ie object index 1 ) to the object with the next higher object index, ie to object no. 2 , and checks if the object no. 2 is valid, ie if its valid flag is set. If the valid flag of object no. 2 (deviating from 3 ) is not set, the algorithm 1 proceeds directly to the object 3 , If, however, (as in 3 ) the valid flag of object no. 2 is set, all of the object 2 scanned outgoing references and those from object 2 selected from referenced objects as valid. Finally, the scanned flag of the object 2 is set, and then the algorithm 1 proceeds to the object 3 ,

The process continues until the last object of the heap (at 3 object 40 ) carried out. 4 shows the occupancy of the valid flags and scanned flags of the heap structure check box 3 after algorithm 1 has been applied to the heap structure.

In the example off 3 the heap structure has backward references, which mean that not all objects of the heap structure can be checked if only a single pass of the heap search is performed. For example, between the pair of objects ( 6 . 9 ) a backward reference. In other words, the object has 9 the second hierarchical level has a higher object index than the object 6 the third hierarchical level. For this reason, if the algorithm is 1 of object 5 that should already be marked as valid and scanned to object 6 progresses, the object 6 not yet marked as valid. Consequently, the references emanating from object are not scanned, but algorithm 1 proceeds straight to object 7 , from there to object 8th and on to object 9 , objects 6 . 7 and 8th remain unchecked, ie neither the valid flag nor the scanned flag is set. First object 9 is valid again. Therefore, objects become 6 and 8th marked as valid and then object 9 marked as scanned. The scanned flags of the objects 6 and 8th do not stay set (see also 4 ). At object 7 both the valid flag and the scanned flag are not set (s. 4 ).

Objects in the heap structure that have backward references can be checked by alternating the heap memory forward as often as necessary (at 3 from 1 to 40 ) and backwards (at 3 from 40 to 1 ) is searched.

While 3 the heap structure points after the heap memory has been searched once forward by applying algorithm 1 to it 5 the same heap structure after the heap memory has been additionally searched backwards once. 5 So it shows the heap structure after an algorithm 2 has been applied to it, such as the following:

(Algorithm 2)

Algorithm 2 includes a forward pass (forward scan) through the heap memory, which is essentially the same as algorithm 1, and a backward pass (backward scan). In the backward pass of Algorithm 2 are especially for the objects 6 and 8th set the scanned flags which were not yet set after the forward pass. For object 7 the valid flag has been set during the backward pass. The flags set during the backward pass in addition to the forward pass are also off 6 can be seen in the the check box off 4 is shown after additionally a backward pass has been applied to the heap memory.

In a preferred algorithm 3 given below, a binary third data field "end flag" is used in addition, which is switched as soon as a run of the search of the heap memory has been made in which no marking has been made the object list has the in 8th shown figure and the heap structure in 7 illustrated figure.

(Algorithm 3)

Of the The above Algorithm 3 searches the heap memory alternately many times forward and backwards, until a sweep (scan) of the heap memory scan has been made no marking has been made. This is done by the (do, while) loop realized as a condition for continuing has the end flag set to boolean false Pass no mark (valid flag) has been made the end flag remains set to the true Boolean value and the (do, while) loop and thus the algorithm is terminated.

7 shows the heap structure 1 and 3 after algorithm 3 has been applied to the underlying heap memory, and 8th shows the associated object list. All objects of the heap structure are already marked as valid. The condition according to 7 and 8th is also the state at the beginning of the last pass of the (do, while) loop of algorithm 3. Since there is no Mar in this pass If the flag is set to a valid flag, the end flag remains set to true so that the (do, while) loop terminates after this last pass.

With the method implemented by the algorithm 3, it is thus possible to find all (still) referenced objects for a heap memory whose heap structure has backward references. According to 7 and 8th are only the unreferenced objects 31 . 32 . 33 . 29 . 30 . 23 . 24 left unchecked valid flag. All referenced objects are marked.

Claims (19)

Method for searching dynamically assigned Heap memory for referenced or unreferenced objects, in which a search of the heap memory by means of an algorithm carried out which works without recursion. The method of claim 1, wherein each object unique object index is assigned, passing through the object indexes all objects of the heap memory have a unique order of Objects is defined, and where according to the algorithm the objects heap memory in the order of their object indexes become. Method according to claim 1 or 2, wherein the objects are numbered in the heap memory, and wherein according to the algorithm the objects of the heap memory be searched in the order of their numbering. The method of claim 2 or 3, wherein the heap memory in terms of the object indexes or numbering forwarded, and where the heap memory according to the algorithm is searched exactly once. The method of claim 2 or 3, wherein the heap memory in terms of the object indexes or numbering forwarded, and where the heap memory according to the algorithm is searched exactly twice, being the second time of browsing being carried out for verification, that the algorithm can be terminated. The method of claim 2 or 3, wherein the heap memory in terms of the object indexes or numbering of its objects at least one Pair of referencing object ((i)) and referenced object ((i + 1)) having a backward reference to each other, and wherein the heap memory is searched at least twice. The method of claim 2 or 3, wherein the heap memory in terms of the object indexes or numbering of its objects at least one Pair of referencing object ((i)) and referenced object ((i + 1)) having a backward reference to each other, and wherein the heap memory is searched at least three times, the last, especially third, time of the search is carried out for review, that the algorithm can be terminated. Method according to one of claims 2 to 7, wherein the heap memory starting with a start object ( 1 ), which has a lowest object index ( 1 ), to an end object ( 40 ), which has a highest object index ( 40 ) is searched. Method according to one of claims 2 to 8, wherein the heap memory starting with an end object ( 40 ), which has a highest object index ( 40 ), up to a start object ( 1 ), which has a lowest object index ( 1 ) is searched. Method according to claims 8 and 9 in association with each other, wherein the heap memory is read at least once each time from the start object ( 1 ) to the end object ( 40 ) and, in reverse order, from the end object ( 40 ) to the start object ( 1 ) is searched. Method according to one of claims 1 to 10, wherein each means of the algorithm found referenced current objects marked becomes. The method of claim 11, wherein the method is terminated once a sweep of searching the entire heap memory has been performed, wherein no mark has been made that is. The method of claim 11 or 12, wherein the marking using a for accessible to the algorithm Check box performed becomes. The method of claim 13, wherein the marker field in a fleeting Memory is provided, in particular in a RAM memory. The method of claim 13 or 14, wherein for marking a check box is used, which is a first for the current object Data field (valid flag) and a second data field (scanned flag) and the first data field (valid flag) is marked if the current one Object is referenced, and where the second data field (scanned flag) is marked if all referenced from the current object are referenced Objects are marked as referenced by that referenced objects marked the first data field (valid flag) is. The method of claim 15, wherein the method is stopped once a run of searching the entire Heap memory performed where there is no marking of a first data field (valid flag) has been made. Method according to one of claims 1 to 16, wherein means of the algorithm found objects to which no or no Reference was found, not marked and / or ignored become. Method according to one of claims 1 to 17, wherein the heap memory in a non-volatile Memory, in particular EEPROM memory, is provided. disk, in particular chip card, in particular Java Card, or chip module or Chip for installation in a data carrier, with a microprocessor, at least one memory and one in implemented on the disk Method according to one of the claims 1 to 18.