Example #1
0
def main():
    # proc path
    recvTm = march.make_time_model("expo", [8500.0])
    respTm = None
    proc_stage = march.make_stage(stage_name="proc",
                                  pathId=0,
                                  pathStageId=0,
                                  stageId=0,
                                  blocking=True,
                                  batching=False,
                                  socket=False,
                                  net=False,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None)

    path = march.make_code_path(pathId=0,
                                prob=1.0,
                                stages=[proc_stage],
                                priority=None)

    mongo_io = march.make_micro_service(servType="micro_service",
                                        servName="mongo_io",
                                        bindConn=False,
                                        paths=[path])

    with open("./json/microservice/mongo_io.json", "w+") as f:
        json.dump(mongo_io, f, indent=2)
Example #2
0
def main():
    # req path
    recvTm = march.make_time_model("expo", [160000])
    respTm = None
    proc_stage = march.make_stage(stage_name="user_proc",
                                  pathId=0,
                                  pathStageId=0,
                                  stageId=0,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  epoll=False,
                                  ngx=False,
                                  net=False,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None,
                                  scaleFactor=0.55,
                                  useHist=False)

    recvTm = march.make_time_model("const", [0])
    respTm = None
    thrift_stage = march.make_stage(stage_name="thrift_proc",
                                    pathId=0,
                                    pathStageId=1,
                                    stageId=1,
                                    blocking=False,
                                    batching=False,
                                    socket=False,
                                    epoll=False,
                                    ngx=False,
                                    net=True,
                                    chunk=False,
                                    recvTm=recvTm,
                                    respTm=respTm,
                                    cm=None,
                                    criSec=False,
                                    threadLimit=None,
                                    scaleFactor=0.55,
                                    useHist=False)

    req_path = march.make_code_path(pathId=0,
                                    prob=100,
                                    stages=[proc_stage, thrift_stage],
                                    priority=None)

    # user
    user = march.make_micro_service(servType="micro_service",
                                    servName="user",
                                    bindConn=True,
                                    paths=[req_path],
                                    baseFreq=2600,
                                    curFreq=2600)

    with open("./json/microservice/user.json", "w+") as f:
        json.dump(user, f, indent=2)
Example #3
0
def main():
    # fopen path
    recvTm = march.make_time_model("expo", [3.0])
    respTm = None
    fopen_stage = march.make_stage(stage_name="fopen",
                                   pathId=0,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=False,
                                   socket=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None)

    fopen_path = march.make_code_path(pathId=0,
                                      prob=None,
                                      stages=[fopen_stage],
                                      priority=None)

    # fput path
    recvTm = march.make_time_model("expo", [1.0])
    respTm = None
    fput_stage = march.make_stage(stage_name="fput",
                                  pathId=1,
                                  pathStageId=0,
                                  stageId=1,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  net=False,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None)

    fput_path = march.make_code_path(pathId=1,
                                     prob=None,
                                     stages=[fput_stage],
                                     priority=None)

    php_io = march.make_micro_service(servType="micro_service",
                                      servName="php_io",
                                      bindConn=False,
                                      paths=[fopen_path, fput_path])

    with open("./json/microservice/php_io.json", "w+") as f:
        json.dump(php_io, f, indent=2)
Example #4
0
def main():
    # req path
    recvTm = march.make_time_model("expo", [1.5])
    respTm = None
    epoll_stage = march.make_stage(stage_name="epoll",
                                   pathId=0,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=True,
                                   socket=False,
                                   epoll=True,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None)

    recvTm = march.make_time_model("expo", [17.0])
    respTm = None
    proc_stage = march.make_stage(stage_name="proc",
                                  pathId=0,
                                  pathStageId=1,
                                  stageId=1,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  epoll=False,
                                  net=True,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None)

    path = march.make_code_path(pathId=0,
                                prob=1.0,
                                stages=[epoll_stage, proc_stage],
                                priority=None)

    # nginx
    nginx = march.make_micro_service(servType="micro_service",
                                     servName="nginx",
                                     bindConn=True,
                                     paths=[path])

    with open("./json/microservice/nginx.json", "w+") as f:
        json.dump(nginx, f, indent=2)
