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

rev 6141 : [mq]: review_fixes

*** 71,82 ****
  // 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 is evacuated to an old heap region. The second
! // appempt 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
--- 71,82 ----
  // 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
*** 115,125 ****
    // 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 approapriate 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);
  
--- 115,125 ----
    // 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);
  
*** 134,146 ****
  };
  
  //
  // 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 create 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 exclusing access to a
  // queue or a table partition.
  //
  class G1StringDedupUnlinkOrOopsDoClosure : public StackObj {
  private:
    BoolObjectClosure*  _is_alive;
--- 134,146 ----
  };
  
  //
  // 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;
*** 174,184 ****
      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 parition 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
--- 174,184 ----
      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