Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/heapRegionSeq.hpp @ 6010:720b6a76dd9d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7157073: G1: type change size_t -> uint for region counts / indexes Summary: Change the type of fields / variables / etc. that represent region counts and indeces from size_t to uint. Reviewed-by: iveresov, brutisso, jmasa, jwilhelm
author tonyp
date Wed, 18 Apr 2012 07:21:15 -0400
parents 4f93f0d00802
children d2a62e0f25eb
comparison
equal deleted inserted replaced
6009:dde53abda3d6 6010:720b6a76dd9d
1 /* 1 /*
2 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. 2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 * 4 *
5 * This code is free software; you can redistribute it and/or modify it 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 6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. 7 * published by the Free Software Foundation.
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONSEQ_HPP
27 27
28 class HeapRegion; 28 class HeapRegion;
29 class HeapRegionClosure; 29 class HeapRegionClosure;
30 class FreeRegionList; 30 class FreeRegionList;
31
32 #define G1_NULL_HRS_INDEX ((size_t) -1)
33 31
34 // This class keeps track of the region metadata (i.e., HeapRegion 32 // This class keeps track of the region metadata (i.e., HeapRegion
35 // instances). They are kept in the _regions array in address 33 // instances). They are kept in the _regions array in address
36 // order. A region's index in the array corresponds to its index in 34 // order. A region's index in the array corresponds to its index in
37 // the heap (i.e., 0 is the region at the bottom of the heap, 1 is 35 // the heap (i.e., 0 is the region at the bottom of the heap, 1 is
63 61
64 // Version of _regions biased to address 0 62 // Version of _regions biased to address 0
65 HeapRegion** _regions_biased; 63 HeapRegion** _regions_biased;
66 64
67 // The number of regions committed in the heap. 65 // The number of regions committed in the heap.
68 size_t _length; 66 uint _length;
69 67
70 // The address of the first reserved word in the heap. 68 // The address of the first reserved word in the heap.
71 HeapWord* _heap_bottom; 69 HeapWord* _heap_bottom;
72 70
73 // The address of the last reserved word in the heap - 1. 71 // The address of the last reserved word in the heap - 1.
74 HeapWord* _heap_end; 72 HeapWord* _heap_end;
75 73
76 // The log of the region byte size. 74 // The log of the region byte size.
77 size_t _region_shift; 75 uint _region_shift;
78 76
79 // A hint for which index to start searching from for humongous 77 // A hint for which index to start searching from for humongous
80 // allocations. 78 // allocations.
81 size_t _next_search_index; 79 uint _next_search_index;
82 80
83 // The number of regions for which we have allocated HeapRegions for. 81 // The number of regions for which we have allocated HeapRegions for.
84 size_t _allocated_length; 82 uint _allocated_length;
85 83
86 // The maximum number of regions in the heap. 84 // The maximum number of regions in the heap.
87 size_t _max_length; 85 uint _max_length;
88 86
89 // Find a contiguous set of empty regions of length num, starting 87 // Find a contiguous set of empty regions of length num, starting
90 // from the given index. 88 // from the given index.
91 size_t find_contiguous_from(size_t from, size_t num); 89 uint find_contiguous_from(uint from, uint num);
92 90
93 // Map a heap address to a biased region index. Assume that the 91 // Map a heap address to a biased region index. Assume that the
94 // address is valid. 92 // address is valid.
95 inline size_t addr_to_index_biased(HeapWord* addr) const; 93 inline uintx addr_to_index_biased(HeapWord* addr) const;
96 94
97 void increment_length(size_t* length) { 95 void increment_length(uint* length) {
98 assert(*length < _max_length, "pre-condition"); 96 assert(*length < _max_length, "pre-condition");
99 *length += 1; 97 *length += 1;
100 } 98 }
101 99
102 void decrement_length(size_t* length) { 100 void decrement_length(uint* length) {
103 assert(*length > 0, "pre-condition"); 101 assert(*length > 0, "pre-condition");
104 *length -= 1; 102 *length -= 1;
105 } 103 }
106 104
107 public: 105 public:
108 // Empty contructor, we'll initialize it with the initialize() method. 106 // Empty contructor, we'll initialize it with the initialize() method.
109 HeapRegionSeq() { } 107 HeapRegionSeq() { }
110 108
111 void initialize(HeapWord* bottom, HeapWord* end, size_t max_length); 109 void initialize(HeapWord* bottom, HeapWord* end, uint max_length);
112 110
113 // Return the HeapRegion at the given index. Assume that the index 111 // Return the HeapRegion at the given index. Assume that the index
114 // is valid. 112 // is valid.
115 inline HeapRegion* at(size_t index) const; 113 inline HeapRegion* at(uint index) const;
116 114
117 // If addr is within the committed space return its corresponding 115 // If addr is within the committed space return its corresponding
118 // HeapRegion, otherwise return NULL. 116 // HeapRegion, otherwise return NULL.
119 inline HeapRegion* addr_to_region(HeapWord* addr) const; 117 inline HeapRegion* addr_to_region(HeapWord* addr) const;
120 118
121 // Return the HeapRegion that corresponds to the given 119 // Return the HeapRegion that corresponds to the given
122 // address. Assume the address is valid. 120 // address. Assume the address is valid.
123 inline HeapRegion* addr_to_region_unsafe(HeapWord* addr) const; 121 inline HeapRegion* addr_to_region_unsafe(HeapWord* addr) const;
124 122
125 // Return the number of regions that have been committed in the heap. 123 // Return the number of regions that have been committed in the heap.
126 size_t length() const { return _length; } 124 uint length() const { return _length; }
127 125
128 // Return the maximum number of regions in the heap. 126 // Return the maximum number of regions in the heap.
129 size_t max_length() const { return _max_length; } 127 uint max_length() const { return _max_length; }
130 128
131 // Expand the sequence to reflect that the heap has grown from 129 // Expand the sequence to reflect that the heap has grown from
132 // old_end to new_end. Either create new HeapRegions, or re-use 130 // old_end to new_end. Either create new HeapRegions, or re-use
133 // existing ones, and return them in the given list. Returns the 131 // existing ones, and return them in the given list. Returns the
134 // memory region that covers the newly-created regions. If a 132 // memory region that covers the newly-created regions. If a
137 MemRegion expand_by(HeapWord* old_end, HeapWord* new_end, 135 MemRegion expand_by(HeapWord* old_end, HeapWord* new_end,
138 FreeRegionList* list); 136 FreeRegionList* list);
139 137
140 // Return the number of contiguous regions at the end of the sequence 138 // Return the number of contiguous regions at the end of the sequence
141 // that are available for allocation. 139 // that are available for allocation.
142 size_t free_suffix(); 140 uint free_suffix();
143 141
144 // Find a contiguous set of empty regions of length num and return 142 // Find a contiguous set of empty regions of length num and return
145 // the index of the first region or G1_NULL_HRS_INDEX if the 143 // the index of the first region or G1_NULL_HRS_INDEX if the
146 // search was unsuccessful. 144 // search was unsuccessful.
147 size_t find_contiguous(size_t num); 145 uint find_contiguous(uint num);
148 146
149 // Apply blk->doHeapRegion() on all committed regions in address order, 147 // Apply blk->doHeapRegion() on all committed regions in address order,
150 // terminating the iteration early if doHeapRegion() returns true. 148 // terminating the iteration early if doHeapRegion() returns true.
151 void iterate(HeapRegionClosure* blk) const; 149 void iterate(HeapRegionClosure* blk) const;
152 150
157 // Tag as uncommitted as many regions that are completely free as 155 // Tag as uncommitted as many regions that are completely free as
158 // possible, up to shrink_bytes, from the suffix of the committed 156 // possible, up to shrink_bytes, from the suffix of the committed
159 // sequence. Return a MemRegion that corresponds to the address 157 // sequence. Return a MemRegion that corresponds to the address
160 // range of the uncommitted regions. Assume shrink_bytes is page and 158 // range of the uncommitted regions. Assume shrink_bytes is page and
161 // heap region aligned. 159 // heap region aligned.
162 MemRegion shrink_by(size_t shrink_bytes, size_t* num_regions_deleted); 160 MemRegion shrink_by(size_t shrink_bytes, uint* num_regions_deleted);
163 161
164 // Do some sanity checking. 162 // Do some sanity checking.
165 void verify_optional() PRODUCT_RETURN; 163 void verify_optional() PRODUCT_RETURN;
166 }; 164 };
167 165