1 /*
2  * Copyright (c) 2018, Red Hat, Inc. All rights reserved.
3  *
4  * This code is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License version 2 only, as
6  * published by the Free Software Foundation.
7  *
8  * This code is distributed in the hope that it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
11  * version 2 for more details (a copy is included in the LICENSE file that
12  * accompanied this code).
13  *
14  * You should have received a copy of the GNU General Public License version
15  * 2 along with this work; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17  *
18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19  * or visit www.oracle.com if you need additional information or have any
20  * questions.
21  *
22  */
23 
24 #ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAHALLOCREQUEST_HPP
25 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAHALLOCREQUEST_HPP
26 
27 #include "memory/allocation.hpp"
28 
29 class ShenandoahAllocRequest : StackObj {
30 public:
31   enum Type {
32     _alloc_shared,      // Allocate common, outside of TLAB
33     _alloc_shared_gc,   // Allocate common, outside of GCLAB
34     _alloc_tlab,        // Allocate TLAB
35     _alloc_gclab,       // Allocate GCLAB
36     _ALLOC_LIMIT
37   };
38 
alloc_type_to_string(Type type)39   static const char* alloc_type_to_string(Type type) {
40     switch (type) {
41       case _alloc_shared:
42         return "Shared";
43       case _alloc_shared_gc:
44         return "Shared GC";
45       case _alloc_tlab:
46         return "TLAB";
47       case _alloc_gclab:
48         return "GCLAB";
49       default:
50         ShouldNotReachHere();
51         return "";
52     }
53   }
54 
55 private:
56   size_t _min_size;
57   size_t _requested_size;
58   size_t _actual_size;
59   Type _alloc_type;
60 #ifdef ASSERT
61   bool _actual_size_set;
62 #endif
63 
ShenandoahAllocRequest(size_t _min_size,size_t _requested_size,Type _alloc_type)64   ShenandoahAllocRequest(size_t _min_size, size_t _requested_size, Type _alloc_type) :
65           _min_size(_min_size), _requested_size(_requested_size),
66           _actual_size(0), _alloc_type(_alloc_type)
67 #ifdef ASSERT
68           , _actual_size_set(false)
69 #endif
70   {}
71 
72 public:
for_tlab(size_t min_size,size_t requested_size)73   static inline ShenandoahAllocRequest for_tlab(size_t min_size, size_t requested_size) {
74     return ShenandoahAllocRequest(min_size, requested_size, _alloc_tlab);
75   }
76 
for_gclab(size_t min_size,size_t requested_size)77   static inline ShenandoahAllocRequest for_gclab(size_t min_size, size_t requested_size) {
78     return ShenandoahAllocRequest(min_size, requested_size, _alloc_gclab);
79   }
80 
for_shared_gc(size_t requested_size)81   static inline ShenandoahAllocRequest for_shared_gc(size_t requested_size) {
82     return ShenandoahAllocRequest(0, requested_size, _alloc_shared_gc);
83   }
84 
for_shared(size_t requested_size)85   static inline ShenandoahAllocRequest for_shared(size_t requested_size) {
86     return ShenandoahAllocRequest(0, requested_size, _alloc_shared);
87   }
88 
size()89   inline size_t size() {
90     return _requested_size;
91   }
92 
type()93   inline Type type() {
94     return _alloc_type;
95   }
96 
type_string()97   inline const char* type_string() {
98     return alloc_type_to_string(_alloc_type);
99   }
100 
min_size()101   inline size_t min_size() {
102     assert (is_lab_alloc(), "Only access for LAB allocs");
103     return _min_size;
104   }
105 
actual_size()106   inline size_t actual_size() {
107     assert (_actual_size_set, "Should be set");
108     return _actual_size;
109   }
110 
set_actual_size(size_t v)111   inline void set_actual_size(size_t v) {
112 #ifdef ASSERT
113     assert (!_actual_size_set, "Should not be set");
114     _actual_size_set = true;
115 #endif
116     _actual_size = v;
117   }
118 
is_mutator_alloc()119   inline bool is_mutator_alloc() {
120     switch (_alloc_type) {
121       case _alloc_tlab:
122       case _alloc_shared:
123         return true;
124       case _alloc_gclab:
125       case _alloc_shared_gc:
126         return false;
127       default:
128         ShouldNotReachHere();
129         return false;
130     }
131   }
132 
is_gc_alloc()133   inline bool is_gc_alloc() {
134     switch (_alloc_type) {
135       case _alloc_tlab:
136       case _alloc_shared:
137         return false;
138       case _alloc_gclab:
139       case _alloc_shared_gc:
140         return true;
141       default:
142         ShouldNotReachHere();
143         return false;
144     }
145   }
146 
is_lab_alloc()147   inline bool is_lab_alloc() {
148     switch (_alloc_type) {
149       case _alloc_tlab:
150       case _alloc_gclab:
151         return true;
152       case _alloc_shared:
153       case _alloc_shared_gc:
154         return false;
155       default:
156         ShouldNotReachHere();
157         return false;
158     }
159   }
160 };
161 
162 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHALLOCREQUEST_HPP
163