def run(cloudburst: CloudburstConnection,
num_requests: int,
data_size: str,
do_optimize: bool):
def stage1(self, row: Row) -> bytes:
import numpy as np
return np.random.rand(row['size'])
def stage2(self, row: Row) -> int:
return 3
print(f'Creating flow with {data_size} ({DATA_SIZES[data_size]}) inputs.')
flow = Flow('colocate-benchmark', FlowType.PUSH, cloudburst)
f1 = flow.map(stage1)
p1 = f1.map(stage2, names=['val1'])
p2 = f1.map(stage2, names=['val2'])
p3 = f1.map(stage2, names=['val3'])
p4 = f1.map(stage2, names=['val4'])
p5 = f1.map(stage2, names=['val5'])
# p6 = f1.map(stage2, names=['val6'])
# p7 = f1.map(stage2, names=['val7'])
# p8 = f1.map(stage2, names=['val8'])
p1.join(p2).join(p3).join(p4).join(p5) # .join(p6).join(p7).join(p8)
if do_optimize:
flow = optimize(flow, rules=optimize_rules)
print('Flow has been optimized...')
flow.deploy()
print('Flow successfully deployed!')
latencies = []
inp = Table([('size', IntType)])
inp.insert([DATA_SIZES[data_size]])
print('Starting benchmark...')
for i in range(num_requests):
if i % 100 == 0 and i > 0:
print(f'On request {i}...')
start = time.time()
res = flow.run(inp).get()
end = time.time()
latencies.append(end - start)
print_latency_stats(latencies, 'E2E')
def run(cloudburst: CloudburstConnection, num_requests: int, gamma: int,
num_replicas: int):
def stage1(self, val: int) -> int:
return val + 1
def stage2(self, row: Row) -> float:
import time
from scipy.stats import gamma
delay = gamma.rvs(3.0, scale=row['scale']) * 10 / 1000 # convert to ms
time.sleep(delay)
return delay
def stage3(self, row: Row) -> float:
return row['val']
print(f'Creating flow with {num_replicas} replicas and' +
f' gamma={GAMMA_VALS[gamma]}')
flow = Flow('fusion-benchmark', FlowType.PUSH, cloudburst)
flow.map(stage1, col='val') \
.map(stage2, names=['val'], high_variance=True) \
.map(stage3, names=['val'])
optimize_rules['compete_replicas'] = num_replicas
flow = optimize(flow, rules=optimize_rules)
print('Flow has been optimized...')
flow.deploy()
print('Flow successfully deployed!')
latencies = []
inp = Table([('val', IntType), ('scale', FloatType)])
inp.insert([1, GAMMA_VALS[gamma]])
print('Starting benchmark...')
for i in range(num_requests):
if i % 100 == 0 and i > 0:
print(f'On request {i}...')
time.sleep(.300) # Sleep to let the queue drain.
start = time.time()
res = flow.run(inp).get()
end = time.time()
latencies.append(end - start)
print_latency_stats(latencies, 'E2E')
def run(cloudburst: CloudburstConnection, num_requests: int, num_fns: int,
data_size: str, do_optimize: bool):
def fusion_op(self, row: Row) -> bytes:
return row['data']
print(f'Creating flow with {num_fns} operators and {data_size}' +
f' ({DATA_SIZES[data_size]}) inputs.')
flow = Flow('fusion-benchmark', FlowType.PUSH, cloudburst)
marker = flow
for _ in range(num_fns):
marker = marker.map(fusion_op, names=['data'])
if do_optimize:
flow = optimize(flow, rules=optimize_rules)
print('Flow has been optimized...')
flow.deploy()
print('Flow successfully deployed!')
latencies = []
inp = Table([('data', BtsType)])
inp.insert([os.urandom(DATA_SIZES[data_size])])
print('Starting benchmark...')
for i in range(num_requests):
if i % 100 == 0 and i > 0:
print(f'On request {i}...')
start = time.time()
res = flow.run(inp).get()
end = time.time()
latencies.append(end - start)
print_latency_stats(latencies, 'E2E')
table = Table([('img', StrType)])
img = base64.b64encode(open('panda.jpg', "rb").read()).decode('ascii')
table.insert([img])
cloudburst = CloudburstConnection(sys.argv[1], '3.226.122.35')
flow = Flow('ensemble-flow', FlowType.PUSH, cloudburst)
img = flow.map(transform, init=transform_init, names=['img'])
anet = img.map(alexnet_model, init=alexnet_init, names=['alexnet_index', 'alexnet_perc'])
rnet = img.map(resnet_model, init=resnet_init, names=['resnet_index', 'resnet_perc'])
anet.join(rnet).map(ensemble_predict, names=['class'])
flow.deploy()
from cloudburst.server.benchmarks.utils import print_latency_stats
import time
print('Starting benchmark...')
latencies = []
for _ in range(100):
start = time.time()
result = flow.run(table).get()
end = time.time()
time.sleep(1)
latencies.append(end - start)
print_latency_stats(latencies, "E2E")
cloudburst.list()
import random
import string
salt = "".join(random.choices(string.ascii_letters, k=6))
print("Running sanity check")
cloud_sq = cloudburst.register(lambda _, x: x * x, "square-2"+salt)
print(cloud_sq(2).get())
cloudburst.delete_dag("dag")
cloudburst.register_dag("dag", ["square-2"+salt], [])
print(cloudburst.call_dag("dag", {"square-2"+salt: [2]}).get())
# 1 / 0
print("Running example flow")
dataflow = Flow("example-flow"+salt, FlowType.PUSH, cloudburst)
dataflow.map(map_fn, names=["sum"]).filter(filter_fn)
table = Table([("a", IntType), ("b", IntType)])
table.insert([1, 2])
table.insert([1, 3])
table.insert([1, 4])
dataflow.register()
dataflow.deploy()
print(dataflow)
print("deployed")
print(dataflow.run(table).get())
def run(cloudburst: CloudburstConnection, num_requests: int, batch_size: int,
gpu: bool):
with open('imagenet_classes.txt', 'r') as f:
classes = [line.strip() for line in f.readlines()]
cloudburst.put_object('imagenet-classes', classes)
def resnet_init_gpu(self, cloudburst):
import os
import torch
import torchvision
from torchvision import transforms
tpath = os.path.join(os.getenv('TORCH_HOME'), 'checkpoints')
self.resnet = torch.load(os.path.join(tpath, 'resnet101.model')).cuda()
self.resnet.eval()
self.transforms = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
self.classes = cloudburst.get('imagenet-classes')
def resnet_model_gpu(self, table: Table) -> str:
"""
AlexNet for image classification on ImageNet
"""
import torch
inputs = []
for row in table.get():
img = self.transforms(row['img'])
inputs.append(img)
inputs = torch.stack(inputs, dim=0).cuda()
output = self.resnet(inputs)
_, indices = torch.sort(output, descending=True)
indices = indices.cpu().detach().numpy()
result = []
for idx_set in indices:
index = idx_set[0]
result.append(self.classes[index])
return result
def resnet_init_cpu(self, cloudburst):
import os
import torch
import torchvision
from torchvision import transforms
tpath = os.path.join(os.getenv('TORCH_HOME'), 'checkpoints')
self.resnet = torch.load(os.path.join(tpath, 'resnet101.model'))
self.resnet.eval()
self.transforms = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
self.classes = cloudburst.get('imagenet-classes')
def resnet_model_cpu(self, table: Table) -> str:
"""
AlexNet for image classification on ImageNet
"""
import torch
inputs = []
for row in table.get():
img = self.transforms(row['img'])
inputs.append(img)
inputs = torch.stack(inputs, dim=0)
output = self.resnet(inputs)
_, indices = torch.sort(output, descending=True)
indices = indices.detach().numpy()
result = []
for idx_set in indices:
index = idx_set[0]
result.append(self.classes[index])
return result
print(f'Creating flow with size {batch_size} batches.')
flow = Flow('batching-benchmark', FlowType.PUSH, cloudburst)
if gpu:
flow.map(resnet_model_gpu,
init=resnet_init_gpu,
names=['class'],
gpu=True,
batching=True)
else:
flow.map(resnet_model_cpu,
init=resnet_init_cpu,
names=['class'],
batching=True)
flow.deploy()
print('Flow successfully deployed!')
latencies = []
inp = Table([('img', NumpyType)])
img = np.array(Image.open('panda.jpg').convert('RGB').resize((224, 224)))
inp.insert([img])
kvs = cloudburst.kvs_client
if gpu:
print('Starting GPU warmup...')
for _ in range(50):
flow.run(inp).get()
print('Finished warmup...')
print('Starting benchmark...')
for i in range(num_requests):
if i % 100 == 0 and i > 0:
print(f'On request {i}...')
futs = []
for _ in range(batch_size):
futs.append(flow.run(inp))
pending = set([fut.obj_id for fut in futs])
# Break these apart to batch the KVS get requests.
start = time.time()
while len(pending) > 0:
get_start = time.time()
response = kvs.get(list(pending))
for key in response:
if response[key] is not None:
pending.discard(key)
end = time.time()
latencies.append(end - start)
compute_time = np.mean(latencies) * num_requests
tput = (batch_size * num_requests) / (compute_time)
print('THROUGHPUT: %.2f' % (tput))
print_latency_stats(latencies, 'E2E')
# cloudburst.put_object(key, product_set)
print('Deploying flow...')
flow.deploy()
print('Starting warmup phase...')
for i in range(NUM_PRODUCT_SETS):
if i % 100 == 0:
print(f'On warmup {i}...')
uid = np.random.randint(NUM_USERS)
recent = np.array([i, 0, 0, 0, 0])
inp = Table([('user', StrType), ('recent', NumpyType)])
inp.insert([str(uid), recent])
flow.run(inp).get()
print('Starting benchmark...')
local = args.local[0].lower() == 'true'
if local:
run(flow, cloudburst, args.requests[0], local)
else:
flow.cloudburst = None # Hack to serialize and send flow.
queue = [flow]
while len(queue) > 0:
op = queue.pop(0)
op.cb_fn = None
queue.extend(op.downstreams)
def run(cloudburst: CloudburstConnection,
num_requests: int,
data_size: str,
breakpoint: bool,
do_optimize: bool):
print('Creating data...')
size = DATA_SIZES[data_size]
for i in range(1, NUM_DATA_POINTS+1):
arr = np.random.rand(size)
cloudburst.put_object('data-' + str(i), arr)
def stage1(self, row: Row) -> (int, str):
idx = int(row['req_num'] / 10) + 1
key = 'data-%d' % (idx)
return idx, key
def stage2(self, row: Row) -> str:
import numpy as np
arr = row[row['key']]
return float(np.sum(arr))
print(f'Creating flow with {data_size} ({DATA_SIZES[data_size]}) inputs.')
flow = Flow('locality-benchmark', FlowType.PUSH, cloudburst)
flow.map(stage1, names=['index', 'key']) \
.lookup('key', dynamic=True) \
.map(stage2, names=['sum'])
optimize_rules['breakpoint'] = breakpoint
if do_optimize:
flow = optimize(flow, rules=optimize_rules)
print('Flow has been optimized...')
flow.deploy()
print('Flow successfully deployed!')
latencies = []
inp = Table([('req_num', IntType)])
if breakpoint:
print('Starting warmup...')
for i in range(NUM_DATA_POINTS):
inp = Table([('req_num', IntType)])
inp.insert([i * 10])
res = flow.run(inp).get()
print('Pausing to let cache metadata propagate...')
time.sleep(15)
print('Starting benchmark...')
for i in range(num_requests):
if i % 100 == 0 and i > 0:
print(f'On request {i}...')
inp = Table([('req_num', IntType)])
inp.insert([i])
start = time.time()
res = flow.run(inp).get()
end = time.time()
latencies.append(end - start)
with open('data.bts', 'wb') as f:
from cloudburst.shared.serializer import Serializer
ser = Serializer()
bts = ser.dump(latencies)
f.write(bts)
print_latency_stats(latencies, 'E2E')