254 enqueue_complete_buffer(buf);
255 return false;
256 }
257
258 void PtrQueueSet::enqueue_complete_buffer(void** buf, size_t index) {
259 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
260 BufferNode* cbn = BufferNode::make_node_from_buffer(buf);
261 cbn->set_index(index);
262 cbn->set_next(NULL);
263 if (_completed_buffers_tail == NULL) {
264 assert(_completed_buffers_head == NULL, "Well-formedness");
265 _completed_buffers_head = cbn;
266 _completed_buffers_tail = cbn;
267 } else {
268 _completed_buffers_tail->set_next(cbn);
269 _completed_buffers_tail = cbn;
270 }
271 _n_completed_buffers++;
272
273 if (!_process_completed && _process_completed_threshold >= 0 &&
274 _n_completed_buffers >= _process_completed_threshold) {
275 _process_completed = true;
276 if (_notify_when_complete)
277 _cbl_mon->notify();
278 }
279 DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked());
280 }
281
282 int PtrQueueSet::completed_buffers_list_length() {
283 int n = 0;
284 BufferNode* cbn = _completed_buffers_head;
285 while (cbn != NULL) {
286 n++;
287 cbn = cbn->next();
288 }
289 return n;
290 }
291
292 void PtrQueueSet::assert_completed_buffer_list_len_correct() {
293 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
294 assert_completed_buffer_list_len_correct_locked();
295 }
296
297 void PtrQueueSet::assert_completed_buffer_list_len_correct_locked() {
298 guarantee(completed_buffers_list_length() == _n_completed_buffers,
299 "Completed buffer length is wrong.");
300 }
301
302 void PtrQueueSet::set_buffer_size(size_t sz) {
303 assert(_sz == 0 && sz > 0, "Should be called only once.");
317 } else {
318 assert(_completed_buffers_head != NULL, "Well formedness");
319 if (src->_completed_buffers_head != NULL) {
320 _completed_buffers_tail->set_next(src->_completed_buffers_head);
321 _completed_buffers_tail = src->_completed_buffers_tail;
322 }
323 }
324 _n_completed_buffers += src->_n_completed_buffers;
325
326 src->_n_completed_buffers = 0;
327 src->_completed_buffers_head = NULL;
328 src->_completed_buffers_tail = NULL;
329
330 assert(_completed_buffers_head == NULL && _completed_buffers_tail == NULL ||
331 _completed_buffers_head != NULL && _completed_buffers_tail != NULL,
332 "Sanity");
333 }
334
335 void PtrQueueSet::notify_if_necessary() {
336 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
337 if (_n_completed_buffers >= _process_completed_threshold || _max_completed_queue == 0) {
338 _process_completed = true;
339 if (_notify_when_complete)
340 _cbl_mon->notify();
341 }
342 }
|
254 enqueue_complete_buffer(buf);
255 return false;
256 }
257
258 void PtrQueueSet::enqueue_complete_buffer(void** buf, size_t index) {
259 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
260 BufferNode* cbn = BufferNode::make_node_from_buffer(buf);
261 cbn->set_index(index);
262 cbn->set_next(NULL);
263 if (_completed_buffers_tail == NULL) {
264 assert(_completed_buffers_head == NULL, "Well-formedness");
265 _completed_buffers_head = cbn;
266 _completed_buffers_tail = cbn;
267 } else {
268 _completed_buffers_tail->set_next(cbn);
269 _completed_buffers_tail = cbn;
270 }
271 _n_completed_buffers++;
272
273 if (!_process_completed && _process_completed_threshold >= 0 &&
274 _n_completed_buffers >= (size_t)_process_completed_threshold) {
275 _process_completed = true;
276 if (_notify_when_complete) {
277 _cbl_mon->notify();
278 }
279 }
280 DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked());
281 }
282
283 size_t PtrQueueSet::completed_buffers_list_length() {
284 size_t n = 0;
285 BufferNode* cbn = _completed_buffers_head;
286 while (cbn != NULL) {
287 n++;
288 cbn = cbn->next();
289 }
290 return n;
291 }
292
293 void PtrQueueSet::assert_completed_buffer_list_len_correct() {
294 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
295 assert_completed_buffer_list_len_correct_locked();
296 }
297
298 void PtrQueueSet::assert_completed_buffer_list_len_correct_locked() {
299 guarantee(completed_buffers_list_length() == _n_completed_buffers,
300 "Completed buffer length is wrong.");
301 }
302
303 void PtrQueueSet::set_buffer_size(size_t sz) {
304 assert(_sz == 0 && sz > 0, "Should be called only once.");
318 } else {
319 assert(_completed_buffers_head != NULL, "Well formedness");
320 if (src->_completed_buffers_head != NULL) {
321 _completed_buffers_tail->set_next(src->_completed_buffers_head);
322 _completed_buffers_tail = src->_completed_buffers_tail;
323 }
324 }
325 _n_completed_buffers += src->_n_completed_buffers;
326
327 src->_n_completed_buffers = 0;
328 src->_completed_buffers_head = NULL;
329 src->_completed_buffers_tail = NULL;
330
331 assert(_completed_buffers_head == NULL && _completed_buffers_tail == NULL ||
332 _completed_buffers_head != NULL && _completed_buffers_tail != NULL,
333 "Sanity");
334 }
335
336 void PtrQueueSet::notify_if_necessary() {
337 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
338 assert(_process_completed_threshold >= 0, "_process_completed is negative");
339 if (_n_completed_buffers >= (size_t)_process_completed_threshold || _max_completed_queue == 0) {
340 _process_completed = true;
341 if (_notify_when_complete)
342 _cbl_mon->notify();
343 }
344 }
|