23 */
24
25 #include "precompiled.hpp"
26 #include "gc/shared/ptrQueue.hpp"
27 #include "logging/log.hpp"
28 #include "memory/allocation.hpp"
29 #include "memory/allocation.inline.hpp"
30 #include "runtime/atomic.hpp"
31 #include "runtime/mutex.hpp"
32 #include "runtime/mutexLocker.hpp"
33 #include "runtime/orderAccess.hpp"
34 #include "runtime/thread.inline.hpp"
35 #include "utilities/globalCounter.inline.hpp"
36
37 #include <new>
38
39 PtrQueue::PtrQueue(PtrQueueSet* qset, bool active) :
40 _qset(qset),
41 _active(active),
42 _index(0),
43 _capacity_in_bytes(0),
44 _buf(NULL)
45 {}
46
47 PtrQueue::~PtrQueue() {
48 assert(_buf == NULL, "queue must be flushed before delete");
49 }
50
51 void PtrQueue::flush_impl() {
52 if (_buf != NULL) {
53 BufferNode* node = BufferNode::make_node_from_buffer(_buf, index());
54 if (is_empty()) {
55 // No work to do.
56 qset()->deallocate_buffer(node);
57 } else {
58 qset()->enqueue_completed_buffer(node);
59 }
60 _buf = NULL;
61 set_index(0);
62 }
63 }
64
65 void PtrQueue::enqueue_known_active(void* ptr) {
66 while (_index == 0) {
67 handle_zero_index();
68 }
69
70 assert(_buf != NULL, "postcondition");
71 assert(index() > 0, "postcondition");
72 assert(index() <= capacity(), "invariant");
73 _index -= _element_size;
74 _buf[index()] = ptr;
75 }
76
77 void PtrQueue::handle_zero_index() {
78 assert(index() == 0, "precondition");
79
80 if (_buf != NULL) {
81 handle_completed_buffer();
82 } else {
83 // Bootstrapping kludge; lazily initialize capacity. The initial
84 // thread's queues are constructed before the second phase of the
85 // two-phase initialization of the associated qsets. As a result,
86 // we can't initialize _capacity_in_bytes in the queue constructor.
87 if (_capacity_in_bytes == 0) {
88 _capacity_in_bytes = index_to_byte_index(qset()->buffer_size());
89 }
90 allocate_buffer();
91 }
92 }
93
94 void PtrQueue::allocate_buffer() {
95 _buf = qset()->allocate_buffer();
96 reset();
97 }
98
99 void PtrQueue::enqueue_completed_buffer() {
100 assert(_buf != NULL, "precondition");
101 BufferNode* node = BufferNode::make_node_from_buffer(_buf, index());
102 qset()->enqueue_completed_buffer(node);
103 allocate_buffer();
104 }
105
106 BufferNode* BufferNode::allocate(size_t size) {
107 size_t byte_size = size * sizeof(void*);
108 void* data = NEW_C_HEAP_ARRAY(char, buffer_offset() + byte_size, mtGC);
109 return new (data) BufferNode;
233 }
234 OrderAccess::release_store(&_transfer_lock, false);
235 return true;
236 }
237
238 size_t BufferNode::Allocator::reduce_free_list(size_t remove_goal) {
239 try_transfer_pending();
240 size_t removed = 0;
241 for ( ; removed < remove_goal; ++removed) {
242 BufferNode* node = _free_list.pop();
243 if (node == NULL) break;
244 BufferNode::deallocate(node);
245 }
246 size_t new_count = Atomic::sub(removed, &_free_count);
247 log_debug(gc, ptrqueue, freelist)
248 ("Reduced %s free list by " SIZE_FORMAT " to " SIZE_FORMAT,
249 name(), removed, new_count);
250 return removed;
251 }
252
253 PtrQueueSet::PtrQueueSet() :
254 _allocator(NULL),
255 _all_active(false)
256 {}
257
258 PtrQueueSet::~PtrQueueSet() {}
259
260 void PtrQueueSet::initialize(BufferNode::Allocator* allocator) {
261 assert(allocator != NULL, "Init order issue?");
262 _allocator = allocator;
263 }
264
265 void** PtrQueueSet::allocate_buffer() {
266 BufferNode* node = _allocator->allocate();
267 return BufferNode::make_buffer_from_node(node);
268 }
269
270 void PtrQueueSet::deallocate_buffer(BufferNode* node) {
271 _allocator->release(node);
272 }
273
|
23 */
24
25 #include "precompiled.hpp"
26 #include "gc/shared/ptrQueue.hpp"
27 #include "logging/log.hpp"
28 #include "memory/allocation.hpp"
29 #include "memory/allocation.inline.hpp"
30 #include "runtime/atomic.hpp"
31 #include "runtime/mutex.hpp"
32 #include "runtime/mutexLocker.hpp"
33 #include "runtime/orderAccess.hpp"
34 #include "runtime/thread.inline.hpp"
35 #include "utilities/globalCounter.inline.hpp"
36
37 #include <new>
38
39 PtrQueue::PtrQueue(PtrQueueSet* qset, bool active) :
40 _qset(qset),
41 _active(active),
42 _index(0),
43 _capacity_in_bytes(index_to_byte_index(qset->buffer_size())),
44 _buf(NULL)
45 {}
46
47 PtrQueue::~PtrQueue() {
48 assert(_buf == NULL, "queue must be flushed before delete");
49 }
50
51 void PtrQueue::flush_impl() {
52 if (_buf != NULL) {
53 BufferNode* node = BufferNode::make_node_from_buffer(_buf, index());
54 if (is_empty()) {
55 // No work to do.
56 qset()->deallocate_buffer(node);
57 } else {
58 qset()->enqueue_completed_buffer(node);
59 }
60 _buf = NULL;
61 set_index(0);
62 }
63 }
64
65 void PtrQueue::enqueue_known_active(void* ptr) {
66 while (_index == 0) {
67 handle_zero_index();
68 }
69
70 assert(_buf != NULL, "postcondition");
71 assert(index() > 0, "postcondition");
72 assert(index() <= capacity(), "invariant");
73 _index -= _element_size;
74 _buf[index()] = ptr;
75 }
76
77 void PtrQueue::handle_zero_index() {
78 assert(index() == 0, "precondition");
79
80 if (_buf != NULL) {
81 handle_completed_buffer();
82 } else {
83 allocate_buffer();
84 }
85 }
86
87 void PtrQueue::allocate_buffer() {
88 _buf = qset()->allocate_buffer();
89 reset();
90 }
91
92 void PtrQueue::enqueue_completed_buffer() {
93 assert(_buf != NULL, "precondition");
94 BufferNode* node = BufferNode::make_node_from_buffer(_buf, index());
95 qset()->enqueue_completed_buffer(node);
96 allocate_buffer();
97 }
98
99 BufferNode* BufferNode::allocate(size_t size) {
100 size_t byte_size = size * sizeof(void*);
101 void* data = NEW_C_HEAP_ARRAY(char, buffer_offset() + byte_size, mtGC);
102 return new (data) BufferNode;
226 }
227 OrderAccess::release_store(&_transfer_lock, false);
228 return true;
229 }
230
231 size_t BufferNode::Allocator::reduce_free_list(size_t remove_goal) {
232 try_transfer_pending();
233 size_t removed = 0;
234 for ( ; removed < remove_goal; ++removed) {
235 BufferNode* node = _free_list.pop();
236 if (node == NULL) break;
237 BufferNode::deallocate(node);
238 }
239 size_t new_count = Atomic::sub(removed, &_free_count);
240 log_debug(gc, ptrqueue, freelist)
241 ("Reduced %s free list by " SIZE_FORMAT " to " SIZE_FORMAT,
242 name(), removed, new_count);
243 return removed;
244 }
245
246 PtrQueueSet::PtrQueueSet(BufferNode::Allocator* allocator) :
247 _allocator(allocator),
248 _all_active(false)
249 {}
250
251 PtrQueueSet::~PtrQueueSet() {}
252
253 void** PtrQueueSet::allocate_buffer() {
254 BufferNode* node = _allocator->allocate();
255 return BufferNode::make_buffer_from_node(node);
256 }
257
258 void PtrQueueSet::deallocate_buffer(BufferNode* node) {
259 _allocator->release(node);
260 }
261
|