Example #5
0
def main():
	# a dummy stage with 0 processing time
	# used mainly for synchronization
	recvTm = march.make_time_model("const", [0])
	respTm = None
	proc = march.make_stage(stage_name = "proc_load_bal", pathId = 0, pathStageId = 0, stageId = 0, blocking = False, batching = False, socket = False, 
		epoll = False, ngx = False, net = True, chunk = False, recvTm = recvTm, respTm = respTm, cm = None, criSec = False, threadLimit = None,
		scaleFactor = 0.0)
	path = march.make_code_path(pathId = 0, prob = 1.0, stages=[proc], priority = None)


	# load balancer
	ldb = march.make_micro_service(servType = "micro_service", servName = "load_balancer", bindConn = True, paths = [path],
		baseFreq = 2.6, curFreq = 2.6)

	with open("./json/microservice/load_balancer.json", "w+") as f:
		json.dump(ldb, f, indent=2)
Example #6
0
def main():
	# proc path
	recvTm = march.make_time_model("expo", [5000000])	# 5000 us
	respTm = None

	cmodel = march.make_chunk_model("expo", [2])

	proc_stage = march.make_stage(stage_name = "disk_io", pathId = 0, pathStageId = 0, stageId = 0, blocking = False, batching = False, socket = False, 
		epoll = False, ngx = False, net = False, chunk = True, recvTm = recvTm, respTm = respTm, cm = cmodel, criSec = False, threadLimit = None,
		scaleFactor = 0.0)

	path = march.make_code_path(pathId = 0, prob = 100, stages=[proc_stage], priority = None)
	
	mongo_io = march.make_micro_service(servType = "micro_service", servName = "mongo_io", bindConn = False, paths = [path], baseFreq = 2600, curFreq = 2600)

	with open("./json/microservice/mongo_io.json", "w+") as f:
		json.dump(mongo_io, f, indent=2)
Example #7
0
def main():
	# read path
	recvTm = march.make_time_model("expo", [3000])
	respTm = None

	# currently do not test the epoll_stage model
	stage = march.make_stage(stage_name = "rabbitmq", pathId = 0, pathStageId = 0, stageId = 0, blocking = False, batching = False, socket = False, 
		epoll = False, ngx = False, net = True, chunk = False, recvTm = recvTm, respTm = respTm, cm = None, criSec = False, threadLimit = None, 
		scaleFactor = 0.0)

	path = march.make_code_path(pathId = 0, prob = None, stages=[stage], priority = None)

	# memcached
	rabbitmq = march.make_micro_service(servType = "micro_service", servName = "rabbitmq", bindConn = True, paths = [path], 
		baseFreq = 2600, curFreq = 2600)

	with open("./json/microservice/rabbitmq.json", "w+") as f:
		json.dump(rabbitmq, f, indent=2)
