1 /*
2 * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2018, 2020 SAP SE. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #ifndef GTEST_METASPACE_METASPACE_RANGEHELPERS_HPP
27 #define GTEST_METASPACE_METASPACE_RANGEHELPERS_HPP
28
29 // We use ranges-of-things in these tests a lot so some helpers help
30 // keeping the code small.
31
32 #include "memory/allocation.hpp"
33 #include "memory/metaspace/chunkLevel.hpp"
34 #include "runtime/os.hpp"
35 #include "utilities/align.hpp"
36 #include "utilities/debug.hpp"
37 #include "utilities/globalDefinitions.hpp"
38
39
40 using metaspace::chunklevel_t;
41 using namespace metaspace::chunklevel;
42
43
44 // A range of numerical values.
45 template <typename T, typename Td>
46 class Range : public StackObj {
47
48 // start and size of range
49 T _start;
50 Td _size;
51
52 static Td random_uncapped_offset() {
53 if (sizeof(Td) > 4) {
54 return (Td)((uint64_t)os::random() * os::random());
55 } else {
56 return (Td)os::random();
57 }
58 }
59
60 protected:
61
62 static void swap_if_needed(T& lo, T& hi) {
63 if (lo > hi) {
64 T v = lo;
65 lo = hi;
66 hi = v;
67 }
68 }
69
70 public:
71
72 // Lowest value in range
73 T lowest() const { return _start; }
74
75 // Highest value in range (including)
76 T highest() const { return _start + (_size - 1); }
77
78 T start() const { return _start; }
79 T end() const { return _start + _size; }
80
81 // Number of values in range
82 Td size() const { return _size; }
83
84 bool is_empty() const { return size() == 0; }
85
86 bool contains(T v) const {
87 return v >= _start && v < end();
88 }
89
90 bool contains(Range<T, Td> r) const {
91 return contains(r.lowest()) && contains(r.highest());
92 }
93
94 // Create a range from [start, end)
95 Range(T start, T end) : _start(start), _size(end - start) {
96 assert(end >= start, "start and end reversed");
97 }
98
99 // a range with a given size, starting at 0
100 Range(Td size) : _start(0), _size(size) {}
101
102 // Return a random offset
103 Td random_offset() const {
104 assert(!is_empty(), "Range too small");
105 Td v = random_uncapped_offset() % size();
106 return v;
107 }
108
109 // Return a random value within the range
110 T random_value() const {
111 assert(!is_empty(), "Range too small");
112 T v = _start + random_offset();
113 assert(contains(v), "Sanity");
114 return v;
115 }
116
117 // Return the head of this range up to but excluding <split_point>
118 Range<T, Td> head(Td split_point) const {
119 assert(_size >= split_point, "Sanity");
120 return Range<T, Td>(_start, _start + split_point);
121 }
122
123 // Return the tail of this range, starting at <split_point>
124 Range<T, Td> tail(Td split_point) const {
125 assert(_size > split_point, "Sanity");
126 return Range<T, Td>(_start + split_point, end());
127 }
128
129 // Return a non-empty random sub range.
130 Range<T, Td> random_subrange() const {
131 assert(size() > 1, "Range too small");
132 Td sz = MAX2((Td)1, random_offset());
133 return random_sized_subrange(sz);
134 }
135
136 // Return a subrange of given size at a random start position
137 Range<T, Td> random_sized_subrange(Td subrange_size) const {
138 assert(subrange_size > 0 && subrange_size < _size, "invalid size");
139 T start = head(_size - subrange_size).random_value();
140 return Range<T, Td>(start, start + subrange_size);
141 }
142
143 //// aligned ranges ////
144
145 bool range_is_aligned(Td alignment) const {
146 return is_aligned(_size, alignment) && is_aligned(_start, alignment);
147 }
148
149 // Return a non-empty aligned random sub range.
150 Range<T, Td> random_aligned_subrange(Td alignment) const {
151 assert(alignment > 0, "Sanity");
152 assert(range_is_aligned(alignment), "Outer range needs to be aligned"); // to keep matters simple
153 assert(_size >= alignment, "Outer range too small.");
154 Td sz = MAX2((Td)1, random_offset());
155 sz = align_up(sz, alignment);
156 return random_aligned_sized_subrange(sz, alignment);
157 }
158
159 // Return a subrange of given size at a random aligned start position
160 Range<T, Td> random_aligned_sized_subrange(Td subrange_size, Td alignment) const {
161 assert(alignment > 0, "Sanity");
162 assert(range_is_aligned(alignment), "Outer range needs to be aligned"); // to keep matters simple
163 assert(subrange_size > 0 && subrange_size <= _size &&
164 is_aligned(subrange_size, alignment), "invalid subrange size");
165 if (_size == subrange_size) {
166 return *this;
167 }
168 T start = head(_size - subrange_size).random_value();
169 start = align_down(start, alignment);
170 return Range<T, Td>(start, start + subrange_size);
171 }
172
173 };
174
175 typedef Range<int, int> IntRange;
176 typedef Range<size_t, size_t> SizeRange;
177 typedef Range<chunklevel_t, int> ChunkLevelRange;
178
179 struct ChunkLevelRanges : public AllStatic {
180 static ChunkLevelRange small_chunks() { return ChunkLevelRange(CHUNK_LEVEL_32K, CHUNK_LEVEL_1K + 1); }
181 static ChunkLevelRange medium_chunks() { return ChunkLevelRange(CHUNK_LEVEL_512K, CHUNK_LEVEL_32K + 1); }
182 static ChunkLevelRange large_chunks() { return ChunkLevelRange(CHUNK_LEVEL_4M, CHUNK_LEVEL_512K + 1); }
183 static ChunkLevelRange all_chunks() { return ChunkLevelRange(CHUNK_LEVEL_4M, CHUNK_LEVEL_1K + 1); }
184 };
185
186 #endif // GTEST_METASPACE_METASPACE_RANGEHELPERS_HPP