archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-19 10:34:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8178499: Remove _ptr_ and _size_ infixes from align functions

Browse source 
Reviewed-by: rehn, tschatzl
This commit is contained in:
Stefan Karlsson 2017-07-04 15:58:10 +02:00
parent 0fcf645cff
commit dbd3b5a79e
115 changed files with 454 additions and 462 deletions
Download patch file Download diff file Expand all files Collapse all files

8
hotspot/test/native/gc/shared/test_collectorPolicy.cpp
View file

@ -161,7 +161,7 @@ class TestGenCollectorPolicy {
SetMaxNewSizeCmd(size_t param1, size_t param2) : BinaryExecutor(param1, param2) { }
void execute() {
size_t heap_alignment = CollectorPolicy::compute_heap_alignment();
size_t new_size_value = align_size_up(MaxHeapSize, heap_alignment)
size_t new_size_value = align_up(MaxHeapSize, heap_alignment)
- param1 + param2;
FLAG_SET_CMDLINE(size_t, MaxNewSize, new_size_value);
}
@ -185,7 +185,7 @@ class TestGenCollectorPolicy {
MarkSweepPolicy msp;
msp.initialize_all();
size_t expected_old_initial = align_size_up(InitialHeapSize, heap_alignment)
size_t expected_old_initial = align_up(InitialHeapSize, heap_alignment)
- MaxNewSize;
ASSERT_EQ(expected_old_initial, msp.initial_old_size());
@ -197,13 +197,13 @@ class TestGenCollectorPolicy {
CheckOldInitialMaxNewSize(size_t param1, size_t param2) : BinaryExecutor(param1, param2) { }
void execute() {
size_t heap_alignment = CollectorPolicy::compute_heap_alignment();
size_t new_size_value = align_size_up(MaxHeapSize, heap_alignment)
size_t new_size_value = align_up(MaxHeapSize, heap_alignment)
- param1 + param2;
MarkSweepPolicy msp;
msp.initialize_all();
size_t expected_old_initial = align_size_up(MaxHeapSize, heap_alignment)
size_t expected_old_initial = align_up(MaxHeapSize, heap_alignment)
- new_size_value;
ASSERT_EQ(expected_old_initial, msp.initial_old_size());

2
hotspot/test/native/memory/test_metachunk.cpp
View file

@ -64,7 +64,7 @@ TEST(Metachunk, basic) {
// Allocate
size_t alloc_size = 64; // Words
EXPECT_TRUE(is_size_aligned(alloc_size, Metachunk::object_alignment()));
EXPECT_TRUE(is_aligned(alloc_size, Metachunk::object_alignment()));
MetaWord* mem = metachunk->allocate(alloc_size);

6
hotspot/test/native/runtime/test_arguments.cpp
View file

@ -152,7 +152,7 @@ static intx calc_expected(julong small_xss_input) {
assert(small_xss_input <= max_julong / 2, "Sanity");
// Match code in arguments.cpp
julong julong_ret = align_size_up_(small_xss_input, K) / K;
julong julong_ret = align_up_(small_xss_input, K) / K;
assert(julong_ret <= (julong)max_intx, "Overflow: " JULONG_FORMAT, julong_ret);
return (intx)julong_ret;
}
@ -186,8 +186,8 @@ TEST_VM_F(ArgumentsTest, parse_xss) {
// Test value aligned both to K and vm_page_size.
{
EXPECT_TRUE(is_size_aligned(32 * M, K));
EXPECT_TRUE(is_size_aligned(32 * M, (size_t)os::vm_page_size()));
EXPECT_TRUE(is_aligned(32 * M, K));
EXPECT_TRUE(is_aligned(32 * M, (size_t)os::vm_page_size()));
EXPECT_EQ(parse_xss_inner(to_string(32 * M), JNI_OK), (intx)(32 * M / K));
}

24
hotspot/test/native/utilities/test_align.cpp
View file

@ -53,46 +53,46 @@ static void test_alignments() {
log("--- Value: " UINT64_FORMAT "\n", values[i]);
// Test align up
const uint64_t up = align_size_up_(values[i], (uint64_t)alignment);
const uint64_t up = align_up_(values[i], (uint64_t)alignment);
if (0 < up && up <= (uint64_t)std::numeric_limits<T>::max()) {
log("Testing align_up: alignment: 0x" UINT64_FORMAT_X " value: 0x" UINT64_FORMAT_X " expected: 0x" UINT64_FORMAT_X "\n", (uint64_t)alignment, values[i], up);
T value = T(values[i]);
// Check against uint64_t version
ASSERT_EQ(align_size_up((uint64_t)value, alignment), up);
ASSERT_EQ(align_up((uint64_t)value, alignment), up);
// Check inline function vs macro
ASSERT_EQ(align_size_up(value, alignment), align_size_up_(value, alignment));
ASSERT_EQ(align_up(value, alignment), align_up_(value, alignment));
// Sanity check
ASSERT_GE(align_size_up(value, alignment), value);
ASSERT_GE(align_up(value, alignment), value);
}
// Test align down
const uint64_t down = align_size_down_(values[i], (uint64_t)alignment);
const uint64_t down = align_down_(values[i], (uint64_t)alignment);
if (down <= (uint64_t)std::numeric_limits<T>::max()) {
log("Testing align_size_down: alignment: 0x" UINT64_FORMAT_X " value: 0x" UINT64_FORMAT_X " expected: 0x" UINT64_FORMAT_X "\n", (uint64_t)alignment, values[i], down);
log("Testing align_down: alignment: 0x" UINT64_FORMAT_X " value: 0x" UINT64_FORMAT_X " expected: 0x" UINT64_FORMAT_X "\n", (uint64_t)alignment, values[i], down);
T value = T(values[i]);
// Check against uint64_t version
ASSERT_EQ((uint64_t)align_size_down(value, alignment), down);
ASSERT_EQ((uint64_t)align_down(value, alignment), down);
// Check inline function vs macro
ASSERT_EQ(align_size_down(value, alignment), align_size_down_(value, alignment));
ASSERT_EQ(align_down(value, alignment), align_down_(value, alignment));
// Sanity check
ASSERT_LE(align_size_down(value, alignment), value);
ASSERT_LE(align_down(value, alignment), value);
}
// Test is aligned
const bool is = is_size_aligned_(values[i], (uint64_t)alignment);
const bool is = is_aligned_(values[i], (uint64_t)alignment);
if (values[i] <= (uint64_t)std::numeric_limits<T>::max()) {
log("Testing is_aligned: alignment: 0x" UINT64_FORMAT_X " value: 0x" UINT64_FORMAT_X " expected: %s\n", (uint64_t)alignment, values[i], is ? "true" : "false");
T value = T(values[i]);
// Check against uint64_t version
ASSERT_EQ(is_size_aligned(value, alignment), is);
ASSERT_EQ(is_aligned(value, alignment), is);
// Check inline function vs macro
ASSERT_EQ(is_size_aligned(value, alignment), is_size_aligned_(value, alignment));
ASSERT_EQ(is_aligned(value, alignment), is_aligned_(value, alignment));
}
}
}