jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/parallelScavenge/psPromotionLAB.hpp@ee019285a52c

8031323: Optionally align objects copied to survivor spaces
Reviewed-by: brutisso, tschatzl

     1 /*

     2  * Copyright (c) 2002, 2012, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONLAB_HPP

    26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONLAB_HPP

    28 #include "gc_implementation/parallelScavenge/objectStartArray.hpp"

    29 #include "gc_interface/collectedHeap.inline.hpp"

    30 #include "memory/allocation.hpp"

    32 //

    33 // PSPromotionLAB is a parallel scavenge promotion lab. This class acts very

    34 // much like a MutableSpace. We couldn't embed a MutableSpace, though, as

    35 // it has a considerable number of asserts and invariants that are violated.

    36 //

    38 class ObjectStartArray;

    40 class PSPromotionLAB : public CHeapObj<mtGC> {

    41  protected:

    42   static size_t filler_header_size;

    44   enum LabState {

    45     needs_flush,

    46     flushed,

    47     zero_size

    48   };

    50   HeapWord* _top;

    51   HeapWord* _bottom;

    52   HeapWord* _end;

    53   LabState _state;

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

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

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

    59   // The shared initialize code invokes this.

    60   debug_only(virtual bool lab_is_valid(MemRegion lab) { return false; });

    62   PSPromotionLAB() : _top(NULL), _bottom(NULL), _end(NULL) { }

    64  public:

    65   // Filling and flushing.

    66   void initialize(MemRegion lab);

    68   virtual void flush();

    70   // Accessors

    71   HeapWord* bottom() const           { return _bottom; }

    72   HeapWord* end() const              { return _end;    }

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

    75   bool is_flushed()                  { return _state == flushed; }

    77   bool unallocate_object(HeapWord* obj, size_t obj_size);

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

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

    82   // Boolean querries.

    83   bool is_empty() const              { return used() == 0; }

    84   bool not_empty() const             { return used() > 0; }

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

    87   // Size computations.  Sizes are in bytes.

    88   size_t capacity() const            { return byte_size(bottom(), end()); }

    89   size_t used() const                { return byte_size(bottom(), top()); }

    90   size_t free() const                { return byte_size(top(),    end()); }

    91 };

    93 class PSYoungPromotionLAB : public PSPromotionLAB {

    94  public:

    95   PSYoungPromotionLAB() { }

    97   // Not MT safe

    98   inline HeapWord* allocate(size_t size);

   100   debug_only(virtual bool lab_is_valid(MemRegion lab);)

   101 };

   103 class PSOldPromotionLAB : public PSPromotionLAB {

   104  private:

   105   ObjectStartArray* _start_array;

   107  public:

   108   PSOldPromotionLAB() : _start_array(NULL) { }

   109   PSOldPromotionLAB(ObjectStartArray* start_array) : _start_array(start_array) { }

   111   void set_start_array(ObjectStartArray* start_array) { _start_array = start_array; }

   113   void flush();

   115   // Not MT safe

   116   HeapWord* allocate(size_t size) {

   117     // Cannot test for this now that we're doing promotion failures

   118     // assert(_state != flushed, "Sanity");

   119     assert(_start_array != NULL, "Sanity");

   120     HeapWord* obj = top();

   121     HeapWord* new_top = obj + size;

   122     // The 'new_top>obj' check is needed to detect overflow of obj+size.

   123     if (new_top > obj && new_top <= end()) {

   124       set_top(new_top);

   125       assert(is_object_aligned((intptr_t)obj) && is_object_aligned((intptr_t)new_top),

   126              "checking alignment");

   127       _start_array->allocate_block(obj);

   128       return obj;

   129     }

   131     return NULL;

   132   }

   134   debug_only(virtual bool lab_is_valid(MemRegion lab));

   135 };

   137 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONLAB_HPP

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