def test_oversubscribed(self):
"""Tests networks which are oversubscribed on the uplinks from racks/downlinks to racks."""
# initialization
q_bin = fpring.fp_ring_create(structuressjf.NUM_BINS_SHIFT)
q_urgent = fpring.fp_ring_create(2 * structuressjf.FP_NODES_SHIFT + 1)
q_head = fpring.fp_ring_create(2 * structuressjf.FP_NODES_SHIFT)
q_admitted_out = fpring.fp_ring_create(structuressjf.BATCH_SHIFT)
core = structuressjf.create_admission_core_state()
structuressjf.alloc_core_init(core, q_bin, q_bin, q_urgent, q_urgent)
status = structuressjf.create_admissible_status(
True, 2, 0, 128, q_head, q_admitted_out)
admitted_batch = structuressjf.create_admitted_batch()
for i in range(0, structuressjf.NUM_BINS):
empty_bin = structuressjf.create_bin(structuressjf.LARGE_BIN_SIZE)
fpring.fp_ring_enqueue(q_bin, empty_bin)
admissiblesjf.enqueue_head_token(q_urgent)
# Make requests that could overfill the links above the ToRs
admissiblesjf.add_backlog(status, 0, 32, 1)
admissiblesjf.add_backlog(status, 1, 64, 1)
admissiblesjf.add_backlog(status, 2, 96, 1)
admissiblesjf.add_backlog(status, 33, 65, 1)
admissiblesjf.add_backlog(status, 97, 66, 1)
# Get admissible traffic
admissiblesjf.get_admissible_traffic(core, status, admitted_batch, 0,
1, 0)
# Check that we admitted at most 2 packets for each of the
# oversubscribed links
admitted = admissiblesjf.dequeue_admitted_traffic(status)
rack_0_out = 0
rack_2_in = 0
for e in range(admitted.size):
edge = structuressjf.get_admitted_edge(admitted, e)
if structuressjf.get_rack_from_id(edge.src) == 0:
rack_0_out += 1
if structuressjf.get_rack_from_id(edge.dst) == 2:
rack_2_in += 1
self.assertEqual(rack_0_out, 2)
self.assertEqual(rack_2_in, 2)
# should clean up memory
pass
def test_oversubscribed(self):
"""Tests networks which are oversubscribed on the uplinks from racks/downlinks to racks."""
# initialization
q_bin = fpring.fp_ring_create(structuressjf.NUM_BINS_SHIFT)
q_urgent = fpring.fp_ring_create(2 * structuressjf.FP_NODES_SHIFT + 1)
q_head = fpring.fp_ring_create(2 * structuressjf.FP_NODES_SHIFT)
q_admitted_out= fpring.fp_ring_create(structuressjf.BATCH_SHIFT)
core = structuressjf.create_admission_core_state()
structuressjf.alloc_core_init(core, q_bin, q_bin, q_urgent, q_urgent)
status = structuressjf.create_admissible_status(True, 2, 0, 128, q_head,
q_admitted_out)
admitted_batch = structuressjf.create_admitted_batch()
for i in range(0, structuressjf.NUM_BINS):
empty_bin = structuressjf.create_bin(structuressjf.LARGE_BIN_SIZE)
fpring.fp_ring_enqueue(q_bin, empty_bin)
admissiblesjf.enqueue_head_token(q_urgent)
# Make requests that could overfill the links above the ToRs
admissiblesjf.add_backlog(status, 0, 32, 1)
admissiblesjf.add_backlog(status, 1, 64, 1)
admissiblesjf.add_backlog(status, 2, 96, 1)
admissiblesjf.add_backlog(status, 33, 65, 1)
admissiblesjf.add_backlog(status, 97, 66, 1)
# Get admissible traffic
admissiblesjf.get_admissible_traffic(core, status, admitted_batch, 0, 1, 0)
# Check that we admitted at most 2 packets for each of the
# oversubscribed links
admitted = admissiblesjf.dequeue_admitted_traffic(status)
rack_0_out = 0
rack_2_in = 0
for e in range(admitted.size):
edge = structuressjf.get_admitted_edge(admitted, e)
if structuressjf.get_rack_from_id(edge.src) == 0:
rack_0_out += 1
if structuressjf.get_rack_from_id(edge.dst) == 2:
rack_2_in += 1
self.assertEqual(rack_0_out, 2)
self.assertEqual(rack_2_in, 2)
# should clean up memory
pass
def test_many_requests(self):
"""Tests the admissible algorithm over a long time, including oversubscription."""
n_nodes = 64
max_r_per_t = 10 # max requests per timeslot
duration = 100000
max_size = 20
rack_capacity = 24
# Track pending requests - mapping from src/dst to num requested
pending_requests = {}
# Track total demands
cumulative_demands = {}
# initialization
q_bin = fpring.fp_ring_create(structuressjf.NUM_BINS_SHIFT)
q_urgent = fpring.fp_ring_create(2 * structuressjf.FP_NODES_SHIFT + 1)
q_head = fpring.fp_ring_create(2 * structuressjf.FP_NODES_SHIFT)
q_admitted_out = fpring.fp_ring_create(structuressjf.BATCH_SHIFT)
core = structuressjf.create_admission_core_state()
structuressjf.alloc_core_init(core, q_bin, q_bin, q_urgent, q_urgent)
status = structuressjf.create_admissible_status(
True, rack_capacity, 0, n_nodes, q_head, q_admitted_out)
admitted_batch = structuressjf.create_admitted_batch()
for i in range(0, structuressjf.NUM_BINS):
empty_bin = structuressjf.create_bin(structuressjf.LARGE_BIN_SIZE)
fpring.fp_ring_enqueue(q_bin, empty_bin)
admissiblesjf.enqueue_head_token(q_urgent)
num_admitted = 0
num_requested = 0
for b in range(duration / structuressjf.BATCH_SIZE):
# Make some new requests
for t in range(structuressjf.BATCH_SIZE):
requests_per_timeslot = random.randint(0, max_r_per_t)
for r in range(requests_per_timeslot):
src = random.randint(0, n_nodes - 1)
dst = random.randint(0, n_nodes - 2)
if (dst >= src):
dst += 1 # don't send to self
size = random.randint(1, max_size)
demand = cumulative_demands.get((src, dst), 0)
demand += size
cumulative_demands[(src, dst)] = demand
if (src, dst) in pending_requests.keys():
pending_requests[(
src, dst)] = pending_requests[(src, dst)] + size
else:
pending_requests[(src, dst)] = size
admissiblesjf.add_backlog(status, src, dst, size)
num_requested += size
# Get admissible traffic for this batch
admissiblesjf.get_admissible_traffic(core, status, admitted_batch,
0, 1, 0)
for i in range(structuressjf.BATCH_SIZE):
admitted_i = admissiblesjf.dequeue_admitted_traffic(status)
num_admitted += admitted_i.size
# Check all admitted edges - make sure they were requested
# and have not yet been fulfilled
self.assertTrue(admitted_i.size <= n_nodes)
rack_outputs = [0, 0]
rack_inputs = [0, 0]
for e in range(admitted_i.size):
edge = structuressjf.get_admitted_edge(admitted_i, e)
pending_count = pending_requests[(edge.src, edge.dst)]
self.assertTrue(pending_count >= 1)
if pending_count > 1:
pending_requests[(edge.src,
edge.dst)] = pending_count - 1
else:
del pending_requests[(edge.src, edge.dst)]
rack_outputs[structuressjf.get_rack_from_id(edge.src)] += 1
rack_inputs[structuressjf.get_rack_from_id(edge.dst)] += 1
for index in range(len(rack_outputs)):
self.assertTrue(rack_outputs[index] <= rack_capacity)
self.assertTrue(rack_inputs[index] <= rack_capacity)
print 'requested %d, admitted %d, capacity %d' % (
num_requested, num_admitted, duration * n_nodes)
# should clean up memory
pass
def test_many_requests(self):
"""Tests the admissible algorithm over a long time, including oversubscription."""
n_nodes = 64
max_r_per_t = 10 # max requests per timeslot
duration = 100000
max_size = 20
rack_capacity = 24
# Track pending requests - mapping from src/dst to num requested
pending_requests = {}
# Track total demands
cumulative_demands = {}
# initialization
q_bin = fpring.fp_ring_create(structuressjf.NUM_BINS_SHIFT)
q_urgent = fpring.fp_ring_create(2 * structuressjf.FP_NODES_SHIFT + 1)
q_head = fpring.fp_ring_create(2 * structuressjf.FP_NODES_SHIFT)
q_admitted_out= fpring.fp_ring_create(structuressjf.BATCH_SHIFT)
core = structuressjf.create_admission_core_state()
structuressjf.alloc_core_init(core, q_bin, q_bin, q_urgent, q_urgent)
status = structuressjf.create_admissible_status(True, rack_capacity, 0, n_nodes, q_head,
q_admitted_out)
admitted_batch = structuressjf.create_admitted_batch()
for i in range(0, structuressjf.NUM_BINS):
empty_bin = structuressjf.create_bin(structuressjf.LARGE_BIN_SIZE)
fpring.fp_ring_enqueue(q_bin, empty_bin)
admissiblesjf.enqueue_head_token(q_urgent)
num_admitted = 0
num_requested = 0
for b in range(duration / structuressjf.BATCH_SIZE):
# Make some new requests
for t in range(structuressjf.BATCH_SIZE):
requests_per_timeslot = random.randint(0, max_r_per_t)
for r in range(requests_per_timeslot):
src = random.randint(0, n_nodes-1)
dst = random.randint(0, n_nodes-2)
if (dst >= src):
dst += 1 # don't send to self
size = random.randint(1, max_size)
demand = cumulative_demands.get((src, dst), 0)
demand += size
cumulative_demands[(src, dst)] = demand
if (src, dst) in pending_requests.keys():
pending_requests[(src, dst)] = pending_requests[(src, dst)] + size
else:
pending_requests[(src, dst)] = size
admissiblesjf.add_backlog(status, src, dst, size)
num_requested += size
# Get admissible traffic for this batch
admissiblesjf.get_admissible_traffic(core, status, admitted_batch, 0, 1, 0)
for i in range(structuressjf.BATCH_SIZE):
admitted_i = admissiblesjf.dequeue_admitted_traffic(status)
num_admitted += admitted_i.size
# Check all admitted edges - make sure they were requested
# and have not yet been fulfilled
self.assertTrue(admitted_i.size <= n_nodes)
rack_outputs = [0, 0]
rack_inputs = [0, 0]
for e in range(admitted_i.size):
edge = structuressjf.get_admitted_edge(admitted_i, e)
pending_count = pending_requests[(edge.src, edge.dst)]
self.assertTrue(pending_count >= 1)
if pending_count > 1:
pending_requests[(edge.src, edge.dst)] = pending_count - 1
else:
del pending_requests[(edge.src, edge.dst)]
rack_outputs[structuressjf.get_rack_from_id(edge.src)] += 1
rack_inputs[structuressjf.get_rack_from_id(edge.dst)] += 1
for index in range(len(rack_outputs)):
self.assertTrue(rack_outputs[index] <= rack_capacity)
self.assertTrue(rack_inputs[index] <= rack_capacity)
print 'requested %d, admitted %d, capacity %d' % (num_requested, num_admitted, duration * n_nodes)
# should clean up memory
pass