Mercurial > hg > graal-jvmci-8
comparison src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp @ 1638:b2a00dd3117c
6957084: simplify TaskQueue overflow handling
Reviewed-by: ysr, jmasa
author | jcoomes |
---|---|
date | Thu, 01 Jul 2010 21:40:45 -0700 |
parents | c18cbe5936b8 |
children | 894b1d7c7e01 |
comparison
equal
deleted
inserted
replaced
1628:a00567c82f02 | 1638:b2a00dd3117c |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2005, 2009, Oracle and/or its affiliates. All rights reserved. | 2 * Copyright (c) 2005, 2010, 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. |
57 }; | 57 }; |
58 // ------------------------ End don't putback if not needed | 58 // ------------------------ End don't putback if not needed |
59 | 59 |
60 private: | 60 private: |
61 // 32-bit: 4K * 8 = 32KiB; 64-bit: 8K * 16 = 128KiB | 61 // 32-bit: 4K * 8 = 32KiB; 64-bit: 8K * 16 = 128KiB |
62 #define OBJARRAY_QUEUE_SIZE (1 << NOT_LP64(12) LP64_ONLY(13)) | 62 #define QUEUE_SIZE (1 << NOT_LP64(12) LP64_ONLY(13)) |
63 typedef GenericTaskQueue<ObjArrayTask, OBJARRAY_QUEUE_SIZE> ObjArrayTaskQueue; | 63 typedef OverflowTaskQueue<ObjArrayTask, QUEUE_SIZE> ObjArrayTaskQueue; |
64 typedef GenericTaskQueueSet<ObjArrayTaskQueue> ObjArrayTaskQueueSet; | 64 typedef GenericTaskQueueSet<ObjArrayTaskQueue> ObjArrayTaskQueueSet; |
65 #undef OBJARRAY_QUEUE_SIZE | 65 #undef QUEUE_SIZE |
66 | 66 |
67 static ParCompactionManager** _manager_array; | 67 static ParCompactionManager** _manager_array; |
68 static OopTaskQueueSet* _stack_array; | 68 static OopTaskQueueSet* _stack_array; |
69 static ObjArrayTaskQueueSet* _objarray_queues; | 69 static ObjArrayTaskQueueSet* _objarray_queues; |
70 static ObjectStartArray* _start_array; | 70 static ObjectStartArray* _start_array; |
71 static RegionTaskQueueSet* _region_array; | 71 static RegionTaskQueueSet* _region_array; |
72 static PSOldGen* _old_gen; | 72 static PSOldGen* _old_gen; |
73 | 73 |
74 private: | 74 private: |
75 OopTaskQueue _marking_stack; | 75 OverflowTaskQueue<oop> _marking_stack; |
76 GrowableArray<oop>* _overflow_stack; | 76 ObjArrayTaskQueue _objarray_stack; |
77 | |
78 typedef GrowableArray<ObjArrayTask> ObjArrayOverflowStack; | |
79 ObjArrayTaskQueue _objarray_queue; | |
80 ObjArrayOverflowStack* _objarray_overflow_stack; | |
81 | 77 |
82 // Is there a way to reuse the _marking_stack for the | 78 // Is there a way to reuse the _marking_stack for the |
83 // saving empty regions? For now just create a different | 79 // saving empty regions? For now just create a different |
84 // type of TaskQueue. | 80 // type of TaskQueue. |
85 | |
86 #ifdef USE_RegionTaskQueueWithOverflow | |
87 RegionTaskQueueWithOverflow _region_stack; | |
88 #else | |
89 RegionTaskQueue _region_stack; | 81 RegionTaskQueue _region_stack; |
90 GrowableArray<size_t>* _region_overflow_stack; | |
91 #endif | |
92 | 82 |
93 #if 1 // does this happen enough to need a per thread stack? | 83 #if 1 // does this happen enough to need a per thread stack? |
94 GrowableArray<Klass*>* _revisit_klass_stack; | 84 GrowableArray<Klass*>* _revisit_klass_stack; |
95 GrowableArray<DataLayout*>* _revisit_mdo_stack; | 85 GrowableArray<DataLayout*>* _revisit_mdo_stack; |
96 #endif | 86 #endif |
105 static void initialize(ParMarkBitMap* mbm); | 95 static void initialize(ParMarkBitMap* mbm); |
106 | 96 |
107 protected: | 97 protected: |
108 // Array of tasks. Needed by the ParallelTaskTerminator. | 98 // Array of tasks. Needed by the ParallelTaskTerminator. |
109 static RegionTaskQueueSet* region_array() { return _region_array; } | 99 static RegionTaskQueueSet* region_array() { return _region_array; } |
110 OopTaskQueue* marking_stack() { return &_marking_stack; } | 100 OverflowTaskQueue<oop>* marking_stack() { return &_marking_stack; } |
111 GrowableArray<oop>* overflow_stack() { return _overflow_stack; } | 101 RegionTaskQueue* region_stack() { return &_region_stack; } |
112 #ifdef USE_RegionTaskQueueWithOverflow | |
113 RegionTaskQueueWithOverflow* region_stack() { return &_region_stack; } | |
114 #else | |
115 RegionTaskQueue* region_stack() { return &_region_stack; } | |
116 GrowableArray<size_t>* region_overflow_stack() { | |
117 return _region_overflow_stack; | |
118 } | |
119 #endif | |
120 | 102 |
121 // Pushes onto the marking stack. If the marking stack is full, | 103 // Pushes onto the marking stack. If the marking stack is full, |
122 // pushes onto the overflow stack. | 104 // pushes onto the overflow stack. |
123 void stack_push(oop obj); | 105 void stack_push(oop obj); |
124 // Do not implement an equivalent stack_pop. Deal with the | 106 // Do not implement an equivalent stack_pop. Deal with the |
125 // marking stack and overflow stack directly. | 107 // marking stack and overflow stack directly. |
126 | 108 |
127 // Pushes onto the region stack. If the region stack is full, | 109 public: |
128 // pushes onto the region overflow stack. | |
129 void region_stack_push(size_t region_index); | |
130 | |
131 public: | |
132 Action action() { return _action; } | 110 Action action() { return _action; } |
133 void set_action(Action v) { _action = v; } | 111 void set_action(Action v) { _action = v; } |
134 | 112 |
135 inline static ParCompactionManager* manager_array(int index); | 113 inline static ParCompactionManager* manager_array(int index); |
136 | 114 |
155 // Probably stays as a growable array | 133 // Probably stays as a growable array |
156 GrowableArray<Klass*>* revisit_klass_stack() { return _revisit_klass_stack; } | 134 GrowableArray<Klass*>* revisit_klass_stack() { return _revisit_klass_stack; } |
157 GrowableArray<DataLayout*>* revisit_mdo_stack() { return _revisit_mdo_stack; } | 135 GrowableArray<DataLayout*>* revisit_mdo_stack() { return _revisit_mdo_stack; } |
158 #endif | 136 #endif |
159 | 137 |
160 // Save oop for later processing. Must not fail. | 138 // Save for later processing. Must not fail. |
161 void save_for_scanning(oop m); | 139 inline void push(oop obj) { _marking_stack.push(obj); } |
162 // Get a oop for scanning. If returns null, no oop were found. | 140 inline void push_objarray(oop objarray, size_t index); |
163 oop retrieve_for_scanning(); | 141 inline void push_region(size_t index); |
164 | |
165 inline void push_objarray(oop obj, size_t index); | |
166 | |
167 // Save region for later processing. Must not fail. | |
168 void save_for_processing(size_t region_index); | |
169 // Get a region for processing. If returns null, no region were found. | |
170 bool retrieve_for_processing(size_t& region_index); | |
171 | 142 |
172 // Access function for compaction managers | 143 // Access function for compaction managers |
173 static ParCompactionManager* gc_thread_compaction_manager(int index); | 144 static ParCompactionManager* gc_thread_compaction_manager(int index); |
174 | 145 |
175 static bool steal(int queue_num, int* seed, Task& t) { | 146 static bool steal(int queue_num, int* seed, oop& t) { |
176 return stack_array()->steal(queue_num, seed, t); | 147 return stack_array()->steal(queue_num, seed, t); |
177 } | 148 } |
178 | 149 |
179 static bool steal_objarray(int queue_num, int* seed, ObjArrayTask& t) { | 150 static bool steal_objarray(int queue_num, int* seed, ObjArrayTask& t) { |
180 return _objarray_queues->steal(queue_num, seed, t); | 151 return _objarray_queues->steal(queue_num, seed, t); |
181 } | 152 } |
182 | 153 |
183 static bool steal(int queue_num, int* seed, RegionTask& t) { | 154 static bool steal(int queue_num, int* seed, size_t& region) { |
184 return region_array()->steal(queue_num, seed, t); | 155 return region_array()->steal(queue_num, seed, region); |
185 } | 156 } |
186 | 157 |
187 // Process tasks remaining on any marking stack | 158 // Process tasks remaining on any marking stack |
188 void follow_marking_stacks(); | 159 void follow_marking_stacks(); |
189 inline bool marking_stacks_empty() const; | 160 inline bool marking_stacks_empty() const; |
190 | 161 |
191 // Process tasks remaining on any stack | 162 // Process tasks remaining on any stack |
192 void drain_region_stacks(); | 163 void drain_region_stacks(); |
193 | |
194 // Process tasks remaining on any stack | |
195 void drain_region_overflow_stack(); | |
196 | 164 |
197 // Debugging support | 165 // Debugging support |
198 #ifdef ASSERT | 166 #ifdef ASSERT |
199 bool stacks_have_been_allocated(); | 167 bool stacks_have_been_allocated(); |
200 #endif | 168 #endif |
206 "out of range manager_array access"); | 174 "out of range manager_array access"); |
207 return _manager_array[index]; | 175 return _manager_array[index]; |
208 } | 176 } |
209 | 177 |
210 bool ParCompactionManager::marking_stacks_empty() const { | 178 bool ParCompactionManager::marking_stacks_empty() const { |
211 return _marking_stack.size() == 0 && _overflow_stack->is_empty() && | 179 return _marking_stack.is_empty() && _objarray_stack.is_empty(); |
212 _objarray_queue.size() == 0 && _objarray_overflow_stack->is_empty(); | |
213 } | 180 } |