File: | jdk/src/hotspot/share/utilities/chunkedList.hpp |
Warning: | line 77, column 5 Undefined or garbage value returned to caller |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* | |||
2 | * Copyright (c) 2014, 2016, 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 | ||||
24 | #include "precompiled.hpp" | |||
25 | #include "unittest.hpp" | |||
26 | #include "utilities/chunkedList.hpp" | |||
27 | ||||
28 | class Metadata; | |||
29 | ||||
30 | template <typename T> | |||
31 | class TestChunkedList { | |||
32 | typedef ChunkedList<T, mtOther> ChunkedListT; | |||
33 | ||||
34 | public: | |||
35 | ||||
36 | static void testEmpty() { | |||
37 | ChunkedListT buffer; | |||
38 | ASSERT_EQ((size_t) 0, buffer.size())switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing ::internal::IsNullLiteralHelper((size_t) 0)) == 1)>::Compare ("(size_t) 0", "buffer.size()", (size_t) 0, buffer.size()))) ; else return ::testing::internal::AssertHelper(::testing::TestPartResult ::kFatalFailure, "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 38, gtest_ar.failure_message()) = ::testing::Message(); | |||
39 | } | |||
40 | ||||
41 | static void testFull() { | |||
42 | ChunkedListT buffer; | |||
43 | for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) { | |||
44 | buffer.push((T) i); | |||
45 | } | |||
46 | ASSERT_EQ((size_t) ChunkedListT::BufferSize, buffer.size())switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing ::internal::IsNullLiteralHelper((size_t) ChunkedListT::BufferSize )) == 1)>::Compare("(size_t) ChunkedListT::BufferSize", "buffer.size()" , (size_t) ChunkedListT::BufferSize, buffer.size()))) ; else return ::testing::internal::AssertHelper(::testing::TestPartResult:: kFatalFailure, "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 46, gtest_ar.failure_message()) = ::testing::Message(); | |||
47 | ASSERT_TRUE(buffer.is_full())switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar_ = ::testing::AssertionResult(buffer.is_full())) ; else return ::testing::internal::AssertHelper(::testing::TestPartResult ::kFatalFailure, "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 47, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_ , "buffer.is_full()", "false", "true").c_str()) = ::testing:: Message(); | |||
48 | } | |||
49 | ||||
50 | static void testSize() { | |||
51 | ChunkedListT buffer; | |||
52 | for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) { | |||
53 | ASSERT_EQ((size_t) i, buffer.size())switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing ::internal::IsNullLiteralHelper((size_t) i)) == 1)>::Compare ("(size_t) i", "buffer.size()", (size_t) i, buffer.size()))) ; else return ::testing::internal::AssertHelper(::testing::TestPartResult ::kFatalFailure, "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 53, gtest_ar.failure_message()) = ::testing::Message(); | |||
54 | buffer.push((T) i); | |||
55 | ASSERT_EQ((size_t) (i + 1), buffer.size())switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing ::internal::IsNullLiteralHelper((size_t) (i + 1))) == 1)>:: Compare("(size_t) (i + 1)", "buffer.size()", (size_t) (i + 1) , buffer.size()))) ; else return ::testing::internal::AssertHelper (::testing::TestPartResult::kFatalFailure, "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 55, gtest_ar.failure_message()) = ::testing::Message(); | |||
56 | } | |||
57 | } | |||
58 | ||||
59 | static void testClear() { | |||
60 | ChunkedListT buffer; | |||
61 | ||||
62 | buffer.clear(); | |||
63 | ASSERT_EQ((size_t) 0, buffer.size())switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing ::internal::IsNullLiteralHelper((size_t) 0)) == 1)>::Compare ("(size_t) 0", "buffer.size()", (size_t) 0, buffer.size()))) ; else return ::testing::internal::AssertHelper(::testing::TestPartResult ::kFatalFailure, "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 63, gtest_ar.failure_message()) = ::testing::Message(); | |||
64 | ||||
65 | for (uintptr_t i = 0; i < ChunkedListT::BufferSize / 2; i++) { | |||
66 | buffer.push((T) i); | |||
67 | } | |||
68 | buffer.clear(); | |||
69 | ASSERT_EQ((size_t) 0, buffer.size())switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing ::internal::IsNullLiteralHelper((size_t) 0)) == 1)>::Compare ("(size_t) 0", "buffer.size()", (size_t) 0, buffer.size()))) ; else return ::testing::internal::AssertHelper(::testing::TestPartResult ::kFatalFailure, "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 69, gtest_ar.failure_message()) = ::testing::Message(); | |||
70 | ||||
71 | for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) { | |||
72 | buffer.push((T) i); | |||
73 | } | |||
74 | buffer.clear(); | |||
75 | ASSERT_EQ((size_t) 0, buffer.size())switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing ::internal::IsNullLiteralHelper((size_t) 0)) == 1)>::Compare ("(size_t) 0", "buffer.size()", (size_t) 0, buffer.size()))) ; else return ::testing::internal::AssertHelper(::testing::TestPartResult ::kFatalFailure, "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 75, gtest_ar.failure_message()) = ::testing::Message(); | |||
76 | } | |||
77 | ||||
78 | static void testAt() { | |||
79 | ChunkedListT buffer; | |||
80 | ||||
81 | for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) { | |||
82 | buffer.push((T) i); | |||
83 | ASSERT_EQ((T) i, buffer.at(i))switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing ::internal::IsNullLiteralHelper((T) i)) == 1)>::Compare("(T) i" , "buffer.at(i)", (T) i, buffer.at(i)))) ; else return ::testing ::internal::AssertHelper(::testing::TestPartResult::kFatalFailure , "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 83, gtest_ar.failure_message()) = ::testing::Message(); | |||
84 | } | |||
85 | ||||
86 | for (uintptr_t i = 0; i < ChunkedListT::BufferSize; i++) { | |||
87 | ASSERT_EQ((T) i, buffer.at(i))switch (0) case 0: default: if (const ::testing::AssertionResult gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing ::internal::IsNullLiteralHelper((T) i)) == 1)>::Compare("(T) i" , "buffer.at(i)", (T) i, buffer.at(i)))) ; else return ::testing ::internal::AssertHelper(::testing::TestPartResult::kFatalFailure , "/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 87, gtest_ar.failure_message()) = ::testing::Message(); | |||
88 | } | |||
89 | } | |||
90 | }; | |||
91 | ||||
92 | TEST(ChunkedList, metadata_empty)class ChunkedList_metadata_empty_Test : public ::testing::Test { public: ChunkedList_metadata_empty_Test() {} private: virtual void TestBody(); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_metadata_empty_Test(ChunkedList_metadata_empty_Test const &) = delete; void operator=(ChunkedList_metadata_empty_Test const &) = delete;};::testing::TestInfo* const ChunkedList_metadata_empty_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "metadata_empty", __null, __null, ::testing:: internal::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 92), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_metadata_empty_Test >);void ChunkedList_metadata_empty_Test::TestBody() { | |||
93 | TestChunkedList<Metadata*>::testEmpty(); | |||
94 | } | |||
95 | ||||
96 | TEST(ChunkedList, metadata_full)class ChunkedList_metadata_full_Test : public ::testing::Test { public: ChunkedList_metadata_full_Test() {} private: virtual void TestBody(); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_metadata_full_Test(ChunkedList_metadata_full_Test const &) = delete; void operator=(ChunkedList_metadata_full_Test const &) = delete;};::testing::TestInfo* const ChunkedList_metadata_full_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "metadata_full", __null, __null, ::testing::internal ::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 96), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_metadata_full_Test >);void ChunkedList_metadata_full_Test::TestBody() { | |||
97 | TestChunkedList<Metadata*>::testFull(); | |||
98 | } | |||
99 | ||||
100 | TEST(ChunkedList, metadata_size)class ChunkedList_metadata_size_Test : public ::testing::Test { public: ChunkedList_metadata_size_Test() {} private: virtual void TestBody(); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_metadata_size_Test(ChunkedList_metadata_size_Test const &) = delete; void operator=(ChunkedList_metadata_size_Test const &) = delete;};::testing::TestInfo* const ChunkedList_metadata_size_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "metadata_size", __null, __null, ::testing::internal ::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 100), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_metadata_size_Test >);void ChunkedList_metadata_size_Test::TestBody() { | |||
101 | TestChunkedList<Metadata*>::testSize(); | |||
102 | } | |||
103 | ||||
104 | TEST(ChunkedList, metadata_clear)class ChunkedList_metadata_clear_Test : public ::testing::Test { public: ChunkedList_metadata_clear_Test() {} private: virtual void TestBody(); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_metadata_clear_Test(ChunkedList_metadata_clear_Test const &) = delete; void operator=(ChunkedList_metadata_clear_Test const &) = delete;};::testing::TestInfo* const ChunkedList_metadata_clear_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "metadata_clear", __null, __null, ::testing:: internal::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 104), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_metadata_clear_Test >);void ChunkedList_metadata_clear_Test::TestBody() { | |||
105 | TestChunkedList<Metadata*>::testSize(); | |||
106 | } | |||
107 | ||||
108 | TEST(ChunkedList, metadata_at)class ChunkedList_metadata_at_Test : public ::testing::Test { public: ChunkedList_metadata_at_Test() {} private: virtual void TestBody(); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_metadata_at_Test(ChunkedList_metadata_at_Test const &) = delete; void operator=(ChunkedList_metadata_at_Test const &) = delete;};::testing::TestInfo* const ChunkedList_metadata_at_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "metadata_at", __null, __null, ::testing::internal ::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 108), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_metadata_at_Test> );void ChunkedList_metadata_at_Test::TestBody() { | |||
109 | TestChunkedList<Metadata*>::testAt(); | |||
110 | } | |||
111 | ||||
112 | TEST(ChunkedList, size_t_empty)class ChunkedList_size_t_empty_Test : public ::testing::Test { public: ChunkedList_size_t_empty_Test() {} private: virtual void TestBody(); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_size_t_empty_Test(ChunkedList_size_t_empty_Test const &) = delete; void operator=(ChunkedList_size_t_empty_Test const &) = delete;};::testing::TestInfo* const ChunkedList_size_t_empty_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "size_t_empty", __null, __null, ::testing::internal ::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 112), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_size_t_empty_Test >);void ChunkedList_size_t_empty_Test::TestBody() { | |||
113 | TestChunkedList<size_t>::testEmpty(); | |||
114 | } | |||
115 | ||||
116 | TEST(ChunkedList, size_t_full)class ChunkedList_size_t_full_Test : public ::testing::Test { public: ChunkedList_size_t_full_Test() {} private: virtual void TestBody(); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_size_t_full_Test(ChunkedList_size_t_full_Test const &) = delete; void operator=(ChunkedList_size_t_full_Test const &) = delete;};::testing::TestInfo* const ChunkedList_size_t_full_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "size_t_full", __null, __null, ::testing::internal ::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 116), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_size_t_full_Test> );void ChunkedList_size_t_full_Test::TestBody() { | |||
117 | TestChunkedList<size_t>::testFull(); | |||
118 | } | |||
119 | ||||
120 | TEST(ChunkedList, size_t_size)class ChunkedList_size_t_size_Test : public ::testing::Test { public: ChunkedList_size_t_size_Test() {} private: virtual void TestBody(); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_size_t_size_Test(ChunkedList_size_t_size_Test const &) = delete; void operator=(ChunkedList_size_t_size_Test const &) = delete;};::testing::TestInfo* const ChunkedList_size_t_size_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "size_t_size", __null, __null, ::testing::internal ::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 120), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_size_t_size_Test> );void ChunkedList_size_t_size_Test::TestBody() { | |||
121 | TestChunkedList<size_t>::testSize(); | |||
122 | } | |||
123 | ||||
124 | TEST(ChunkedList, size_t_clear)class ChunkedList_size_t_clear_Test : public ::testing::Test { public: ChunkedList_size_t_clear_Test() {} private: virtual void TestBody(); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_size_t_clear_Test(ChunkedList_size_t_clear_Test const &) = delete; void operator=(ChunkedList_size_t_clear_Test const &) = delete;};::testing::TestInfo* const ChunkedList_size_t_clear_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "size_t_clear", __null, __null, ::testing::internal ::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 124), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_size_t_clear_Test >);void ChunkedList_size_t_clear_Test::TestBody() { | |||
125 | TestChunkedList<size_t>::testSize(); | |||
126 | } | |||
127 | ||||
128 | TEST(ChunkedList, size_t_at)class ChunkedList_size_t_at_Test : public ::testing::Test { public : ChunkedList_size_t_at_Test() {} private: virtual void TestBody (); static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); ChunkedList_size_t_at_Test(ChunkedList_size_t_at_Test const &) = delete; void operator=(ChunkedList_size_t_at_Test const &) = delete;};::testing::TestInfo* const ChunkedList_size_t_at_Test ::test_info_ = ::testing::internal::MakeAndRegisterTestInfo( "ChunkedList", "size_t_at", __null, __null, ::testing::internal ::CodeLocation("/home/daniel/Projects/java/jdk/test/hotspot/gtest/utilities/test_chunkedList.cpp" , 128), (::testing::internal::GetTestTypeId()), ::testing::Test ::SetUpTestCase, ::testing::Test::TearDownTestCase, new ::testing ::internal::TestFactoryImpl< ChunkedList_size_t_at_Test> );void ChunkedList_size_t_at_Test::TestBody() { | |||
129 | TestChunkedList<size_t>::testAt(); | |||
| ||||
130 | } |
1 | /* | |||
2 | * Copyright (c) 2014, 2019, 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 | */ | |||
24 | ||||
25 | #ifndef SHARE_UTILITIES_CHUNKEDLIST_HPP | |||
26 | #define SHARE_UTILITIES_CHUNKEDLIST_HPP | |||
27 | ||||
28 | #include "memory/allocation.hpp" | |||
29 | #include "utilities/debug.hpp" | |||
30 | ||||
31 | template <class T, MEMFLAGS F> class ChunkedList : public CHeapObj<F> { | |||
32 | template <class U> friend class TestChunkedList; | |||
33 | ||||
34 | static const size_t BufferSize = 64; | |||
35 | ||||
36 | T _values[BufferSize]; | |||
37 | T* _top; | |||
38 | ||||
39 | ChunkedList<T, F>* _next_used; | |||
40 | ChunkedList<T, F>* _next_free; | |||
41 | ||||
42 | T const * end() const { | |||
43 | return &_values[BufferSize]; | |||
44 | } | |||
45 | ||||
46 | public: | |||
47 | ChunkedList<T, F>() : _top(_values), _next_used(NULL__null), _next_free(NULL__null) {} | |||
48 | ||||
49 | bool is_full() const { | |||
50 | return _top == end(); | |||
51 | } | |||
52 | ||||
53 | void clear() { | |||
54 | _top = _values; | |||
55 | // Don't clear the next pointers since that would interfere | |||
56 | // with other threads trying to iterate through the lists. | |||
57 | } | |||
58 | ||||
59 | void push(T m) { | |||
60 | assert(!is_full(), "Buffer is full")do { if (!(!is_full())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/chunkedList.hpp" , 60, "assert(" "!is_full()" ") failed", "Buffer is full"); :: breakpoint(); } } while (0); | |||
61 | *_top = m; | |||
62 | _top++; | |||
63 | } | |||
64 | ||||
65 | void set_next_used(ChunkedList<T, F>* buffer) { _next_used = buffer; } | |||
66 | void set_next_free(ChunkedList<T, F>* buffer) { _next_free = buffer; } | |||
67 | ||||
68 | ChunkedList<T, F>* next_used() const { return _next_used; } | |||
69 | ChunkedList<T, F>* next_free() const { return _next_free; } | |||
70 | ||||
71 | size_t size() const { | |||
72 | return pointer_delta(_top, _values, sizeof(T)); | |||
73 | } | |||
74 | ||||
75 | T at(size_t i) { | |||
76 | assert(i < size(), "IOOBE i: " SIZE_FORMAT " size(): " SIZE_FORMAT, i, size())do { if (!(i < size())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/chunkedList.hpp" , 76, "assert(" "i < size()" ") failed", "IOOBE i: " "%" "l" "u" " size(): " "%" "l" "u", i, size()); ::breakpoint(); } } while (0); | |||
77 | return _values[i]; | |||
| ||||
78 | } | |||
79 | }; | |||
80 | ||||
81 | #endif // SHARE_UTILITIES_CHUNKEDLIST_HPP |