Example #8
0
def main():
    # codepath 0: tcp send to localhost
    recvTm = march.make_time_model("expo", [1500])
    respTm = None
    proc_send_local = march.make_stage(stage_name="proc_send_local",
                                       pathId=0,
                                       pathStageId=0,
                                       stageId=0,
                                       blocking=False,
                                       batching=False,
                                       socket=False,
                                       epoll=False,
                                       ngx=False,
                                       net=True,
                                       chunk=False,
                                       recvTm=recvTm,
                                       respTm=respTm,
                                       cm=None,
                                       criSec=False,
                                       threadLimit=None,
                                       scaleFactor=0.0,
                                       useHist=False)
    send_local = march.make_code_path(pathId=0,
                                      prob=None,
                                      stages=[proc_send_local],
                                      priority=None)

    # codepath 1: tcp send to remote host
    recvTm = march.make_time_model("expo", [1000])
    respTm = None
    proc_send_remote = march.make_stage(stage_name="proc_send_remote",
                                        pathId=1,
                                        pathStageId=0,
                                        stageId=1,
                                        blocking=False,
                                        batching=False,
                                        socket=False,
                                        epoll=False,
                                        ngx=False,
                                        net=True,
                                        chunk=False,
                                        recvTm=recvTm,
                                        respTm=respTm,
                                        cm=None,
                                        criSec=False,
                                        threadLimit=None,
                                        scaleFactor=0.0,
                                        useHist=False)
    send_remote = march.make_code_path(pathId=1,
                                       prob=None,
                                       stages=[proc_send_remote],
                                       priority=None)

    # codepath 2: tcp recv from local host
    recvTm = march.make_time_model("expo", [1500])
    respTm = None
    proc_recv_local = march.make_stage(stage_name="proc_recv_local",
                                       pathId=2,
                                       pathStageId=0,
                                       stageId=2,
                                       blocking=False,
                                       batching=False,
                                       socket=False,
                                       epoll=False,
                                       ngx=False,
                                       net=True,
                                       chunk=False,
                                       recvTm=recvTm,
                                       respTm=respTm,
                                       cm=None,
                                       criSec=False,
                                       threadLimit=None,
                                       scaleFactor=0.0,
                                       useHist=False)
    recv_local = march.make_code_path(pathId=2,
                                      prob=None,
                                      stages=[proc_recv_local],
                                      priority=None)

    # codepath 3: tcp recv from remote host
    recvTm = march.make_time_model("expo", [4000])
    respTm = None
    proc_recv_remote = march.make_stage(stage_name="proc_recv_remote",
                                        pathId=3,
                                        pathStageId=0,
                                        stageId=3,
                                        blocking=False,
                                        batching=False,
                                        socket=False,
                                        epoll=False,
                                        ngx=False,
                                        net=True,
                                        chunk=False,
                                        recvTm=recvTm,
                                        respTm=respTm,
                                        cm=None,
                                        criSec=False,
                                        threadLimit=None,
                                        scaleFactor=0.0,
                                        useHist=False)
    recv_remote = march.make_code_path(pathId=3,
                                       prob=None,
                                       stages=[proc_recv_remote],
                                       priority=None)

    # tcp
    tcp = march.make_micro_service(
        servType="micro_service",
        servName="net_stack",
        bindConn=True,
        paths=[send_local, send_remote, recv_local, recv_remote],
        baseFreq=2600,
        curFreq=2600)

    with open("./json/microservice/net_stack.json", "w+") as f:
        json.dump(tcp, f, indent=2)
Example #9
0
def main():
    # read path
    recvTm = march.make_time_model("expo", [1500])
    respTm = None

    # currently do not test the epoll_stage model
    epoll_stage = march.make_stage(stage_name="epoll",
                                   pathId=0,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=True,
                                   socket=False,
                                   epoll=False,
                                   ngx=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None,
                                   scaleFactor=0.55)

    recvTm = march.make_time_model("expo", [1500])
    respTm = None
    socket_stage = march.make_stage(stage_name="socket",
                                    pathId=0,
                                    pathStageId=1,
                                    stageId=1,
                                    blocking=False,
                                    batching=True,
                                    socket=True,
                                    epoll=False,
                                    ngx=False,
                                    net=False,
                                    chunk=False,
                                    recvTm=recvTm,
                                    respTm=respTm,
                                    cm=None,
                                    criSec=False,
                                    threadLimit=None,
                                    scaleFactor=0.35)

    recvTm = march.make_time_model("expo", [600])
    respTm = None
    read_stage = march.make_stage(stage_name="proc_read",
                                  pathId=0,
                                  pathStageId=2,
                                  stageId=2,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  epoll=False,
                                  ngx=False,
                                  net=False,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None,
                                  scaleFactor=0.45)

    recvTm = march.make_time_model("expo", [7500])
    respTm = None
    send_stage = march.make_stage(stage_name="send",
                                  pathId=0,
                                  pathStageId=3,
                                  stageId=3,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  epoll=False,
                                  ngx=False,
                                  net=True,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None,
                                  scaleFactor=0.3)

    read_path = march.make_code_path(
        pathId=0,
        prob=None,
        stages=[epoll_stage, socket_stage, read_stage, send_stage],
        priority=None)

    # write path
    recvTm = march.make_time_model("expo", [1500])
    respTm = None
    epoll_stage = march.make_stage(stage_name="epoll",
                                   pathId=1,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=True,
                                   socket=False,
                                   epoll=False,
                                   ngx=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None,
                                   scaleFactor=0.55)

    recvTm = march.make_time_model("expo", [1500])
    respTm = None
    socket_stage = march.make_stage(stage_name="socket",
                                    pathId=1,
                                    pathStageId=1,
                                    stageId=1,
                                    blocking=False,
                                    batching=True,
                                    socket=True,
                                    epoll=False,
                                    ngx=False,
                                    net=False,
                                    chunk=False,
                                    recvTm=recvTm,
                                    respTm=respTm,
                                    cm=None,
                                    criSec=False,
                                    threadLimit=None,
                                    scaleFactor=0.35)

    recvTm = march.make_time_model("expo", [800])
    respTm = None
    write_stage = march.make_stage(stage_name="proc_write",
                                   pathId=1,
                                   pathStageId=2,
                                   stageId=4,
                                   blocking=False,
                                   batching=False,
                                   socket=False,
                                   epoll=False,
                                   ngx=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None,
                                   scaleFactor=0.45)

    recvTm = march.make_time_model("expo", [7500])
    respTm = None
    send_stage = march.make_stage(stage_name="send",
                                  pathId=1,
                                  pathStageId=3,
                                  stageId=3,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  epoll=False,
                                  ngx=False,
                                  net=True,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None,
                                  scaleFactor=0.3)

    write_path = march.make_code_path(
        pathId=1,
        prob=None,
        stages=[epoll_stage, socket_stage, write_stage, send_stage],
        priority=None)

    # memcached
    memcached = march.make_micro_service(servType="micro_service",
                                         servName="memcached",
                                         bindConn=True,
                                         paths=[read_path, write_path],
                                         baseFreq=2600,
                                         curFreq=2600)

    with open("./json/microservice/memcached.json", "w+") as f:
        json.dump(memcached, f, indent=2)
