0N/A

0N/A#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_DIRTYCARDQUEUE_HPP

0N/A#define SHARE_VM_GC_IMPLEMENTATION_G1_DIRTYCARDQUEUE_HPP

0N/A

0N/A#include "gc_implementation/g1/ptrQueue.hpp"

0N/A#include "memory/allocation.hpp"

0N/A

0N/Aclass FreeIdSet;

0N/A

0N/Aclass CardTableEntryClosure: public CHeapObj<mtGC> {

0N/Apublic:

0N/A // Process the card whose card table entry is "card_ptr". If returns

0N/A // "false", terminate the iteration early.

0N/A virtual bool do_card_ptr(jbyte* card_ptr, int worker_i = 0) = 0;

0N/A};

0N/A

0N/Aclass DirtyCardQueue: public PtrQueue {

0N/Apublic:

0N/A DirtyCardQueue(PtrQueueSet* qset_, bool perm = false) :

0N/A // Dirty card queues are always active, so we create them with their

0N/A // active field set to true.

0N/A PtrQueue(qset_, perm, true /* active */) { }

0N/A

0N/A // Apply the closure to all elements, and reset the index to make the

0N/A // buffer empty. If a closure application returns "false", return

0N/A // "false" immediately, halting the iteration. If "consume" is true,

0N/A // deletes processed entries from logs.

0N/A bool apply_closure(CardTableEntryClosure* cl,

0N/A bool consume = true,

0N/A size_t worker_i = 0);

0N/A

0N/A // Apply the closure to all elements of "buf", down to "index"

0N/A // (inclusive.) If returns "false", then a closure application returned

0N/A // "false", and we return immediately. If "consume" is true, entries are

0N/A // set to NULL as they are processed, so they will not be processed again

0N/A // later.

0N/A static bool apply_closure_to_buffer(CardTableEntryClosure* cl,

0N/A void** buf, size_t index, size_t sz,

0N/A bool consume = true,

0N/A int worker_i = 0);

0N/A void **get_buf() { return _buf;}

0N/A void set_buf(void **buf) {_buf = buf;}

0N/A size_t get_index() { return _index;}

0N/A void reinitialize() { _buf = 0; _sz = 0; _index = 0;}

0N/A};

0N/A

0N/A

0N/A

0N/Aclass DirtyCardQueueSet: public PtrQueueSet {

0N/A CardTableEntryClosure* _closure;

0N/A

0N/A DirtyCardQueue _shared_dirty_card_queue;

0N/A

0N/A // Override.

0N/A bool mut_process_buffer(void** buf);

0N/A

0N/A // Protected by the _cbl_mon.

0N/A FreeIdSet* _free_ids;

0N/A

0N/A // The number of completed buffers processed by mutator and rs thread,

0N/A // respectively.

0N/A jint _processed_buffers_mut;

0N/A jint _processed_buffers_rs_thread;

0N/A

0N/Apublic:

0N/A DirtyCardQueueSet(bool notify_when_complete = true);

0N/A

void initialize(Monitor* cbl_mon, Mutex* fl_lock,

int process_completed_threshold,

int max_completed_queue,

Mutex* lock, PtrQueueSet* fl_owner = NULL);

// The number of parallel ids that can be claimed to allow collector or

// mutator threads to do card-processing work.

static size_t num_par_ids();

static void handle_zero_index_for_thread(JavaThread* t);

// Register "blk" as "the closure" for all queues. Only one such closure

// is allowed. The "apply_closure_to_completed_buffer" method will apply

// this closure to a completed buffer, and "iterate_closure_all_threads"

// applies it to partially-filled buffers (the latter should only be done

// with the world stopped).

void set_closure(CardTableEntryClosure* closure);

// If there is a registered closure for buffers, apply it to all entries

// in all currently-active buffers. This should only be applied at a

// safepoint. (Currently must not be called in parallel; this should

// change in the future.) If "consume" is true, processed entries are

// discarded.

void iterate_closure_all_threads(bool consume = true,

size_t worker_i = 0);

// If there exists some completed buffer, pop it, then apply the

// registered closure to all its elements, nulling out those elements

// processed. If all elements are processed, returns "true". If no

// completed buffers exist, returns false. If a completed buffer exists,

// but is only partially completed before a "yield" happens, the

// partially completed buffer (with its processed elements set to NULL)

// is returned to the completed buffer set, and this call returns false.

bool apply_closure_to_completed_buffer(int worker_i = 0,

int stop_at = 0,

bool during_pause = false);

// If there exists some completed buffer, pop it, then apply the

// specified closure to all its elements, nulling out those elements

// processed. If all elements are processed, returns "true". If no

// completed buffers exist, returns false. If a completed buffer exists,

// but is only partially completed before a "yield" happens, the

// partially completed buffer (with its processed elements set to NULL)

// is returned to the completed buffer set, and this call returns false.

bool apply_closure_to_completed_buffer(CardTableEntryClosure* cl,

int worker_i = 0,

int stop_at = 0,

bool during_pause = false);

// Helper routine for the above.

bool apply_closure_to_completed_buffer_helper(CardTableEntryClosure* cl,

int worker_i,

BufferNode* nd);

BufferNode* get_completed_buffer(int stop_at);

// Applies the current closure to all completed buffers,

// non-consumptively.

void apply_closure_to_all_completed_buffers();

DirtyCardQueue* shared_dirty_card_queue() {

return &_shared_dirty_card_queue;

}

// Deallocate any completed log buffers

void clear();

// If a full collection is happening, reset partial logs, and ignore

// completed ones: the full collection will make them all irrelevant.

void abandon_logs();

// If any threads have partial logs, add them to the global list of logs.

void concatenate_logs();

void clear_n_completed_buffers() { _n_completed_buffers = 0;}

jint processed_buffers_mut() {

return _processed_buffers_mut;

}

jint processed_buffers_rs_thread() {

return _processed_buffers_rs_thread;

}

};

#endif // SHARE_VM_GC_IMPLEMENTATION_G1_DIRTYCARDQUEUE_HPP