Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/freeList.hpp @ 10241:d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
Summary: Make processing of minimum, initial and maximum heap size more intiutive by removing previous limitations on allowed values, and make error reporting consistent. Further, fix errors in ergonomic heap sizing.
Reviewed-by: johnc, jwilhelm, tamao
| author | tschatzl |
|---|---|
| date | Mon, 06 May 2013 17:19:42 +0200 |
| parents | 685df3c6f84b |
| children | 7c5a1b62f53d |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6842
b9a9ed0f8eeb
7197424: update copyright year to match last edit in jdk8 hotspot repository
mikael
parents:
6028
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1145
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1145
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1145
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 6026 | 25 #ifndef SHARE_VM_MEMORY_FREELIST_HPP |
| 26 #define SHARE_VM_MEMORY_FREELIST_HPP | |
| 1972 | 27 |
| 28 #include "gc_implementation/shared/allocationStats.hpp" | |
| 29 | |
| 0 | 30 class CompactibleFreeListSpace; |
| 31 | |
| 6026 | 32 // A class for maintaining a free list of Chunk's. The FreeList |
| 0 | 33 // maintains a the structure of the list (head, tail, etc.) plus |
| 34 // statistics for allocations from the list. The links between items | |
| 35 // are not part of FreeList. The statistics are | |
| 6026 | 36 // used to make decisions about coalescing Chunk's when they |
| 0 | 37 // are swept during collection. |
| 38 // | |
| 39 // See the corresponding .cpp file for a description of the specifics | |
| 40 // for that implementation. | |
| 41 | |
| 42 class Mutex; | |
| 43 | |
| 6885 | 44 template <class Chunk_t> |
| 0 | 45 class FreeList VALUE_OBJ_CLASS_SPEC { |
| 46 friend class CompactibleFreeListSpace; | |
|
152
c70a245cad3a
6670684: 4/5 SA command universe did not print out CMS space information
dcubed
parents:
12
diff
changeset
|
47 friend class VMStructs; |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
196
diff
changeset
|
48 |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
196
diff
changeset
|
49 private: |
| 6885 | 50 Chunk_t* _head; // Head of list of free chunks |
| 51 Chunk_t* _tail; // Tail of list of free chunks | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
196
diff
changeset
|
52 size_t _size; // Size in Heap words of each chunk |
| 0 | 53 ssize_t _count; // Number of entries in list |
| 54 | |
| 6885 | 55 protected: |
| 0 | 56 |
| 57 #ifdef ASSERT | |
| 58 Mutex* _protecting_lock; | |
| 59 #endif | |
| 60 | |
| 61 // Asserts false if the protecting lock (if any) is not held. | |
| 62 void assert_proper_lock_protection_work() const PRODUCT_RETURN; | |
| 63 void assert_proper_lock_protection() const { | |
| 64 #ifdef ASSERT | |
| 65 if (_protecting_lock != NULL) | |
| 66 assert_proper_lock_protection_work(); | |
| 67 #endif | |
| 68 } | |
| 69 | |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
196
diff
changeset
|
70 void increment_count() { |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
196
diff
changeset
|
71 _count++; |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
196
diff
changeset
|
72 } |
|
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
196
diff
changeset
|
73 |
| 0 | 74 void decrement_count() { |
| 75 _count--; | |
|
12
6432c3bb6240
6668743: CMS: Consolidate block statistics reporting code
ysr
parents:
0
diff
changeset
|
76 assert(_count >= 0, "Count should not be negative"); |
|
6432c3bb6240
6668743: CMS: Consolidate block statistics reporting code
ysr
parents:
0
diff
changeset
|
77 } |
| 0 | 78 |
| 79 public: | |
| 80 // Constructor | |
| 81 // Construct a list without any entries. | |
| 82 FreeList(); | |
| 83 // Construct a list with "fc" as the first (and lone) entry in the list. | |
| 6885 | 84 FreeList(Chunk_t* fc); |
| 0 | 85 |
| 6885 | 86 // Do initialization |
| 87 void initialize(); | |
| 88 | |
| 89 // Reset the head, tail, and count of a free list. | |
| 90 void reset(); | |
| 0 | 91 |
| 92 // Declare the current free list to be protected by the given lock. | |
| 93 #ifdef ASSERT | |
| 6885 | 94 Mutex* protecting_lock() const { return _protecting_lock; } |
| 95 void set_protecting_lock(Mutex* v) { | |
| 96 _protecting_lock = v; | |
| 0 | 97 } |
| 98 #endif | |
| 99 | |
| 100 // Accessors. | |
| 6885 | 101 Chunk_t* head() const { |
| 0 | 102 assert_proper_lock_protection(); |
| 103 return _head; | |
| 104 } | |
| 6885 | 105 void set_head(Chunk_t* v) { |
| 0 | 106 assert_proper_lock_protection(); |
| 107 _head = v; | |
| 108 assert(!_head || _head->size() == _size, "bad chunk size"); | |
| 109 } | |
| 110 // Set the head of the list and set the prev field of non-null | |
| 111 // values to NULL. | |
| 6885 | 112 void link_head(Chunk_t* v); |
| 0 | 113 |
| 6885 | 114 Chunk_t* tail() const { |
| 0 | 115 assert_proper_lock_protection(); |
| 116 return _tail; | |
| 117 } | |
| 6885 | 118 void set_tail(Chunk_t* v) { |
| 0 | 119 assert_proper_lock_protection(); |
| 120 _tail = v; | |
| 121 assert(!_tail || _tail->size() == _size, "bad chunk size"); | |
| 122 } | |
| 123 // Set the tail of the list and set the next field of non-null | |
| 124 // values to NULL. | |
| 6885 | 125 void link_tail(Chunk_t* v) { |
| 0 | 126 assert_proper_lock_protection(); |
| 127 set_tail(v); | |
| 128 if (v != NULL) { | |
|
6028
f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents:
6026
diff
changeset
|
129 v->clear_next(); |
| 0 | 130 } |
| 131 } | |
| 132 | |
| 133 // No locking checks in read-accessors: lock-free reads (only) are benign. | |
| 134 // Readers are expected to have the lock if they are doing work that | |
| 135 // requires atomicity guarantees in sections of code. | |
| 136 size_t size() const { | |
| 137 return _size; | |
| 138 } | |
| 139 void set_size(size_t v) { | |
| 140 assert_proper_lock_protection(); | |
| 141 _size = v; | |
| 142 } | |
| 6885 | 143 ssize_t count() const { return _count; } |
| 144 void set_count(ssize_t v) { _count = v;} | |
| 0 | 145 |
| 6885 | 146 size_t get_better_size() { return size(); } |
| 0 | 147 |
| 6885 | 148 size_t returned_bytes() const { ShouldNotReachHere(); return 0; } |
| 149 void set_returned_bytes(size_t v) {} | |
| 150 void increment_returned_bytes_by(size_t v) {} | |
| 0 | 151 |
| 152 // Unlink head of list and return it. Returns NULL if | |
| 153 // the list is empty. | |
| 6885 | 154 Chunk_t* get_chunk_at_head(); |
| 0 | 155 |
| 156 // Remove the first "n" or "count", whichever is smaller, chunks from the | |
| 157 // list, setting "fl", which is required to be empty, to point to them. | |
| 6885 | 158 void getFirstNChunksFromList(size_t n, FreeList<Chunk_t>* fl); |
| 0 | 159 |
| 160 // Unlink this chunk from it's free list | |
| 6885 | 161 void remove_chunk(Chunk_t* fc); |
| 0 | 162 |
| 163 // Add this chunk to this free list. | |
| 6885 | 164 void return_chunk_at_head(Chunk_t* fc); |
| 165 void return_chunk_at_tail(Chunk_t* fc); | |
| 0 | 166 |
| 167 // Similar to returnChunk* but also records some diagnostic | |
| 168 // information. | |
| 6885 | 169 void return_chunk_at_head(Chunk_t* fc, bool record_return); |
| 170 void return_chunk_at_tail(Chunk_t* fc, bool record_return); | |
| 0 | 171 |
| 172 // Prepend "fl" (whose size is required to be the same as that of "this") | |
| 173 // to the front of "this" list. | |
| 6885 | 174 void prepend(FreeList<Chunk_t>* fl); |
| 0 | 175 |
| 176 // Verify that the chunk is in the list. | |
| 177 // found. Return NULL if "fc" is not found. | |
| 6885 | 178 bool verify_chunk_in_free_list(Chunk_t* fc) const; |
|
12
6432c3bb6240
6668743: CMS: Consolidate block statistics reporting code
ysr
parents:
0
diff
changeset
|
179 |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
196
diff
changeset
|
180 // Stats verification |
| 6885 | 181 // void verify_stats() const { ShouldNotReachHere(); }; |
|
1145
e018e6884bd8
6631166: CMS: better heuristics when combatting fragmentation
ysr
parents:
196
diff
changeset
|
182 |
|
12
6432c3bb6240
6668743: CMS: Consolidate block statistics reporting code
ysr
parents:
0
diff
changeset
|
183 // Printing support |
|
6432c3bb6240
6668743: CMS: Consolidate block statistics reporting code
ysr
parents:
0
diff
changeset
|
184 static void print_labels_on(outputStream* st, const char* c); |
|
6432c3bb6240
6668743: CMS: Consolidate block statistics reporting code
ysr
parents:
0
diff
changeset
|
185 void print_on(outputStream* st, const char* c = NULL) const; |
| 0 | 186 }; |
| 1972 | 187 |
| 6026 | 188 #endif // SHARE_VM_MEMORY_FREELIST_HPP |