1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
/*
* Copyright (c) 2021 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <glog/logging.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <hicn/transport/core/content_object.h>
#include <hicn/transport/core/interest.h>
#define ALLOCATION_CHECKS
#include <hicn/transport/core/global_object_pool.h>
#undef ALLOCATION_CHECKS
#include <hicn/transport/utils/event_thread.h>
namespace transport {
namespace core {
class PacketAllocatorTest : public ::testing::Test {
protected:
static inline const std::size_t default_size = 2048;
static inline const std::size_t default_n_buffer = 1024;
// Get fixed block allocator_ of 1024 buffers of size 2048 bytes
PacketAllocatorTest() : allocator_(PacketManager<>::getInstance()) {
// You can do set-up work for each test here.
}
virtual ~PacketAllocatorTest() {
// You can do clean-up work that doesn't throw exceptions here.
}
// If the constructor and destructor are not enough for setting up
// and cleaning up each test, you can define the following methods:
virtual void SetUp() {}
virtual void TearDown() {}
static bool pointerIsAligned(const void *pointer, size_t byte_count) {
return uintptr_t(pointer) % byte_count == 0;
}
template <typename T, typename... Args>
void allocationTest(Args &&...args) {
// Create packet
auto packet = allocator_.getPacket<T>(std::forward<Args>(args)...);
// Check boundaries
LOG(INFO) << "packet size: " << sizeof(*packet) + sizeof(packet)
<< std::endl;
EXPECT_LE(sizeof(*packet) + sizeof(packet) + sizeof(std::max_align_t),
sizeof(PacketManager<>::PacketStorage::packet_and_shared_ptr));
}
PacketManager<> &allocator_;
};
TEST_F(PacketAllocatorTest, ContentObjectAllocation) {
allocationTest<core::ContentObject>(HF_INET_TCP);
}
TEST_F(PacketAllocatorTest, InterestAllocation) {
allocationTest<core::Interest>(HF_INET_TCP);
}
// TEST_F(PacketAllocatorTest, MemBufAllocation) {
// allocationTest<::utils::MemBuf>();
// }
TEST_F(PacketAllocatorTest, CheckAllocationIsCorrect) {
// Create packet
auto packet = allocator_.getPacket<core::ContentObject>(HF_INET_TCP);
// Address of actual buffer
uint8_t *buffer_address = packet->writableData();
// Address of packet
uint8_t *packet_address = reinterpret_cast<uint8_t *>(packet.get());
uint8_t *start_address =
buffer_address -
sizeof(PacketManager<>::PacketStorage::packet_and_shared_ptr);
// Check memory was allocated on correct positions
EXPECT_TRUE(pointerIsAligned(start_address, alignof(std::max_align_t)));
EXPECT_TRUE(packet_address > start_address &&
packet_address < buffer_address);
EXPECT_TRUE(pointerIsAligned(buffer_address, alignof(std::max_align_t)));
EXPECT_THAT(std::size_t(buffer_address - start_address),
testing::Eq(sizeof(
PacketManager<>::PacketStorage::packet_and_shared_ptr)));
}
} // namespace core
} // namespace transport
|