Example #10
0
def main():
    # req path
    recvTm = march.make_time_model("expo", [1500])  # 1.5 us
    respTm = None
    epoll_stage = march.make_stage(stage_name="epoll",
                                   pathId=0,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=True,
                                   socket=False,
                                   epoll=True,
                                   ngx=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None,
                                   scaleFactor=0.55)

    recvTm = march.make_time_model("expo", [19000])
    respTm = None
    proc_req_stage = march.make_stage(stage_name="proc_req",
                                      pathId=0,
                                      pathStageId=1,
                                      stageId=1,
                                      blocking=False,
                                      batching=False,
                                      socket=False,
                                      epoll=False,
                                      ngx=True,
                                      net=True,
                                      chunk=False,
                                      recvTm=recvTm,
                                      respTm=respTm,
                                      cm=None,
                                      criSec=False,
                                      threadLimit=None,
                                      scaleFactor=0.4)

    req_path = march.make_code_path(pathId=0,
                                    prob=100,
                                    stages=[epoll_stage, proc_req_stage],
                                    priority=None)

    # resp path

    recvTm = march.make_time_model("expo", [19000])  # 19 us
    respTm = None
    proc_resp_stage = march.make_stage(stage_name="proc_resp",
                                       pathId=0,
                                       pathStageId=1,
                                       stageId=1,
                                       blocking=False,
                                       batching=False,
                                       socket=False,
                                       epoll=False,
                                       ngx=True,
                                       net=True,
                                       chunk=False,
                                       recvTm=recvTm,
                                       respTm=respTm,
                                       cm=None,
                                       criSec=False,
                                       threadLimit=None,
                                       scaleFactor=1.0)

    resp_path = march.make_code_path(pathId=1,
                                     prob=None,
                                     stages=[epoll_stage, proc_resp_stage],
                                     priority=None)

    # nginx
    nginx = march.make_micro_service(servType="micro_service",
                                     servName="nginx_frontend",
                                     bindConn=True,
                                     paths=[req_path],
                                     baseFreq=2600,
                                     curFreq=2600)

    with open("./json/microservice/nginx_frontend.json", "w+") as f:
        json.dump(nginx, f, indent=2)
