hotspot/src/share/vm/memory/binaryTreeDictionary.hpp
author mgerdin
Mon, 04 Jun 2012 09:21:53 +0200
changeset 12933 0b79a2cea769
parent 12509 6228e2085074
child 13728 882756847a04
permissions -rw-r--r--
7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup Summary: Add "using" keyword to import base class functions from FreeList<T> to fix template name lookup in gcc 4.7 Reviewed-by: brutisso, iveresov
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
     2
 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4574
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4574
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4574
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    25
#ifndef SHARE_VM_MEMORY_BINARYTREEDICTIONARY_HPP
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    26
#define SHARE_VM_MEMORY_BINARYTREEDICTIONARY_HPP
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    28
#include "memory/freeBlockDictionary.hpp"
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    29
#include "memory/freeList.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
 * A binary tree based search structure for free blocks.
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    33
 * This is currently used in the Concurrent Mark&Sweep implementation, but
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    34
 * will be used for free block management for metadata.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// A TreeList is a FreeList which can be used to maintain a
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// binary tree of free lists.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    40
template <class Chunk> class TreeChunk;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    41
template <class Chunk> class BinaryTreeDictionary;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    42
template <class Chunk> class AscendTreeCensusClosure;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    43
template <class Chunk> class DescendTreeCensusClosure;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    44
template <class Chunk> class DescendTreeSearchClosure;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    46
template <class Chunk>
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    47
class TreeList: public FreeList<Chunk> {
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    48
  friend class TreeChunk<Chunk>;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    49
  friend class BinaryTreeDictionary<Chunk>;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    50
  friend class AscendTreeCensusClosure<Chunk>;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    51
  friend class DescendTreeCensusClosure<Chunk>;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    52
  friend class DescendTreeSearchClosure<Chunk>;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    53
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    54
  TreeList<Chunk>* _parent;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    55
  TreeList<Chunk>* _left;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    56
  TreeList<Chunk>* _right;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
 protected:
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    59
  TreeList<Chunk>* parent() const { return _parent; }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    60
  TreeList<Chunk>* left()   const { return _left;   }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    61
  TreeList<Chunk>* right()  const { return _right;  }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    62
12933
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    63
  // Explicitly import these names into our namespace to fix name lookup with templates
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    64
  using FreeList<Chunk>::head;
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    65
  using FreeList<Chunk>::set_head;
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    66
12933
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    67
  using FreeList<Chunk>::tail;
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    68
  using FreeList<Chunk>::set_tail;
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    69
  using FreeList<Chunk>::link_tail;
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    70
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    71
  using FreeList<Chunk>::increment_count;
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    72
  NOT_PRODUCT(using FreeList<Chunk>::increment_returned_bytes_by;)
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    73
  using FreeList<Chunk>::verify_chunk_in_free_list;
0b79a2cea769 7172226: HotSpot fails to build with GCC 4.7 because of stricter c++ argument dependent lookup
mgerdin
parents: 12509
diff changeset
    74
  using FreeList<Chunk>::size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  // Accessors for links in tree.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
    78
  void set_left(TreeList<Chunk>* tl) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    _left   = tl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    if (tl != NULL)
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
    81
      tl->set_parent(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  }
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
    83
  void set_right(TreeList<Chunk>* tl) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    _right  = tl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    if (tl != NULL)
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
    86
      tl->set_parent(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  }
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
    88
  void set_parent(TreeList<Chunk>* tl)  { _parent = tl;   }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  void clearLeft()               { _left = NULL;   }
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
    91
  void clear_right()              { _right = NULL;  }
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
    92
  void clear_parent()             { _parent = NULL; }
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
    93
  void initialize()              { clearLeft(); clear_right(), clear_parent(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // For constructing a TreeList from a Tree chunk or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  // address and size.
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    97
  static TreeList<Chunk>* as_TreeList(TreeChunk<Chunk>* tc);
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
    98
  static TreeList<Chunk>* as_TreeList(HeapWord* addr, size_t size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // Returns the head of the free list as a pointer to a TreeChunk.
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   101
  TreeChunk<Chunk>* head_as_TreeChunk();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // Returns the first available chunk in the free list as a pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // to a TreeChunk.
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   105
  TreeChunk<Chunk>* first_available();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 670
diff changeset
   107
  // Returns the block with the largest heap address amongst
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 670
diff changeset
   108
  // those in the list for this size; potentially slow and expensive,
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 670
diff changeset
   109
  // use with caution!
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   110
  TreeChunk<Chunk>* largest_address();
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 670
diff changeset
   111
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   112
  // remove_chunk_replace_if_needed() removes the given "tc" from the TreeList.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  // If "tc" is the first chunk in the list, it is also the
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   114
  // TreeList that is the node in the tree.  remove_chunk_replace_if_needed()
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  // returns the possibly replaced TreeList* for the node in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  // the tree.  It also updates the parent of the original
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  // node to point to the new node.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   118
  TreeList<Chunk>* remove_chunk_replace_if_needed(TreeChunk<Chunk>* tc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // See FreeList.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   120
  void return_chunk_at_head(TreeChunk<Chunk>* tc);
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   121
  void return_chunk_at_tail(TreeChunk<Chunk>* tc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   124
// A TreeChunk is a subclass of a Chunk that additionally
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
// maintains a pointer to the free list on which it is currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
// linked.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
// A TreeChunk is also used as a node in the binary tree.  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
// allows the binary tree to be maintained without any additional
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
// storage (the free chunks are used).  In a binary tree the first
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
// chunk in the free list is also the tree node.  Note that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
// TreeChunk has an embedded TreeList for this purpose.  Because
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
// the first chunk in the list is distinguished in this fashion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
// (also is the node in the tree), it is the last chunk to be found
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
// on the free list for a node in the tree and is only removed if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
// it is the last chunk on the free list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   137
template <class Chunk>
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   138
class TreeChunk : public Chunk {
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   139
  friend class TreeList<Chunk>;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   140
  TreeList<Chunk>* _list;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   141
  TreeList<Chunk> _embedded_list;  // if non-null, this chunk is on _list
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
 protected:
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   143
  TreeList<Chunk>* embedded_list() const { return (TreeList<Chunk>*) &_embedded_list; }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   144
  void set_embedded_list(TreeList<Chunk>* v) { _embedded_list = *v; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
 public:
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   146
  TreeList<Chunk>* list() { return _list; }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   147
  void set_list(TreeList<Chunk>* v) { _list = v; }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   148
  static TreeChunk<Chunk>* as_TreeChunk(Chunk* fc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // Initialize fields in a TreeChunk that should be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // initialized when the TreeChunk is being added to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // a free list in the tree.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  void initialize() { embedded_list()->initialize(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   154
  Chunk* next() const { return Chunk::next(); }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   155
  Chunk* prev() const { return Chunk::prev(); }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   156
  size_t size() const volatile { return Chunk::size(); }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   157
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // debugging
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   159
  void verify_tree_chunk_list() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   163
template <class Chunk>
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   164
class BinaryTreeDictionary: public FreeBlockDictionary<Chunk> {
578
862a85ed20db 6670684: 4/5 SA command universe did not print out CMS space information
dcubed
parents: 1
diff changeset
   165
  friend class VMStructs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  bool       _splay;
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   167
  size_t     _total_size;
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   168
  size_t     _total_free_blocks;
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   169
  TreeList<Chunk>* _root;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   170
  bool       _adaptive_freelists;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // private accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  bool splay() const { return _splay; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  void set_splay(bool v) { _splay = v; }
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   175
  void set_total_size(size_t v) { _total_size = v; }
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   176
  virtual void inc_total_size(size_t v);
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   177
  virtual void dec_total_size(size_t v);
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   178
  size_t total_free_blocks() const { return _total_free_blocks; }
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   179
  void set_total_free_blocks(size_t v) { _total_free_blocks = v; }
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   180
  TreeList<Chunk>* root() const { return _root; }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   181
  void set_root(TreeList<Chunk>* v) { _root = v; }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   182
  bool adaptive_freelists() { return _adaptive_freelists; }
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   183
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   184
  // This field is added and can be set to point to the
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   185
  // the Mutex used to synchronize access to the
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   186
  // dictionary so that assertion checking can be done.
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   187
  // For example it is set to point to _parDictionaryAllocLock.
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   188
  NOT_PRODUCT(Mutex* _lock;)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  // Remove a chunk of size "size" or larger from the tree and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  // return it.  If the chunk
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  // is the last chunk of that size, remove the node for that size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  // from the tree.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   194
  TreeChunk<Chunk>* get_chunk_from_tree(size_t size, enum FreeBlockDictionary<Chunk>::Dither dither, bool splay);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  // Return a list of the specified size or NULL from the tree.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  // The list is not removed from the tree.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   197
  TreeList<Chunk>* find_list (size_t size) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // Remove this chunk from the tree.  If the removal results
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  // in an empty list in the tree, remove the empty list.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   200
  TreeChunk<Chunk>* remove_chunk_from_tree(TreeChunk<Chunk>* tc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  // Remove the node in the trees starting at tl that has the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  // minimum value and return it.  Repair the tree as needed.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   203
  TreeList<Chunk>* remove_tree_minimum(TreeList<Chunk>* tl);
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   204
  void       semi_splay_step(TreeList<Chunk>* tl);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  // Add this free chunk to the tree.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   206
  void       insert_chunk_in_tree(Chunk* freeChunk);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
 public:
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   208
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   209
  static const size_t min_tree_chunk_size  = sizeof(TreeChunk<Chunk>)/HeapWordSize;
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   210
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   211
  void       verify_tree() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  // verify that the given chunk is in the tree.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   213
  bool       verify_chunk_in_free_list(Chunk* tc) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
 private:
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   215
  void          verify_tree_helper(TreeList<Chunk>* tl) const;
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   216
  static size_t verify_prev_free_ptrs(TreeList<Chunk>* tl);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  // Returns the total number of chunks in the list.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   219
  size_t     total_list_length(TreeList<Chunk>* tl) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  // Returns the total number of words in the chunks in the tree
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  // starting at "tl".
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   222
  size_t     total_size_in_tree(TreeList<Chunk>* tl) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  // Returns the sum of the square of the size of each block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  // in the tree starting at "tl".
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   225
  double     sum_of_squared_block_sizes(TreeList<Chunk>* const tl) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  // Returns the total number of free blocks in the tree starting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  // at "tl".
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   228
  size_t     total_free_blocks_in_tree(TreeList<Chunk>* tl) const;
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   229
  size_t     num_free_blocks() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  size_t     treeHeight() const;
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   231
  size_t     tree_height_helper(TreeList<Chunk>* tl) const;
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   232
  size_t     total_nodes_in_tree(TreeList<Chunk>* tl) const;
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   233
  size_t     total_nodes_helper(TreeList<Chunk>* tl) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  // Constructor
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   237
  BinaryTreeDictionary(bool adaptive_freelists, bool splay = false);
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   238
  BinaryTreeDictionary(MemRegion mr, bool adaptive_freelists, bool splay = false);
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   239
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   240
  // Public accessors
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   241
  size_t total_size() const { return _total_size; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  // Reset the dictionary to the initial conditions with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  // a single free chunk.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  void       reset(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  void       reset(HeapWord* addr, size_t size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  // Reset the dictionary to be empty.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  void       reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  // Return a chunk of size "size" or greater from
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  // the tree.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  // want a better dynamic splay strategy for the future.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   253
  Chunk* get_chunk(size_t size, enum FreeBlockDictionary<Chunk>::Dither dither) {
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   254
    FreeBlockDictionary<Chunk>::verify_par_locked();
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   255
    Chunk* res = get_chunk_from_tree(size, dither, splay());
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   256
    assert(res == NULL || res->is_free(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
           "Should be returning a free chunk");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
    return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   261
  void return_chunk(Chunk* chunk) {
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   262
    FreeBlockDictionary<Chunk>::verify_par_locked();
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   263
    insert_chunk_in_tree(chunk);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   266
  void remove_chunk(Chunk* chunk) {
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   267
    FreeBlockDictionary<Chunk>::verify_par_locked();
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   268
    remove_chunk_from_tree((TreeChunk<Chunk>*)chunk);
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   269
    assert(chunk->is_free(), "Should still be a free chunk");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   272
  size_t     max_chunk_size() const;
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   273
  size_t     total_chunk_size(debug_only(const Mutex* lock)) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    debug_only(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
      if (lock != NULL && lock->owned_by_self()) {
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   276
        assert(total_size_in_tree(root()) == total_size(),
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   277
               "_total_size inconsistency");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    )
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   280
    return total_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   283
  size_t     min_size() const {
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   284
    return min_tree_chunk_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  double     sum_of_squared_block_sizes() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
    return sum_of_squared_block_sizes(root());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   291
  Chunk* find_chunk_ends_at(HeapWord* target) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  // Find the list with size "size" in the binary tree and update
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  // the statistics in the list according to "split" (chunk was
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  // split or coalesce) and "birth" (chunk was added or removed).
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   296
  void       dict_census_udpate(size_t size, bool split, bool birth);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // Return true if the dictionary is overpopulated (more chunks of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  // this size than desired) for size "size".
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   299
  bool       coal_dict_over_populated(size_t size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  // Methods called at the beginning of a sweep to prepare the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  // statistics for the sweep.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   302
  void       begin_sweep_dict_census(double coalSurplusPercent,
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 670
diff changeset
   303
                                  float inter_sweep_current,
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 670
diff changeset
   304
                                  float inter_sweep_estimate,
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 670
diff changeset
   305
                                  float intra_sweep_estimate);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  // Methods called after the end of a sweep to modify the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  // statistics for the sweep.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   308
  void       end_sweep_dict_census(double splitSurplusPercent);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  // Return the largest free chunk in the tree.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   310
  Chunk* find_largest_dict() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  // Accessors for statistics
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   312
  void       set_tree_surplus(double splitSurplusPercent);
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   313
  void       set_tree_hints(void);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  // Reset statistics for all the lists in the tree.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   315
  void       clear_tree_census(void);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  // Print the statistcis for all the lists in the tree.  Also may
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  // print out summaries.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   318
  void       print_dict_census(void) const;
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 670
diff changeset
   319
  void       print_free_lists(outputStream* st) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   321
  // For debugging.  Returns the sum of the _returned_bytes for
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  // all lists in the tree.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   323
  size_t     sum_dict_returned_bytes()     PRODUCT_RETURN0;
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   324
  // Sets the _returned_bytes for all the lists in the tree to zero.
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   325
  void       initialize_dict_returned_bytes()      PRODUCT_RETURN;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  // For debugging.  Return the total number of chunks in the dictionary.
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   327
  size_t     total_count()       PRODUCT_RETURN0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
12509
6228e2085074 7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
jmasa
parents: 12507
diff changeset
   329
  void       report_statistics() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  void       verify() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   333
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 7397
diff changeset
   334
#endif // SHARE_VM_MEMORY_BINARYTREEDICTIONARY_HPP