def test_remove_two_servers_while_request_in_progress():
sim = SimulatorKernel(outputDirectory = None)
server1 = MockServer(sim, latency = 10)
server2 = MockServer(sim, latency = 10)
server3 = MockServer(sim, latency = 10)
lb = LoadBalancer(sim)
lb.algorithm = 'SQF'
lb.addBackend(server1)
lb.addBackend(server2)
lb.addBackend(server3)
onShutdownCompleted = Mock()
r1 = Request()
r1.onCompleted = Mock()
r2 = Request()
r2.onCompleted = Mock()
r3 = Request()
r3.onCompleted = Mock()
sim.add(0, lambda: lb.request(r1))
sim.add(0, lambda: lb.request(r2))
sim.add(0, lambda: lb.request(r3))
sim.add(1, lambda: lb.removeBackend(server1, onShutdownCompleted))
sim.add(2, lambda: lb.removeBackend(server2, onShutdownCompleted))
sim.run()
r1.onCompleted.assert_called_once_with()
r2.onCompleted.assert_called_once_with()
r3.onCompleted.assert_called_once_with()
assert onShutdownCompleted.call_count == 2
assert server1.numSeenRequests == 1
assert server2.numSeenRequests == 1
assert server3.numSeenRequests == 1
def test_with_controller_always_yes():
completedRequests = []
controller = Mock()
controller.withOptional.return_value = True, 1
sim = SimulatorKernel(outputDirectory = None)
server = Server(sim,
serviceTimeY = 10, serviceTimeYVariance = 0,
serviceTimeN = 1, serviceTimeNVariance = 0)
server.controller = controller
r = Request()
r.onCompleted = lambda: completedRequests.append(r)
sim.add(0, lambda: server.request(r))
r2 = Request()
r2.onCompleted = lambda: completedRequests.append(r2)
sim.add(0, lambda: server.request(r2))
sim.run()
controller.withOptional.assert_called_with()
assert set(completedRequests) == set([ r, r2 ])
assert abs(server.getActiveTime() - 20.0) < eps, server.getActiveTime()
def test_remove_while_request_not_in_progress():
sim = SimulatorKernel(outputDirectory = None)
server1 = MockServer(sim, latency = 0.1)
server2 = MockServer(sim, latency = 0.1)
lb = LoadBalancer(sim)
lb.addBackend(server1)
lb.addBackend(server2)
onShutdownCompleted = Mock()
def remove_active_server():
if server1.numSeenRequests:
lb.removeBackend(server1, onShutdownCompleted)
else:
lb.removeBackend(server2, onShutdownCompleted)
r1 = Request()
r1.onCompleted = Mock()
sim.add(0, lambda: lb.request(r1))
sim.add(1, lambda: remove_active_server())
sim.add(1, lambda: lb.request(Request()))
sim.add(2, lambda: lb.request(Request()))
sim.add(2, lambda: lb.request(Request()))
sim.run()
r1.onCompleted.assert_called_once_with()
onShutdownCompleted.assert_called_once_with()
assert server1.numSeenRequests == 1 or server2.numSeenRequests == 1
assert server1.numSeenRequests == 3 or server2.numSeenRequests == 3
def request(self, request):
newRequest = Request()
newRequest.originalRequest = request
newRequest.onCompleted = lambda: self.onCompleted(newRequest)
self.loadBalancer.request(newRequest)
action = self.controller.onRequest(newRequest)
self.scaleBy(action)
def test_without_controller():
completedRequests = []
sim = SimulatorKernel(outputDirectory = None)
server = Server(sim, serviceTimeY = 1, serviceTimeYVariance = 0)
r = Request()
r.onCompleted = lambda: completedRequests.append(r)
sim.add(0, lambda: server.request(r))
r2 = Request()
r2.onCompleted = lambda: completedRequests.append(r2)
sim.add(0, lambda: server.request(r2))
sim.run()
assert set(completedRequests) == set([ r, r2 ])
assert server.getActiveTime() == 2.0, server.getActiveTime()
def request(self, request):
#self.sim.log(self, "Got request {0}", request)
request.arrival = self.sim.now
if self.algorithm in [
'weighted-RR', 'theta-diff', 'theta-diff-plus', 'equal-thetas',
'ctl-simplify'
]:
chosenBackendIndex = \
weightedChoice(zip(range(0, len(self.backends)), self.weights), self.random)
elif self.algorithm == 'equal-thetas-SQF' or self.algorithm == 'equal-thetas-fast' or self.algorithm == 'equal-thetas-fast-mul':
# Update controller in the -fast version
if self.algorithm == 'equal-thetas-fast' or self.algorithm == 'equal-thetas-fast-mul':
dt = self.sim.now - self.lastDecision
if dt > 1: dt = 1
for i in range(0, len(self.backends)):
# Gain
gamma = self.equal_thetas_fast_gain * dt
# Calculate the negative deviation from the average
e = self.lastThetas[i] - avg(self.lastThetas)
# Integrate the negative deviation from the average
self.queueOffsets[
i] += gamma * e # + Kp * (e - self.lastThetaErrors[i])
self.lastThetaErrors[i] = e
self.lastDecision = self.sim.now
# To prevent starvation, choose a random empty server..
empty_servers = [i for i in range(0, len(self.queueLengths)) \
if self.queueLengths[i] == 0]
if empty_servers:
chosenBackendIndex = self.random.choice(empty_servers)
else:
if self.algorithm == 'equal-thetas-fast-mul':
# ...or choose replica with shortest (queue * 2 ** queueOffset)
chosenBackendIndex = \
min(range(0, len(self.queueLengths)), \
key = lambda i: self.queueLengths[i] * (2 ** (-self.queueOffsets[i])))
else:
# ...or choose replica with shortest (queue + queueOffset)
chosenBackendIndex = \
min(range(0, len(self.queueLengths)), \
key = lambda i: self.queueLengths[i]-self.queueOffsets[i])
elif self.algorithm == 'theta-diff-plus-SQF':
# choose replica with shortest (queue + queueOffset)
chosenBackendIndex = \
min(range(0, len(self.queueLengths)), \
key = lambda i: self.queueLengths[i]-self.queueOffsets[i])
pass
elif self.algorithm == 'random':
# round robin
chosenBackendIndex = \
self.random.choice(range(0, len(self.backends)))
elif self.algorithm == 'RR':
# round robin
chosenBackendIndex = \
(self.numRequests % len(self.backends)) - 1
elif self.algorithm == 'SQF':
# choose replica with shortest queue
chosenBackendIndex = \
min(range(0, len(self.queueLengths)), \
key = lambda i: self.queueLengths[i])
elif self.algorithm == 'SQF-plus':
# choose replica with shortest queue
minIndices = [
i for i, x in enumerate(self.queueLengths)
if x == min(self.queueLengths)
]
if len(minIndices) == 1:
chosenBackendIndex = minIndices[0]
else:
dimmers = [self.lastThetas[i] for i in minIndices]
maxDimmerIndex = dimmers.index(max(dimmers))
chosenBackendIndex = minIndices[maxDimmerIndex]
elif self.algorithm == '2RC':
maxlat = [max(x) if x else 0 for x in self.lastLatencies]
if len(self.backends) == 1:
chosenBackendIndex = 0
# randomly select two backends and send it to the one with lowest latency
else:
backends = set(range(0, len(self.backends)))
randomlychosen = self.random.sample(backends, 2)
if maxlat[randomlychosen[0]] > maxlat[randomlychosen[1]]:
chosenBackendIndex = randomlychosen[1]
else:
chosenBackendIndex = randomlychosen[0]
elif self.algorithm == 'FRF':
# choose replica with minimum latency
maxlat = [max(x) if x else 0 for x in self.lastLatencies]
chosenBackendIndex = \
maxlat.index(min(maxlat))
elif self.algorithm == 'FRF-EWMA':
# choose replica with minimum EWMA latency
#self.sim.log(self, "EWMA RT {0}", self.ewmaResponseTime)
chosenBackendIndex = \
min(range(0, len(self.backends)), \
key = lambda i: self.ewmaResponseTime[i])
elif self.algorithm == 'predictive':
maxlat = np.array([max(x) if x else 0 for x in self.lastLatencies])
maxlatLast = np.array(
[max(x) if x else 0 for x in self.lastLastLatencies])
wlat = 0.2
wqueue = 0.8
points = wlat * (maxlat - maxlatLast) + wqueue * (
np.array(self.queueLengths) - np.array(self.lastQueueLengths))
# choose replica with shortest queue
chosenBackendIndex = \
min(range(0, len(points)), \
key = lambda i: points[i])
elif self.algorithm == "SRTF":
# choose replica with shortest "time" queue
#chosenBackendIndex = \
# min(range(0, len(self.backends)), \
# key = lambda i: sum([r.remainingTime if hasattr(r, 'remainingTime') else 0 for r in self.backends[i].activeRequests]))
chosenBackendIndex = \
min(range(0, len(self.queueLengths)), \
key = lambda i: self.queueLengths[i] * (self.backends[i].serviceTimeY * self.lastThetas[i] + self.backends[i].serviceTimeN * (1 - self.lastThetas[i])))
elif self.algorithm == 'theta-diff-plus-fast':
dt = self.sim.now - self.lastDecision
if dt > 1: dt = 1
for i in range(0, len(self.backends)):
# Gain
Kp = 0.25
Ti = 5.0
gammaTr = .01
# PI control law
e = self.lastThetas[i] - self.lastLastThetas[i]
self.queueOffsets[i] += (Kp * e +
(Kp / Ti) * self.lastThetas[i]) * dt
# Anti-windup
self.queueOffsets[i] -= gammaTr * (self.queueOffsets[i] -
self.queueLengths[i]) * dt
self.lastThetaErrors[i] = e
self.lastDecision = self.sim.now
# choose replica with shortest (queue + queueOffset)
chosenBackendIndex = \
min(range(0, len(self.queueLengths)), \
key = lambda i: self.queueLengths[i]-self.queueOffsets[i])
else:
raise Exception("Unknown load-balancing algorithm " +
self.algorithm)
request.chosenBackend = self.backends[chosenBackendIndex]
newRequest = Request()
newRequest.originalRequest = request
newRequest.onCompleted = lambda: self.onCompleted(newRequest)
#self.sim.log(self, "Directed request to {0}", chosenBackendIndex)
self.queueLengths[chosenBackendIndex] += 1
self.numRequestsPerReplica[chosenBackendIndex] += 1
self.backends[chosenBackendIndex].request(newRequest)