Example #11
0
def main():
    # read path
    recvTm = march.make_time_model("expo", [1.5])
    respTm = None
    epoll_stage = march.make_stage(stage_name="epoll",
                                   pathId=0,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=True,
                                   socket=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None)

    recvTm = march.make_time_model("expo", [4.0])
    respTm = None
    socket_stage = march.make_stage(stage_name="socket",
                                    pathId=0,
                                    pathStageId=1,
                                    stageId=1,
                                    blocking=False,
                                    batching=True,
                                    socket=True,
                                    net=False,
                                    chunk=False,
                                    recvTm=recvTm,
                                    respTm=respTm,
                                    cm=None,
                                    criSec=False,
                                    threadLimit=None)

    recvTm = march.make_time_model("expo", [0.1])
    respTm = None
    read_stage = march.make_stage(stage_name="proc_read",
                                  pathId=0,
                                  pathStageId=2,
                                  stageId=2,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  net=False,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None)

    recvTm = march.make_time_model("expo", [4.5])
    respTm = None
    send_stage = march.make_stage(stage_name="send",
                                  pathId=0,
                                  pathStageId=3,
                                  stageId=3,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  net=True,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None)

    read_path = march.make_code_path(
        pathId=0,
        prob=1.0,
        stages=[epoll_stage, socket_stage, read_stage, send_stage],
        priority=None)

    # write path
    recvTm = march.make_time_model("expo", [1.5])
    respTm = None
    epoll_stage = march.make_stage(stage_name="epoll",
                                   pathId=1,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=True,
                                   socket=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None)

    recvTm = march.make_time_model("expo", [4.0])
    respTm = None
    socket_stage = march.make_stage(stage_name="socket",
                                    pathId=1,
                                    pathStageId=1,
                                    stageId=1,
                                    blocking=False,
                                    batching=True,
                                    socket=True,
                                    net=False,
                                    chunk=False,
                                    recvTm=recvTm,
                                    respTm=respTm,
                                    cm=None,
                                    criSec=False,
                                    threadLimit=None)

    recvTm = march.make_time_model("expo", [0.1])
    respTm = None
    write_stage = march.make_stage(stage_name="proc_write",
                                   pathId=1,
                                   pathStageId=2,
                                   stageId=4,
                                   blocking=False,
                                   batching=False,
                                   socket=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None)

    recvTm = march.make_time_model("expo", [4.5])
    respTm = None
    send_stage = march.make_stage(stage_name="send",
                                  pathId=1,
                                  pathStageId=3,
                                  stageId=3,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  net=True,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None)

    write_path = march.make_code_path(
        pathId=1,
        prob=0.0,
        stages=[epoll_stage, socket_stage, write_stage, send_stage],
        priority=None)

    # memcached
    memcached = march.make_micro_service(servType="micro_service",
                                         servName="memcached",
                                         bindConn=True,
                                         paths=[read_path, write_path])

    with open("./json/microservice/memcached.json", "w+") as f:
        json.dump(memcached, f, indent=2)
Example #12
0
def main():
    # cache hit path
    recvTm = march.make_time_model("expo", [75.0])
    respTm = None
    mem_hit_stage = march.make_stage(stage_name="mem_access_hit",
                                     pathId=0,
                                     pathStageId=0,
                                     stageId=0,
                                     blocking=False,
                                     batching=False,
                                     socket=False,
                                     net=True,
                                     chunk=False,
                                     recvTm=recvTm,
                                     respTm=respTm,
                                     cm=None,
                                     criSec=False,
                                     threadLimit=None)

    cache_hit_path = march.make_code_path(pathId=0,
                                          prob=None,
                                          stages=[mem_hit_stage],
                                          priority=None)

    # cache miss path
    recvTm = march.make_time_model("expo", [100.0])
    respTm = march.make_time_model("const", [10.0])
    mem_miss_stage = march.make_stage(stage_name="mem_access_miss",
                                      pathId=1,
                                      pathStageId=0,
                                      stageId=0,
                                      blocking=False,
                                      batching=False,
                                      socket=False,
                                      net=False,
                                      chunk=False,
                                      recvTm=recvTm,
                                      respTm=respTm,
                                      cm=None,
                                      criSec=False,
                                      threadLimit=None)

    recvTm = march.make_time_model("const", [0.0])
    respTm = march.make_time_model("expo", [100.0])
    chkm = march.make_chunk_model("expo", [3])
    io_stage = march.make_stage(stage_name="io",
                                pathId=1,
                                pathStageId=1,
                                stageId=1,
                                blocking=True,
                                batching=False,
                                socket=False,
                                net=False,
                                chunk=True,
                                recvTm=recvTm,
                                respTm=respTm,
                                cm=chkm,
                                criSec=False,
                                threadLimit=None)

    recvTm = march.make_time_model("expo", [80.0])
    respTm = None
    mem_fill_stage = march.make_stage(stage_name="mem_fill",
                                      pathId=1,
                                      pathStageId=2,
                                      stageId=2,
                                      blocking=False,
                                      batching=False,
                                      socket=False,
                                      net=True,
                                      chunk=False,
                                      recvTm=recvTm,
                                      respTm=respTm,
                                      cm=None,
                                      criSec=False,
                                      threadLimit=None)

    cache_miss_path = march.make_code_path(
        pathId=1,
        prob=None,
        stages=[mem_miss_stage, io_stage, mem_fill_stage],
        priority=None)

    # mongodb
    mongodb = march.make_micro_service(servType="micro_service",
                                       servName="mongodb",
                                       bindConn=True,
                                       paths=[cache_hit_path, cache_miss_path])

    with open("./json/microservice/mongodb.json", "w+") as f:
        json.dump(mongodb, f, indent=2)
