jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/g1/g1StringDedup.hpp@e7d0505c8a30 (annotated)

src/share/vm/gc_implementation/g1/g1StringDedup.hpp@e7d0505c8a30 (annotated)

src/share/vm/gc_implementation/g1/g1StringDedup.hpp

Fri, 10 Oct 2014 15:51:58 +0200

author: tschatzl
date: Fri, 10 Oct 2014 15:51:58 +0200
changeset 7257: e7d0505c8a30
parent 6690: 1772223a25a2
child 6876: 710a3c8b516e
child 7658: c3fcc09c9239
permissions: -rw-r--r--

8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso

 /*
  * Copyright (c) 2014, 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.
  *
  * 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.
  *
  */
 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1STRINGDEDUP_HPP
 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1STRINGDEDUP_HPP
 //
 // String Deduplication
 //
 // String deduplication aims to reduce the heap live-set by deduplicating identical
 // instances of String so that they share the same backing character array.
 //
 // The deduplication process is divided in two main parts, 1) finding the objects to
 // deduplicate, and 2) deduplicating those objects. The first part is done as part of
 // a normal GC cycle when objects are marked or evacuated. At this time a check is
 // applied on each object to check if it is a candidate for deduplication. If so, the
 // object is placed on the deduplication queue for later processing. The second part,
 // processing the objects on the deduplication queue, is a concurrent phase which
 // starts right after the stop-the-wold marking/evacuation phase. This phase is
 // executed by the deduplication thread, which pulls deduplication candidates of the
 // deduplication queue and tries to deduplicate them.
 //
 // A deduplication hashtable is used to keep track of all unique character arrays
 // used by String objects. When deduplicating, a lookup is made in this table to see
 // if there is already an identical character array somewhere on the heap. If so, the
 // 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
 // attempt to deduplicate such strings will be in vain, but we have no fast way of
 // filtering them out. This has not shown to be a problem, as the number of interned
 // strings is usually dwarfed by the number of normal (non-interned) strings.
 //
 // 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;
 //
 // 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);
   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 unlink(BoolObjectClosure* is_alive);
   static void unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive,
                                 bool allow_resize_and_rehash = true);
   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() {
     return (size_t)Atomic::add_ptr(1, &_next_queue) - 1;
   }
   // 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) {
     return (size_t)Atomic::add_ptr(partition_size, &_next_bucket) - 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) {
       return _is_alive->do_object_b(o);
     }
     return true;
   }
   // Applies the keep_alive closure, or does nothing if no such
   // closure was provided.
   void keep_alive(oop* p) {
     if (_keep_alive != NULL) {
       _keep_alive->do_oop(p);
     }
   }
 };
 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1STRINGDEDUP_HPP

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/gc_implementation/g1/g1StringDedup.hpp@e7d0505c8a30 (annotated)

src/share/vm/gc_implementation/g1/g1StringDedup.hpp