tools/mdsal_benchmark/rpcbenchmark.py

   1 #!/usr/bin/python
   2 ##############################################################################
   3 # Copyright (c) 2015 Cisco Systems  All rights reserved.
   4 #
   5 # This program and the accompanying materials are made available under the
   6 # terms of the Eclipse Public License v1.0 which accompanies this distribution,
   7 # and is available at http://www.eclipse.org/legal/epl-v10.html
   8 ##############################################################################
   9
  10 import argparse
  11 import requests
  12 import json
  13 import csv
  14
  15
  16 __author__ = "Jan Medved"
  17 __copyright__ = "Copyright(c) 2015, Cisco Systems, Inc."
  18 __license__ = "Eclipse Public License v1.0"
  19 __email__ = "jmedved@cisco.com"
  20
  21
  22 global BASE_URL
  23
  24
  25 def send_test_request(operation, clients, servers, payload_size, iterations):
  26     """
  27     Sends a request to the rpcbenchmark app to start a data store benchmark test run.
  28     The rpcbenchmark app will perform the requested benchmark test and return measured
  29     test execution time and RPC throughput
  30
  31     :param operation: operation type
  32     :param clients: number of simulated RPC clients
  33     :param servers: Number of simulated RPC servers if operation type is ROUTED-***
  34     :param payload_size: Payload size for the test RPCs
  35     :param iterations: Number of iterations to run
  36     :return: Result from the test request REST call (json)
  37     """
  38     url = BASE_URL + "operations/rpcbenchmark:start-test"
  39     postheaders = {'content-type': 'application/json', 'Accept': 'application/json'}
  40
  41     test_request_template = '''{
  42         "input": {
  43             "operation": "%s",
  44             "num-clients": "%s",
  45             "num-servers": "%s",
  46             "payload-size": "%s",
  47             "iterations": "%s"
  48         }
  49     }'''
  50     data = test_request_template % (operation, clients, servers, payload_size, iterations)
  51     r = requests.post(url, data, headers=postheaders, stream=False, auth=('admin', 'admin'))
  52     result = {u'http-status': r.status_code}
  53     if r.status_code == 200:
  54         result = dict(result.items() + json.loads(r.content)['output'].items())
  55     else:
  56         print 'Error %s, %s' % (r.status_code, r.content)
  57     return result
  58
  59
  60 def print_results(run_type, idx, res):
  61     """
  62     Prints results from a dsbenchmakr test run to console
  63     :param run_type: String parameter that can be used to identify the type of the
  64                      test run (e.g. WARMUP or TEST)
  65     :param idx: Index of the test run
  66     :param res: Parsed json (disctionary) that was returned from a dsbenchmark
  67                 test run
  68     :return: None
  69     """
  70     print '%s #%d: Ok: %d, Error: %d, Rate: %d, Exec time: %d' % \
  71           (run_type, idx,
  72            res[u'global-rtc-client-ok'], res[u'global-rtc-client-error'], res[u'rate'], res[u'exec-time'])
  73
  74
  75 def run_test(warmup_runs, test_runs, operation, clients, servers, payload_size, iterations):
  76     """
  77     Execute a benchmark test. Performs the JVM 'wamrup' before the test, runs
  78     the specified number of dsbenchmark test runs and computes the average time
  79     for building the test data (a list of lists) and the average time for the
  80     execution of the test.
  81     :param warmup_runs: # of warmup runs
  82     :param test_runs: # of test runs
  83     :param operation: PUT, MERGE or DELETE
  84     :param data_fmt: BINDING-AWARE or BINDING-INDEPENDENT
  85     :param outer_elem: Number of elements in the outer list
  86     :param inner_elem: Number of elements in the inner list
  87     :param ops_per_tx: Number of operations (PUTs, MERGEs or DELETEs) on each transaction
  88     :return: average build time AND average test execution time
  89     """
  90     total_exec_time = 0.0
  91     total_rate = 0.0
  92
  93     for idx in range(warmup_runs):
  94         res = send_test_request(operation, clients, servers, payload_size, iterations)
  95         print_results('WARM-UP', idx, res)
  96
  97     for idx in range(test_runs):
  98         res = send_test_request(operation, clients, servers, payload_size, iterations)
  99         print_results('TEST', idx, res)
 100         total_exec_time += res['exec-time']
 101         total_rate += res['rate']
 102
 103     return total_exec_time / test_runs, total_rate / test_runs
 104
 105
 106 if __name__ == "__main__":
 107     parser = argparse.ArgumentParser(description='RPC Benchmarking')
 108
 109     # Host Config
 110     parser.add_argument("--host", default="localhost", help="IP of the target host where benchmarks will be run.")
 111     parser.add_argument("--port", type=int, default=8181, help="The port number of target host.")
 112
 113     # Test Parameters
 114     parser.add_argument("--operation", choices=["GLOBAL-RTC", "ROUTED-RTC"], default='GLOBAL-RTC',
 115                         help='RPC and client type. RPC can be global or routcan be run-to-completion (RTC).'
 116                              '(default: GLOBAL-RTC - Global RPC, Run-to-completion client)')
 117     parser.add_argument("--warm", type=int, default=10, help='The number of warm-up runs before the measured test runs'
 118                                                              '(Default 10)')
 119     parser.add_argument("--run", type=int, default=10,
 120                         help='The number of measured test runs. Reported results are based on these average of all'
 121                              " measured runs. (Default 10)")
 122     parser.add_argument("--clients", type=int, nargs='+', default=[1, 2, 4, 8, 16, 32, 64],
 123                         help='The number of test RPC clients to start. (Default 10)')
 124     parser.add_argument("--servers", type=int, nargs='+', default=[1, 2, 4, 8, 16, 32, 64],
 125                         help='The number of routed RPC servers to start in the routed RPC test. Ignored in the global '
 126                              'RPC test. (Default 10)')
 127     parser.add_argument("--iterations", type=int, default=10, help='The number requests that each RPC client issues '
 128                                                                    'during the test run. (Default 10)')
 129     parser.add_argument("--payload", type=int, default=10, help='Payload size for the RPC - number of elements in a '
 130                                                                 'simple integer list. (Default 10)')
 131
 132     args = parser.parse_args()
 133     BASE_URL = "http://%s:%d/restconf/" % (args.host, args.port)
 134
 135     if args.operation == 'GLOBAL-RTC':
 136         servers = [1]
 137     else:
 138         servers = args.servers
 139
 140     # Run the benchmark tests and collect data in a csv file for import into a graphing software
 141     f = open('test.csv', 'wt')
 142     try:
 143         writer = csv.writer(f)
 144         rate_matrix = []
 145
 146         for svr in servers:
 147             rate_row = ['']
 148             for client in args.clients:
 149                 exec_time, rate = \
 150                     run_test(args.warm, args.run, args.operation, client, svr, args.payload, args.iterations)
 151                 rate_row.append(rate)
 152             rate_matrix.append(rate_row)
 153         print rate_matrix
 154
 155         writer.writerow(('RPC Rates:', ''))
 156         writer.writerows(rate_matrix)
 157     finally:
 158         f.close()