< prev index next >
src/hotspot/share/gc/shared/stringdedup/stringDedup.hpp
Print this page
*** 1,7 ****
/*
! * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
--- 1,7 ----
/*
! * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*** 20,31 ****
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
! #ifndef SHARE_VM_GC_G1_G1STRINGDEDUP_HPP
! #define SHARE_VM_GC_G1_G1STRINGDEDUP_HPP
//
// String Deduplication
//
// String deduplication aims to reduce the heap live-set by deduplicating identical
--- 20,31 ----
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
! #ifndef SHARE_VM_GC_SHARED_STRINGDEDUP_STRINGDEDUP_HPP
! #define SHARE_VM_GC_SHARED_STRINGDEDUP_STRINGDEDUP_HPP
//
// String Deduplication
//
// String deduplication aims to reduce the heap live-set by deduplicating identical
*** 47,76 ****
// String object is adjusted to point to that character array, releasing the reference
// to the original array allowing it to eventually be garbage collected. If the lookup
// fails the character array is instead inserted into the hashtable so that this array
// can be shared at some point in the future.
//
! // Candidate selection
! //
! // An object is considered a deduplication candidate if all of the following
! // statements are true:
! //
! // - The object is an instance of java.lang.String
! //
! // - The object is being evacuated from a young heap region
! //
! // - The object is being evacuated to a young/survivor heap region and the
! // object's age is equal to the deduplication age threshold
! //
! // or
! //
! // The object is being evacuated to an old heap region and the object's age is
! // less than the deduplication age threshold
! //
! // Once an string object has been promoted to an old region, or its age is higher
! // than the deduplication age threshold, is will never become a candidate again.
! // This approach avoids making the same object a candidate more than once.
//
// Interned strings are a bit special. They are explicitly deduplicated just before
// being inserted into the StringTable (to avoid counteracting C2 optimizations done
// on string literals), then they also become deduplication candidates if they reach
// the deduplication age threshold or are evacuated to an old heap region. The second
--- 47,57 ----
// String object is adjusted to point to that character array, releasing the reference
// to the original array allowing it to eventually be garbage collected. If the lookup
// fails the character array is instead inserted into the hashtable so that this array
// can be shared at some point in the future.
//
! // Candidate selection criteria is GC specific.
//
// Interned strings are a bit special. They are explicitly deduplicated just before
// being inserted into the StringTable (to avoid counteracting C2 optimizations done
// on string literals), then they also become deduplication candidates if they reach
// the deduplication age threshold or are evacuated to an old heap region. The second
*** 80,189 ****
//
// For additional information on string deduplication, please see JEP 192,
// http://openjdk.java.net/jeps/192
//
#include "memory/allocation.hpp"
! #include "oops/oop.hpp"
!
! class OopClosure;
! class BoolObjectClosure;
! class ThreadClosure;
! class outputStream;
! class G1StringDedupTable;
! class G1StringDedupUnlinkOrOopsDoClosure;
! class G1GCPhaseTimes;
//
// Main interface for interacting with string deduplication.
//
! class G1StringDedup : public AllStatic {
private:
! // Single state for checking if both G1 and string deduplication is enabled.
static bool _enabled;
- // Candidate selection policies, returns true if the given object is
- // candidate for string deduplication.
- static bool is_candidate_from_mark(oop obj);
- static bool is_candidate_from_evacuation(bool from_young, bool to_young, oop obj);
-
public:
! // Returns true if both G1 and string deduplication is enabled.
static bool is_enabled() {
return _enabled;
}
- // Initialize string deduplication.
- static void initialize();
-
// Stop the deduplication thread.
static void stop();
// Immediately deduplicates the given String object, bypassing the
// the deduplication queue.
static void deduplicate(oop java_string);
! // Enqueues a deduplication candidate for later processing by the deduplication
! // thread. Before enqueuing, these functions apply the appropriate candidate
! // selection policy to filters out non-candidates.
! static void enqueue_from_mark(oop java_string, uint worker_id);
! static void enqueue_from_evacuation(bool from_young, bool to_young,
! unsigned int queue, oop java_string);
!
! static void oops_do(OopClosure* keep_alive);
! static void parallel_unlink(G1StringDedupUnlinkOrOopsDoClosure* unlink, uint worker_id);
! static void unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive,
! bool allow_resize_and_rehash, G1GCPhaseTimes* phase_times = NULL);
static void threads_do(ThreadClosure* tc);
static void print_worker_threads_on(outputStream* st);
static void verify();
};
//
! // This closure encapsulates the state and the closures needed when scanning
// the deduplication queue and table during the unlink_or_oops_do() operation.
- // A single instance of this closure is created and then shared by all worker
- // threads participating in the scan. The _next_queue and _next_bucket fields
- // provide a simple mechanism for GC workers to claim exclusive access to a
- // queue or a table partition.
//
! class G1StringDedupUnlinkOrOopsDoClosure : public StackObj {
private:
BoolObjectClosure* _is_alive;
OopClosure* _keep_alive;
- G1StringDedupTable* _resized_table;
- G1StringDedupTable* _rehashed_table;
- size_t _next_queue;
- size_t _next_bucket;
public:
! G1StringDedupUnlinkOrOopsDoClosure(BoolObjectClosure* is_alive,
! OopClosure* keep_alive,
! bool allow_resize_and_rehash);
! ~G1StringDedupUnlinkOrOopsDoClosure();
!
! bool is_resizing() {
! return _resized_table != NULL;
! }
!
! G1StringDedupTable* resized_table() {
! return _resized_table;
! }
!
! bool is_rehashing() {
! return _rehashed_table != NULL;
! }
!
! // Atomically claims the next available queue for exclusive access by
! // the current thread. Returns the queue number of the claimed queue.
! size_t claim_queue();
!
! // Atomically claims the next available table partition for exclusive
! // access by the current thread. Returns the table bucket number where
! // the claimed partition starts.
! size_t claim_table_partition(size_t partition_size);
// Applies and returns the result from the is_alive closure, or
// returns true if no such closure was provided.
bool is_alive(oop o) {
if (_is_alive != NULL) {
--- 61,127 ----
//
// For additional information on string deduplication, please see JEP 192,
// http://openjdk.java.net/jeps/192
//
+ #include "gc/shared/stringdedup/stringDedupQueue.hpp"
+ #include "gc/shared/stringdedup/stringDedupStat.hpp"
+ #include "gc/shared/stringdedup/stringDedupTable.hpp"
#include "memory/allocation.hpp"
! #include "runtime/thread.hpp"
//
// Main interface for interacting with string deduplication.
//
! class StringDedup : public AllStatic {
private:
! // Single state for checking if string deduplication is enabled.
static bool _enabled;
public:
! // Returns true if string deduplication is enabled.
static bool is_enabled() {
return _enabled;
}
// Stop the deduplication thread.
static void stop();
// Immediately deduplicates the given String object, bypassing the
// the deduplication queue.
static void deduplicate(oop java_string);
! static void parallel_unlink(StringDedupUnlinkOrOopsDoClosure* unlink, uint worker_id);
static void threads_do(ThreadClosure* tc);
static void print_worker_threads_on(outputStream* st);
static void verify();
+
+ // GC support
+ static void gc_prologue(bool resize_and_rehash_table);
+ static void gc_epilogue();
+
+ protected:
+ // Initialize string deduplication.
+ // QUEUE: String Dedup Queue implementation
+ // STAT: String Dedup Stat implementation
+ template <typename QUEUE, typename STAT>
+ static void initialize_impl();
};
//
! // This closure encapsulates the closures needed when scanning
// the deduplication queue and table during the unlink_or_oops_do() operation.
//
! class StringDedupUnlinkOrOopsDoClosure : public StackObj {
private:
BoolObjectClosure* _is_alive;
OopClosure* _keep_alive;
public:
! StringDedupUnlinkOrOopsDoClosure(BoolObjectClosure* is_alive,
! OopClosure* keep_alive);
// Applies and returns the result from the is_alive closure, or
// returns true if no such closure was provided.
bool is_alive(oop o) {
if (_is_alive != NULL) {
*** 199,204 ****
_keep_alive->do_oop(p);
}
}
};
! #endif // SHARE_VM_GC_G1_G1STRINGDEDUP_HPP
--- 137,142 ----
_keep_alive->do_oop(p);
}
}
};
! #endif // SHARE_VM_GC_SHARED_STRINGDEDUP_STRINGDEDUP_HPP
< prev index next >