Kea 2.0.0
generic_lease_mgr_benchmark.cc
Go to the documentation of this file.
1// Copyright (C) 2018-2019 Internet Systems Consortium, Inc. ("ISC")
2// Copyright (C) 2017 Deutsche Telekom AG.
3//
4// Authors: Andrei Pavel <andrei.pavel@qualitance.com>
5//
6// Licensed under the Apache License, Version 2.0 (the "License");
7// you may not use this file except in compliance with the License.
8// You may obtain a copy of the License at
9//
10// http://www.apache.org/licenses/LICENSE-2.0
11//
12// Unless required by applicable law or agreed to in writing, software
13// distributed under the License is distributed on an "AS IS" BASIS,
14// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15// See the License for the specific language governing permissions and
16// limitations under the License.
17
18#include <config.h>
19
22
23#include <chrono>
24#include <iomanip>
25#include <iostream>
26#include <string>
27#include <vector>
28
29using namespace isc::asiolink;
30using namespace std;
31using namespace std::chrono;
32
33namespace isc {
34namespace dhcp {
35namespace bench {
36
38}
39
41}
42
43void
44GenericLeaseMgrBenchmark::setUp4(::benchmark::State& state, size_t const& lease_count) {
45 state.PauseTiming();
46 SetUp(state);
47 prepareLeases4(lease_count);
48 state.ResumeTiming();
49}
50
51void
53 size_t const& lease_count) {
54 state.PauseTiming();
55 SetUp(state);
56 prepareLeases4(lease_count);
58 state.ResumeTiming();
59}
60
61void
62GenericLeaseMgrBenchmark::setUp6(::benchmark::State& state, size_t const& lease_count) {
63 state.PauseTiming();
64 SetUp(state);
65 prepareLeases6(lease_count);
66 state.ResumeTiming();
67}
68
69void
71 size_t const& lease_count) {
72 state.PauseTiming();
73 SetUp(state);
74 prepareLeases6(lease_count);
76 state.ResumeTiming();
77}
78
79void
80GenericLeaseMgrBenchmark::prepareLeases4(size_t const& lease_count) {
81 leases4_.clear();
82 for (size_t i = 0x0001u; i < 0x0001u + lease_count; ++i) {
83 Lease4Ptr lease(new Lease4());
84 lease->addr_ = IOAddress(i);
85 lease->hwaddr_.reset(new HWAddr(vector<uint8_t>(6, i), HTYPE_ETHER));
86 lease->client_id_ = ClientIdPtr(new ClientId(vector<uint8_t>(8, 2 * i)));
87 lease->valid_lft_ = i;
88 lease->cltt_ = i;
89 lease->subnet_id_ = i;
90 lease->fqdn_rev_ = (i % 2) ? true : false;
91 lease->fqdn_fwd_ = (i % 2) ? true : false;
92 lease->hostname_ = to_string(i) + ".host.com";
93 leases4_.push_back(lease);
94 }
95}
96
97void
99 for (Lease4Ptr const& lease : leases4_) {
100 lmptr_->addLease(lease);
101 }
102}
103
104void
106 for (Lease4Ptr const& lease : leases4_) {
107 lmptr_->updateLease4(lease);
108 }
109}
110
111void
113 for (Lease4Ptr const& lease : leases4_) {
114 lmptr_->getLease4(lease->addr_);
115 }
116}
117
118void
120 for (Lease4Ptr const& lease : leases4_) {
121 const Lease4Collection collection = lmptr_->getLease4(*lease->hwaddr_);
122 }
123}
124
125void
127 for (Lease4Ptr const& lease : leases4_) {
128 lmptr_->getLease4(*lease->hwaddr_, lease->subnet_id_);
129 }
130}
131
132void
134 for (Lease4Ptr const& lease : leases4_) {
135 lmptr_->getLease4(*lease->client_id_);
136 }
137}
138
139void
141 for (Lease4Ptr const& lease : leases4_) {
142 lmptr_->getLease4(*lease->client_id_, lease->subnet_id_);
143 }
144}
145
146void
148 Lease4Collection expired_leases;
149 lmptr_->getExpiredLeases4(expired_leases, leases4_.size());
150}
151
152void
154 if (lease_count > 0xfffdu) {
155 cerr << "lease_count <= 0xfffd or change address generation in "
156 "GenericLeaseMgrBenchmark::prepareLeases6()"
157 << endl;
158 }
159 leases6_.clear();
160 for (size_t i = 0x0001u; i < 0x0001u + lease_count; ++i) {
161 stringstream ss;
162 string n_lease;
163 ss << std::hex << i;
164 ss >> n_lease;
165 const string prefix = string("2001:db8::") + n_lease;
166 Lease6Ptr lease(new Lease6());
167 lease->addr_ = IOAddress(prefix);
168 lease->type_ = static_cast<Lease::Type>(i % 3); // NA, TA or PD
169 lease->prefixlen_ = i % 128;
170 lease->iaid_ = i;
171 lease->duid_ = DuidPtr(new DUID(vector<uint8_t>(8, i)));
172 lease->preferred_lft_ = i;
173 lease->valid_lft_ = i;
174 lease->cltt_ = i;
175 lease->subnet_id_ = i;
176 lease->fqdn_fwd_ = (i % 2 == 0) ? true : false;
177 lease->fqdn_rev_ = (i % 2 == 0) ? true : false;
178 lease->hostname_ = n_lease + ".host.com";
179 leases6_.push_back(lease);
180 }
181}
182
183void
185 for (Lease6Ptr const& lease : leases6_) {
186 lmptr_->addLease(lease);
187 }
188}
189
190void
192 for (Lease6Ptr const& lease : leases6_) {
193 lmptr_->updateLease6(lease);
194 }
195}
196
197void
199 for (Lease6Ptr const& lease : leases6_) {
200 lmptr_->getLease6(lease->type_, lease->addr_);
201 }
202}
203
204void
206 for (Lease6Ptr const& lease : leases6_) {
207 lmptr_->getLeases6(lease->type_, *lease->duid_, lease->iaid_);
208 }
209}
210
211void
213 for (Lease6Ptr const& lease : leases6_) {
214 lmptr_->getLease6(lease->type_, *lease->duid_, lease->iaid_,
215 lease->subnet_id_);
216 }
217}
218
219void
221 Lease6Collection expired_leases;
222 lmptr_->getExpiredLeases6(expired_leases, leases6_.size());
223}
224
229
230} // namespace bench
231} // namespace dhcp
232} // namespace isc
Holds Client identifier or client IPv4 address.
Definition: duid.h:111
Holds DUID (DHCPv6 Unique Identifier)
Definition: duid.h:27
virtual Lease6Collection getLeases6(Lease::Type type, const DUID &duid, uint32_t iaid) const =0
Returns existing IPv6 leases for a given DUID+IA combination.
virtual void getExpiredLeases6(Lease6Collection &expired_leases, const size_t max_leases) const =0
Returns a collection of expired DHCPv6 leases.
virtual Lease4Ptr getLease4(const isc::asiolink::IOAddress &addr) const =0
Returns an IPv4 lease for specified IPv4 address.
virtual bool addLease(const Lease4Ptr &lease)=0
Adds an IPv4 lease.
virtual void getExpiredLeases4(Lease4Collection &expired_leases, const size_t max_leases) const =0
Returns a collection of expired DHCPv4 leases.
virtual void updateLease4(const Lease4Ptr &lease4)=0
Updates IPv4 lease.
virtual Lease6Ptr getLease6(Lease::Type type, const isc::asiolink::IOAddress &addr) const =0
Returns existing IPv6 lease for a given IPv6 address.
virtual void updateLease6(const Lease6Ptr &lease6)=0
Updates IPv6 lease.
void benchInsertLeases4()
This step inserts all IPv4 leases stored in lease4_ into the LeaseMgr.
void benchGetLease4_clientid_subnetid()
This step retrieves IPv4 leases by (client-id, subnet-id) tuple.
void prepareLeases4(size_t const &lease_count)
Prepares specified number of IPv4 leases.
Lease6Collection leases6_
List of IPv6 leases (useful during benchmarks)
void benchUpdateLeases4()
This step updates all IPv4 leases stored in lease4_ in the LeaseMgr.
LeaseMgr * lmptr_
Pointer to the lease manager being under evaluation.
void benchUpdateLeases6()
This step updates all IPv6 leases stored in lease6_ in the LeaseMgr.
void benchGetLease4_hwaddr()
This step retrieves IPv4 leases by hardware address.
void benchGetLease6_type_duid_iaid_subnetid()
This step retrieves IPv6 leases by (type, duid, iaid, subnet-id) tuple.
void setUpWithInserts6(::benchmark::State &state, size_t const &lease_count)
set up code (with lease preinsertion) for initializing IPv6 version of a benchmark.
void benchGetLease4_address()
This step retrieves IPv4 leases by IP address.
void benchGetExpiredLeases6()
This step retrieves all expired IPv6 leases.
void benchGetLease4_clientid()
This step retrieves IPv4 leases by client-id.
void benchGetLease6_type_duid_iaid()
This step retrieves IPv6 leases by (type, duid, iaid) tuple.
void setUpWithInserts4(::benchmark::State &state, size_t const &lease_count)
set up code (with lease preinsertion) for initializing IPv4 version of a benchmark.
Lease4Collection leases4_
List of IPv4 leases (useful during benchmarks)
void benchGetExpiredLeases4()
This step retrieves all expired IPv4 leases.
void benchGetLease6_type_address()
This step retrieves IPv6 leases by IP address.
void setUp6(::benchmark::State &state, size_t const &lease_count)
set up code for initializing IPv6 version of a benchmark
void benchGetLease4_hwaddr_subnetid()
This step retrieves IPv4 leases by (hwaddr, subnet-id) tuple.
void prepareLeases6(size_t const &lease_count)
Prepares specified number of IPv6 leases.
void setUp4(::benchmark::State &state, size_t const &lease_count)
set up code for initializing IPv4 version of a benchmark
void benchInsertLeases6()
This step inserts all IPv6 leases stored in lease6_ into the LeaseMgr.
boost::shared_ptr< DUID > DuidPtr
Definition: duid.h:20
boost::shared_ptr< Lease6 > Lease6Ptr
Pointer to a Lease6 structure.
Definition: lease.h:492
std::vector< Lease6Ptr > Lease6Collection
A collection of IPv6 leases.
Definition: lease.h:640
boost::shared_ptr< ClientId > ClientIdPtr
Shared pointer to a Client ID.
Definition: duid.h:103
std::vector< Lease4Ptr > Lease4Collection
A collection of IPv4 leases.
Definition: lease.h:487
@ HTYPE_ETHER
Ethernet 10Mbps.
Definition: dhcp4.h:56
boost::shared_ptr< Lease4 > Lease4Ptr
Pointer to a Lease4 structure.
Definition: lease.h:283
Defines the logger used by the top-level component of kea-lfc.
Hardware type that represents information from DHCPv4 packet.
Definition: hwaddr.h:20
Structure that holds a lease for IPv4 address.
Definition: lease.h:294
Structure that holds a lease for IPv6 address and/or prefix.
Definition: lease.h:503
Type
Type of lease or pool.
Definition: lease.h:50