Example #13
0
def main():
    # sock recv
    recvTm = march.make_time_model("expo", [3000])
    respTm = None
    recv_stage = march.make_stage(stage_name="sock_recv",
                                  pathId=0,
                                  pathStageId=0,
                                  stageId=0,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  epoll=False,
                                  ngx=False,
                                  scaleFactor=0.0,
                                  net=False,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None,
                                  useHist=False)

    # cache hit path
    recvTm = march.make_time_model("expo", [75000])
    respTm = None
    cache_hit_stage = march.make_stage(stage_name="proc_cache_hit",
                                       pathId=0,
                                       pathStageId=1,
                                       stageId=1,
                                       blocking=False,
                                       batching=False,
                                       socket=False,
                                       epoll=False,
                                       ngx=False,
                                       scaleFactor=0.0,
                                       net=True,
                                       chunk=False,
                                       recvTm=recvTm,
                                       respTm=respTm,
                                       cm=None,
                                       criSec=False,
                                       threadLimit=None,
                                       useHist=False)

    cache_hit_path = march.make_code_path(pathId=0,
                                          prob=None,
                                          stages=[recv_stage, cache_hit_stage],
                                          priority=None)

    # cache miss path
    recvTm = march.make_time_model("expo", [3000])
    respTm = None
    recv_stage = march.make_stage(stage_name="sock_recv",
                                  pathId=1,
                                  pathStageId=0,
                                  stageId=2,
                                  blocking=False,
                                  batching=False,
                                  socket=False,
                                  epoll=False,
                                  ngx=False,
                                  scaleFactor=0.0,
                                  net=False,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None,
                                  useHist=False)

    recvTm = march.make_time_model("expo", [100000])
    mem_miss_stage = march.make_stage(stage_name="assemble_cache_miss",
                                      pathId=1,
                                      pathStageId=1,
                                      stageId=3,
                                      blocking=True,
                                      batching=False,
                                      socket=False,
                                      epoll=False,
                                      ngx=False,
                                      scaleFactor=0.0,
                                      net=False,
                                      chunk=False,
                                      recvTm=recvTm,
                                      respTm=None,
                                      cm=None,
                                      criSec=False,
                                      threadLimit=None,
                                      useHist=False)

    recvTm = march.make_time_model("expo", [100000])
    io_stage = march.make_stage(stage_name="proc_cache_miss",
                                pathId=1,
                                pathStageId=2,
                                stageId=4,
                                blocking=False,
                                batching=False,
                                socket=False,
                                epoll=False,
                                ngx=False,
                                scaleFactor=0.0,
                                net=True,
                                chunk=False,
                                recvTm=recvTm,
                                respTm=None,
                                cm=None,
                                criSec=False,
                                threadLimit=None,
                                useHist=False)

    # recvTm = march.make_time_model("expo", [80.0])
    # respTm = None
    # mem_fill_stage = march.make_stage(stage_name = "mem_fill", pathId = 1, pathStageId = 2, stageId = 2, blocking = False, batching = False, socket = False,
    # 	net = True, chunk = False, recvTm = recvTm, respTm = None, cm = None, criSec = False, threadLimit = None)

    cache_miss_path = march.make_code_path(
        pathId=1,
        prob=None,
        stages=[recv_stage, mem_miss_stage, io_stage],
        priority=None)

    # mongodb
    mongodb = march.make_micro_service(servType="micro_service",
                                       servName="mongodb",
                                       bindConn=True,
                                       paths=[cache_hit_path, cache_miss_path],
                                       baseFreq=2600,
                                       curFreq=2600)

    with open("./json/microservice/mongodb.json", "w+") as f:
        json.dump(mongodb, f, indent=2)
