File: replication_bandwidth_limiter.cc

package info (click to toggle)
lizardfs 3.12.0+dfsg-3
  • links: PTS, VCS
  • area: main
  • in suites: buster, sid
  • size: 8,064 kB
  • sloc: cpp: 91,899; sh: 9,341; python: 3,878; ansic: 3,109; pascal: 128; makefile: 57
file content (67 lines) | stat: -rw-r--r-- 2,316 bytes parent folder | download | duplicates (5)
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
/*
   Copyright 2013-2015 Skytechnology sp. z o.o.

   This file is part of LizardFS.

   LizardFS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, version 3.

   LizardFS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with LizardFS. If not, see <http://www.gnu.org/licenses/>.
 */

#include "common/platform.h"
#include "chunkserver/replication_bandwidth_limiter.h"

using namespace ioLimiting;

std::mutex ReplicationBandwidthLimiter::mutex_;

// I/O limit group storing the replication limit.
// Group is needed just for technical purpose: IoLimiting mechanism operates on groups
// (since it can support multiple ones), but here we need just a single one.
constexpr const char* kReplicationGroupId = "replication";

ReplicationBandwidthLimiter::ReplicationBandwidthLimiter()
		: state_(limiter_, std::chrono::milliseconds(20)) {}

void ReplicationBandwidthLimiter::setLimit(uint64_t limit_kBps) {
	limiter_.setLimit(limit_kBps);
	if (group_) {
		return;
	}
	group_.reset(new Group(state_, kReplicationGroupId, clock_));
}

void ReplicationBandwidthLimiter::unsetLimit() {
	group_.reset();
	limiter_.unsetLimit();
}

uint8_t ReplicationBandwidthLimiter::wait(uint64_t requestedSize, const SteadyDuration timeout) {
	if (!group_) {
		// No limit set, request is instantly accepted
		return LIZARDFS_STATUS_OK;
	}
	std::unique_lock<std::mutex> lock(mutex_);
	return group_->wait(requestedSize, SteadyClock::now() + timeout, lock);
}

uint64_t ReplicationBandwidthLimiter::ReplicationLimiter::request(
		const IoLimitGroupId& groupId, uint64_t size) {
	return database_.request(SteadyClock::now(), groupId, size);
}

void ReplicationBandwidthLimiter::ReplicationLimiter::setLimit(uint64_t limit_kBps) {
	database_.setLimits(SteadyClock::now(), {{kReplicationGroupId, limit_kBps}}, 200);
}

void ReplicationBandwidthLimiter::ReplicationLimiter::unsetLimit() {
	database_.setLimits(SteadyClock::now(), IoLimitsConfigLoader::LimitsMap{}, 200);
}