/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#include "gc_implementation/parallelScavenge/psPromotionLAB.hpp"
#include "gc_implementation/shared/gcTrace.hpp"
#include "gc_implementation/shared/copyFailedInfo.hpp"
#include "memory/allocation.hpp"
#include "utilities/taskqueue.hpp"
//
// psPromotionManager is used by a single thread to manage object survival
// during a scavenge. The promotion manager contains thread local data only.
//
// NOTE! Be careful when allocating the stacks on cheap. If you are going
// to use a promotion manager in more than one thread, the stacks MUST be
// on cheap. This can lead to memory leaks, though, as they are not auto
// deallocated.
//
// FIX ME FIX ME Add a destructor, and don't rely on the user to drain/flush/deallocate!
//
// Move to some global location
// End move to some global location
class MutableSpace;
class PSOldGen;
class ParCompactionManager;
friend class PSScavenge;
friend class PSRefProcTaskExecutor;
private:
#if TASKQUEUE_STATS
void print_taskqueue_stats(uint i) const;
void print_local_stats(uint i) const;
static void print_stats();
void reset_stats();
#endif // TASKQUEUE_STATS
bool _young_gen_is_full;
bool _old_gen_is_full;
bool _totally_drain;
// Accessors
template <class T> inline void claim_or_forward_internal_depth(T* p);
// On the task queues we push reference locations as well as
// partially-scanned arrays (in the latter case, we push an oop to
// the from-space image of the array and the length on the
// from-space image indicates how many entries on the array we still
// need to scan; this is basically how ParNew does partial array
// scanning too). To be able to distinguish between reference
// locations and partially-scanned array oops we simply mask the
// latter oops with 0x01. The next three methods do the masking,
// unmasking, and checking whether the oop is masked or not. Notice
// that the signature of the mask and unmask methods looks a bit
// strange, as they accept and return different types (oop and
// oop*). This is because of the difference in types between what
// the task queue holds (oop*) and oops to partially-scanned arrays
// (oop). We do all the necessary casting in the mask / unmask
// methods to avoid sprinkling the rest of the code with more casts.
// These are added to the taskqueue so PS_CHUNKED_ARRAY_OOP_MASK (or any
// future masks) can't conflict with COMPRESSED_OOP_MASK
// If something is marked chunked it's always treated like wide oop*
}
return ret;
}
return ret;
}
template <class T> void push_depth(T* p) {
claimed_stack_depth()->push(p);
}
protected:
public:
// Static
static void initialize();
static void pre_scavenge();
static PSPromotionManager* vm_thread_promotion_manager();
}
// Accessors
return &_claimed_stack_depth;
}
// Promotion methods
void reset();
void flush_labs();
}
public:
void drain_stacks_cond_depth() {
drain_stacks_depth(false);
}
}
void drain_stacks_depth(bool totally_drain);
bool stacks_empty() {
return claimed_stack_depth()->is_empty();
}
inline void process_popped_location_depth(StarTask p);
template <class T> inline void claim_or_forward_depth(T* p);
};
#endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONMANAGER_HPP