def test_a_heavily_biased_sample_of_100_out_of_1000_elements(self):
sample = ExponentiallyDecayingSample(1000, 0.01)
for i in xrange(100):
sample.update(i)
snapshot = sample.get_snapshot()
self.assertEqual(sample.size(), 100)
self.assertEqual(snapshot.size(), 100)
for i in snapshot.get_values():
self.assertTrue(i < 100 and i >= 0)
def test_a_sample_of_100_out_of_10_elements(self):
sample = ExponentiallyDecayingSample(100, 0.99)
for i in xrange(10):
sample.update(i)
snapshot = sample.get_snapshot()
self.assertEqual(sample.size(), 10)
self.assertEqual(snapshot.size(), 10)
self.assertAlmostEqual(snapshot.get_median(), 4.5)
for i in snapshot.get_values():
self.assertTrue(i < 10 and i >= 0)
def get_biased(klass):
"""
Create a new instance of L{Histogram} that uses an L{ExponentiallyDecayingSample}
with sample size L{DEFAULT_SAMPLE_SIZE} and alpha L{DEFAULT_ALPHA}.
@return: L{Histogram}
"""
return klass(ExponentiallyDecayingSample(klass.DEFAULT_SAMPLE_SIZE, klass.DEFAULT_ALPHA))
def test_long_period_of_inactivity_should_not_corrupt_sampling_state(self):
twisted_clock = Clock()
sample = ExponentiallyDecayingSample(10, 0.015, twisted_clock.seconds)
for i in xrange(1000):
sample.update(1000 + i)
twisted_clock.advance(0.1)
self.assertTrue(sample.get_snapshot().size() == 10)
self._assert_all_values_between(sample, 1000, 2000)
twisted_clock.advance(15*3600)
sample.update(2000)
self.assertTrue(sample.get_snapshot().size() == 2)
self._assert_all_values_between(sample, 1000, 3000)
for i in xrange(1000):
sample.update(3000 + i)
twisted_clock.advance(0.1)
self.assertTrue(sample.get_snapshot().size() == 10)
self._assert_all_values_between(sample, 3000, 4000)
def test_a_heavily_biased_sample_of_100_out_of_1000_elements(self):
sample = ExponentiallyDecayingSample(1000, 0.01)
for i in xrange(100):
sample.update(i)
snapshot = sample.get_snapshot()
self.assertEqual(sample.size(), 100)
self.assertEqual(snapshot.size(), 100)
for i in snapshot.get_values():
self.assertTrue(i < 100 and i >= 0)
def test_a_sample_of_100_out_of_10_elements(self):
sample = ExponentiallyDecayingSample(100, 0.99)
for i in xrange(10):
sample.update(i)
snapshot = sample.get_snapshot()
self.assertEqual(sample.size(), 10)
self.assertEqual(snapshot.size(), 10)
self.assertAlmostEqual(snapshot.get_median(), 4.5)
for i in snapshot.get_values():
self.assertTrue(i < 10 and i >= 0)
def test_long_period_of_inactivity_should_not_corrupt_sampling_state(self):
twisted_clock = Clock()
sample = ExponentiallyDecayingSample(10, 0.015, twisted_clock.seconds)
for i in xrange(1000):
sample.update(1000 + i)
twisted_clock.advance(0.1)
self.assertTrue(sample.get_snapshot().size() == 10)
self._assert_all_values_between(sample, 1000, 2000)
twisted_clock.advance(15 * 3600)
sample.update(2000)
self.assertTrue(sample.get_snapshot().size() == 2)
self._assert_all_values_between(sample, 1000, 3000)
for i in xrange(1000):
sample.update(3000 + i)
twisted_clock.advance(0.1)
self.assertTrue(sample.get_snapshot().size() == 10)
self._assert_all_values_between(sample, 3000, 4000)
def __init__(self, id_, serverList, replicaSelectionStrategy,
accessPattern, replicationFactor, backpressure,
shadowReadRatio, rateInterval, cubicC, cubicSmax, cubicBeta,
hysterisisFactor, demandWeight, costExponent,
concurrencyWeight):
self.id = id_
self.serverList = serverList
self.accessPattern = accessPattern
self.replicationFactor = replicationFactor
self.REPLICA_SELECTION_STRATEGY = replicaSelectionStrategy
self.pendingRequestsMonitor = \
Simulation.Monitor(name="PendingRequests")
self.latencyTrackerMonitor = Simulation.Monitor(name="ResponseHandler")
self.rateMonitor = Simulation.Monitor(name="AlphaMonitor")
self.receiveRateMonitor = Simulation.Monitor(name="ReceiveRateMonitor")
self.tokenMonitor = Simulation.Monitor(name="TokenMonitor")
self.edScoreMonitor = Simulation.Monitor(name="edScoreMonitor")
self.backpressure = backpressure # True/Flase
self.shadowReadRatio = shadowReadRatio
self.demandWeight = demandWeight
self.costExponent = costExponent
self.concurrencyWeight = concurrencyWeight
# Book-keeping and metrics to be recorded follow...
# Number of outstanding requests at the client
self.pendingRequestsMap = {node: 0 for node in serverList}
# Number of outstanding requests times oracle-service time of replica
self.pendingXserviceMap = {node: 0 for node in serverList}
# Last-received response time of server
self.responseTimesMap = {node: 0 for node in serverList}
# Used to track response time from the perspective of the client
self.taskSentTimeTracker = {}
self.taskArrivalTimeTracker = {}
self.taskBatchCounter = {}
# Record waiting and service times as relayed by the server
self.expectedDelayMap = {node: {} for node in serverList}
self.lastSeen = {node: 0 for node in serverList}
# Round robin parameters
self.rrIndex = {node: 0 for node in serverList}
# Rate limiters per replica
self.rateLimiters = {
node: RateLimiter("RL-%s" % node.id, self, 10, rateInterval)
for node in serverList
}
self.lastRateDecrease = {node: 0 for node in serverList}
self.valueOfLastDecrease = {node: 10 for node in serverList}
self.receiveRate = {
node: ReceiveRate("RL-%s" % node.id, rateInterval)
for node in serverList
}
self.lastRateIncrease = {node: 0 for node in serverList}
self.rateInterval = rateInterval
# Parameters for congestion control
self.cubicC = cubicC
self.cubicSmax = cubicSmax
self.cubicBeta = cubicBeta
self.hysterisisFactor = hysterisisFactor
# Parameters for Refresh selection
self.sendtime = {node: 0.00000000 for node in serverList}
# Backpressure related initialization
if (backpressure is True):
self.backpressureSchedulers = \
{node: BackpressureScheduler("BP-%s" % node.id, self)
for node in serverList}
for node in serverList:
Simulation.activate(self.backpressureSchedulers[node],
self.backpressureSchedulers[node].run(),
at=Simulation.now())
# ds-metrics
if (replicaSelectionStrategy == "ds"):
self.latencyEdma = {
node: ExponentiallyDecayingSample(100, 0.75, self.clock)
for node in serverList
}
self.dsScores = {node: 0 for node in serverList}
for node, rateLimiter in self.rateLimiters.items():
ds = DynamicSnitch(self, 100)
Simulation.activate(ds, ds.run(), at=Simulation.now())
