jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/shared/mutableSpace.hpp@12eea04c8b06

6672698: mangle_unused_area() should not remangle the entire heap at each collection.
Summary: Maintain a high water mark for the allocations in a space and mangle only up to that high water mark.
Reviewed-by: ysr, apetrusenko

     1 /*

     2  * Copyright 2001-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 // A MutableSpace is a subtype of ImmutableSpace that supports the

    26 // concept of allocation. This includes the concepts that a space may

    27 // be only partially full, and the querry methods that go with such

    28 // an assumption.

    29 //

    30 // Invariant: (ImmutableSpace +) bottom() <= top() <= end()

    31 // top() is inclusive and end() is exclusive.

    33 class MutableSpaceMangler;

    35 class MutableSpace: public ImmutableSpace {

    36   friend class VMStructs;

    38   // Helper for mangling unused space in debug builds

    39   MutableSpaceMangler* _mangler;

    41  protected:

    42   HeapWord* _top;

    44   MutableSpaceMangler* mangler() { return _mangler; }

    46  public:

    47   virtual ~MutableSpace();

    48   MutableSpace();

    50   // Accessors

    51   HeapWord* top() const                    { return _top;    }

    52   virtual void set_top(HeapWord* value)    { _top = value;   }

    54   HeapWord** top_addr()                    { return &_top; }

    55   HeapWord** end_addr()                    { return &_end; }

    57   virtual void set_bottom(HeapWord* value) { _bottom = value; }

    58   virtual void set_end(HeapWord* value)    { _end = value; }

    60   // Returns a subregion containing all objects in this space.

    61   MemRegion used_region() { return MemRegion(bottom(), top()); }

    63   // Initialization

    64   virtual void initialize(MemRegion mr,

    65                           bool clear_space,

    66                           bool mangle_space);

    67   virtual void clear(bool mangle_space);

    68   // Does the usual initialization but optionally resets top to bottom.

    69 #if 0  // MANGLE_SPACE

    70   void initialize(MemRegion mr, bool clear_space, bool reset_top);

    71 #endif

    72   virtual void update() { }

    73   virtual void accumulate_statistics() { }

    75   // Methods used in mangling.  See descriptions under SpaceMangler.

    76   virtual void mangle_unused_area() PRODUCT_RETURN;

    77   virtual void mangle_unused_area_complete() PRODUCT_RETURN;

    78   virtual void check_mangled_unused_area(HeapWord* limit) PRODUCT_RETURN;

    79   virtual void check_mangled_unused_area_complete() PRODUCT_RETURN;

    80   virtual void set_top_for_allocations(HeapWord* v) PRODUCT_RETURN;

    82   // Used to save the space's current top for later use during mangling.

    83   virtual void set_top_for_allocations() PRODUCT_RETURN;

    85   virtual void ensure_parsability() { }

    87   virtual void mangle_region(MemRegion mr) PRODUCT_RETURN;

    89   // Boolean querries.

    90   bool is_empty() const              { return used_in_words() == 0; }

    91   bool not_empty() const             { return used_in_words() > 0; }

    92   bool contains(const void* p) const { return _bottom <= p && p < _end; }

    94   // Size computations.  Sizes are in bytes.

    95   size_t used_in_bytes() const                { return used_in_words() * HeapWordSize; }

    96   size_t free_in_bytes() const                { return free_in_words() * HeapWordSize; }

    98   // Size computations.  Sizes are in heapwords.

    99   virtual size_t used_in_words() const                    { return pointer_delta(top(), bottom()); }

   100   virtual size_t free_in_words() const                    { return pointer_delta(end(),    top()); }

   101   virtual size_t tlab_capacity(Thread* thr) const         { return capacity_in_bytes();            }

   102   virtual size_t unsafe_max_tlab_alloc(Thread* thr) const { return free_in_bytes();                }

   104   // Allocation (return NULL if full)

   105   virtual HeapWord* allocate(size_t word_size);

   106   virtual HeapWord* cas_allocate(size_t word_size);

   107   // Optional deallocation. Used in NUMA-allocator.

   108   bool cas_deallocate(HeapWord *obj, size_t size);

   110   // Iteration.

   111   void oop_iterate(OopClosure* cl);

   112   void object_iterate(ObjectClosure* cl);

   114   // Debugging

   115   virtual void print() const;

   116   virtual void print_on(outputStream* st) const;

   117   virtual void print_short() const;

   118   virtual void print_short_on(outputStream* st) const;

   119   virtual void verify(bool allow_dirty);

   120 };

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/gc_implementation/shared/mutableSpace.hpp@12eea04c8b06

src/share/vm/gc_implementation/shared/mutableSpace.hpp