Example #14
0
def main():
    # req path
    recvTm = march.make_time_model("expo", [1.5])
    respTm = None
    epoll_stage = march.make_stage(stage_name="epoll",
                                   pathId=0,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=True,
                                   socket=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None)

    recvTm = march.make_time_model("expo", [2.0])
    respTm = None
    socket_stage = march.make_stage(stage_name="socket",
                                    pathId=0,
                                    pathStageId=1,
                                    stageId=1,
                                    blocking=False,
                                    batching=True,
                                    socket=True,
                                    net=False,
                                    chunk=False,
                                    recvTm=recvTm,
                                    respTm=respTm,
                                    cm=None,
                                    criSec=False,
                                    threadLimit=None)

    recvTm = march.make_time_model("expo", [40.0])
    respTm = None
    req_stage = march.make_stage(stage_name="proc_req",
                                 pathId=0,
                                 pathStageId=2,
                                 stageId=2,
                                 blocking=False,
                                 batching=False,
                                 socket=False,
                                 net=True,
                                 chunk=False,
                                 recvTm=recvTm,
                                 respTm=respTm,
                                 cm=None,
                                 criSec=False,
                                 threadLimit=None)

    req_path = march.make_code_path(
        pathId=0,
        prob=None,
        stages=[epoll_stage, socket_stage, req_stage],
        priority=None)

    # mmc path
    recvTm = march.make_time_model("expo", [1.5])
    respTm = None
    epoll_stage = march.make_stage(stage_name="epoll",
                                   pathId=1,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=True,
                                   socket=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None)

    recvTm = march.make_time_model("expo", [2.0])
    respTm = None
    socket_stage = march.make_stage(stage_name="socket",
                                    pathId=1,
                                    pathStageId=1,
                                    stageId=1,
                                    blocking=False,
                                    batching=True,
                                    socket=True,
                                    net=False,
                                    chunk=False,
                                    recvTm=recvTm,
                                    respTm=respTm,
                                    cm=None,
                                    criSec=False,
                                    threadLimit=None)

    recvTm = march.make_time_model("expo", [40.0])
    respTm = None
    mmc_stage = march.make_stage(stage_name="proc_mmc",
                                 pathId=1,
                                 pathStageId=2,
                                 stageId=3,
                                 blocking=False,
                                 batching=False,
                                 socket=False,
                                 net=True,
                                 chunk=False,
                                 recvTm=recvTm,
                                 respTm=respTm,
                                 cm=None,
                                 criSec=False,
                                 threadLimit=None)

    mmc_path = march.make_code_path(
        pathId=1,
        prob=None,
        stages=[epoll_stage, socket_stage, mmc_stage],
        priority=None)

    # php path
    recvTm = march.make_time_model("expo", [1.5])
    respTm = None
    epoll_stage = march.make_stage(stage_name="epoll",
                                   pathId=2,
                                   pathStageId=0,
                                   stageId=0,
                                   blocking=False,
                                   batching=True,
                                   socket=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None)

    recvTm = march.make_time_model("expo", [2.0])
    respTm = None
    socket_stage = march.make_stage(stage_name="socket",
                                    pathId=2,
                                    pathStageId=1,
                                    stageId=1,
                                    blocking=False,
                                    batching=True,
                                    socket=True,
                                    net=False,
                                    chunk=False,
                                    recvTm=recvTm,
                                    respTm=respTm,
                                    cm=None,
                                    criSec=False,
                                    threadLimit=None)

    recvTm = march.make_time_model("expo", [20.0])
    respTm = None
    php_stage = march.make_stage(stage_name="proc_php",
                                 pathId=2,
                                 pathStageId=2,
                                 stageId=4,
                                 blocking=False,
                                 batching=False,
                                 socket=False,
                                 net=True,
                                 chunk=False,
                                 recvTm=recvTm,
                                 respTm=respTm,
                                 cm=None,
                                 criSec=False,
                                 threadLimit=None)

    php_path = march.make_code_path(
        pathId=2,
        prob=None,
        stages=[epoll_stage, socket_stage, php_stage],
        priority=None)

    # nginx
    nginx = march.make_micro_service(servType="micro_service",
                                     servName="nginx",
                                     bindConn=True,
                                     paths=[req_path, mmc_path, php_path])

    with open("./json/microservice/nginx.json", "w+") as f:
        json.dump(nginx, f, indent=2)
