threadLocalAllocBuffer.inline.hpp revision 8638:767f36deb0dc 
10Sduke/*
20Sduke * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
30Sduke * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
40Sduke *
50Sduke * This code is free software; you can redistribute it and/or modify it
60Sduke * under the terms of the GNU General Public License version 2 only, as
70Sduke * published by the Free Software Foundation.
80Sduke *
90Sduke * This code is distributed in the hope that it will be useful, but WITHOUT
100Sduke * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
110Sduke * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
120Sduke * version 2 for more details (a copy is included in the LICENSE file that
130Sduke * 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 */
24
25#ifndef SHARE_VM_GC_SHARED_THREADLOCALALLOCBUFFER_INLINE_HPP
26#define SHARE_VM_GC_SHARED_THREADLOCALALLOCBUFFER_INLINE_HPP
27
28#include "gc/shared/collectedHeap.hpp"
29#include "gc/shared/threadLocalAllocBuffer.hpp"
30#include "runtime/thread.hpp"
31#include "utilities/copy.hpp"
32
33inline HeapWord* ThreadLocalAllocBuffer::allocate(size_t size) {
34  invariants();
35  HeapWord* obj = top();
36  if (pointer_delta(end(), obj) >= size) {
37    // successful thread-local allocation
38#ifdef ASSERT
39    // Skip mangling the space corresponding to the object header to
40    // ensure that the returned space is not considered parsable by
41    // any concurrent GC thread.
42    size_t hdr_size = oopDesc::header_size();
43    Copy::fill_to_words(obj + hdr_size, size - hdr_size, badHeapWordVal);
44#endif // ASSERT
45    // This addition is safe because we know that top is
46    // at least size below end, so the add can't wrap.
47    set_top(obj + size);
48
49    invariants();
50    return obj;
51  }
52  return NULL;
53}
54
55inline size_t ThreadLocalAllocBuffer::compute_size(size_t obj_size) {
56  const size_t aligned_obj_size = align_object_size(obj_size);
57
58  // Compute the size for the new TLAB.
59  // The "last" tlab may be smaller to reduce fragmentation.
60  // unsafe_max_tlab_alloc is just a hint.
61  const size_t available_size = Universe::heap()->unsafe_max_tlab_alloc(myThread()) /
62                                                  HeapWordSize;
63  size_t new_tlab_size = MIN2(available_size, desired_size() + aligned_obj_size);
64
65  // Make sure there's enough room for object and filler int[].
66  const size_t obj_plus_filler_size = aligned_obj_size + alignment_reserve();
67  if (new_tlab_size < obj_plus_filler_size) {
68    // If there isn't enough room for the allocation, return failure.
69    if (PrintTLAB && Verbose) {
70      gclog_or_tty->print_cr("ThreadLocalAllocBuffer::compute_size(" SIZE_FORMAT ")"
71                    " returns failure",
72                    obj_size);
73    }
74    return 0;
75  }
76  if (PrintTLAB && Verbose) {
77    gclog_or_tty->print_cr("ThreadLocalAllocBuffer::compute_size(" SIZE_FORMAT ")"
78                  " returns " SIZE_FORMAT,
79                  obj_size, new_tlab_size);
80  }
81  return new_tlab_size;
82}
83
84
85void ThreadLocalAllocBuffer::record_slow_allocation(size_t obj_size) {
86  // Raise size required to bypass TLAB next time. Why? Else there's
87  // a risk that a thread that repeatedly allocates objects of one
88  // size will get stuck on this slow path.
89
90  set_refill_waste_limit(refill_waste_limit() + refill_waste_limit_increment());
91
92  _slow_allocations++;
93
94  if (PrintTLAB && Verbose) {
95    Thread* thrd = myThread();
96    gclog_or_tty->print("TLAB: %s thread: " INTPTR_FORMAT " [id: %2d]"
97                        " obj: " SIZE_FORMAT
98                        " free: " SIZE_FORMAT
99                        " waste: " SIZE_FORMAT "\n",
100                        "slow", p2i(thrd), thrd->osthread()->thread_id(),
101                        obj_size, free(), refill_waste_limit());
102  }
103}
104
105#endif // SHARE_VM_GC_SHARED_THREADLOCALALLOCBUFFER_INLINE_HPP
106