Example #15
0
def main():
    # read path
    # fcgi_req, goes to php_io
    recvTm = march.make_time_model("expo", [40.0])
    respTm = march.make_time_model("expo", [40.0])
    fcgi_req_stage = march.make_stage(stage_name="php_fcgi_req",
                                      pathId=0,
                                      pathStageId=0,
                                      stageId=0,
                                      blocking=True,
                                      batching=False,
                                      socket=False,
                                      net=False,
                                      chunk=False,
                                      recvTm=recvTm,
                                      respTm=respTm,
                                      cm=None,
                                      criSec=False,
                                      threadLimit=None)

    # fopen, goes to php_io
    recvTm = march.make_time_model("expo", [48.0])
    respTm = march.make_time_model("expo", [48.0])
    fopen_stage = march.make_stage(stage_name="php_fopen_req",
                                   pathId=0,
                                   pathStageId=1,
                                   stageId=1,
                                   blocking=True,
                                   batching=False,
                                   socket=False,
                                   net=False,
                                   chunk=False,
                                   recvTm=recvTm,
                                   respTm=respTm,
                                   cm=None,
                                   criSec=False,
                                   threadLimit=None)

    # fput, goes to mongo
    recvTm = march.make_time_model("expo", [40.0])
    respTm = march.make_time_model("expo", [40.0])
    fput_stage = march.make_stage(stage_name="php_fput",
                                  pathId=0,
                                  pathStageId=2,
                                  stageId=2,
                                  blocking=True,
                                  batching=False,
                                  socket=False,
                                  net=True,
                                  chunk=False,
                                  recvTm=recvTm,
                                  respTm=respTm,
                                  cm=None,
                                  criSec=False,
                                  threadLimit=None)

    # find_done, goes to mongo
    recvTm = march.make_time_model("expo", [40.0])
    respTm = march.make_time_model("expo", [40.0])
    find_done_stage = march.make_stage(stage_name="php_find_done",
                                       pathId=0,
                                       pathStageId=3,
                                       stageId=3,
                                       blocking=True,
                                       batching=False,
                                       socket=False,
                                       net=True,
                                       chunk=False,
                                       recvTm=recvTm,
                                       respTm=respTm,
                                       cm=None,
                                       criSec=False,
                                       threadLimit=None)

    # get_bytes, goes to memcached
    recvTm = march.make_time_model("expo", [40.0])
    respTm = march.make_time_model("expo", [40.0])
    get_bytes_stage = march.make_stage(stage_name="php_get_bytes",
                                       pathId=0,
                                       pathStageId=4,
                                       stageId=4,
                                       blocking=True,
                                       batching=False,
                                       socket=False,
                                       net=True,
                                       chunk=False,
                                       recvTm=recvTm,
                                       respTm=respTm,
                                       cm=None,
                                       criSec=False,
                                       threadLimit=None)

    # mmc_store, goes to nginx
    recvTm = march.make_time_model("expo", [40.0])
    respTm = march.make_time_model("expo", [40.0])
    mmc_store_stage = march.make_stage(stage_name="php_mmc_store",
                                       pathId=0,
                                       pathStageId=5,
                                       stageId=5,
                                       blocking=True,
                                       batching=False,
                                       socket=False,
                                       net=True,
                                       chunk=False,
                                       recvTm=recvTm,
                                       respTm=respTm,
                                       cm=None,
                                       criSec=False,
                                       threadLimit=None)

    path = march.make_code_path(pathId=0,
                                prob=1.0,
                                stages=[
                                    fcgi_req_stage, fopen_stage, fput_stage,
                                    find_done_stage, get_bytes_stage,
                                    mmc_store_stage
                                ],
                                priority=None)

    php = march.make_micro_service(servType="micro_service",
                                   servName="php",
                                   bindConn=False,
                                   paths=[path])

    with open("./json/microservice/php.json", "w+") as f:
        json.dump(php, f, indent=2)