Chiebot-Mirror
/
grpc
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add some more scenarios

Browse Source
pull/6462/head
Jan Tattermusch 9 years ago
parent e8ca2acb38
commit d7b162f601
1 changed files with 319 additions and 504 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 823
      tools/run_tests/performance/scenario_config.py

823
tools/run_tests/performance/scenario_config.py
Unescape View File

@ -69,6 +69,75 @@ DEEP=100
WIDE=64 WIDE=64
def _get_secargs(is_secure):
if is_secure:
return SECURE_SECARGS
else:
return None
def _ping_pong_scenario(name, rpc_type,
client_type, server_type,
secure=True,
use_generic_payload=False,
use_unconstrained_client=False,
server_language=None,
server_core_limit=0,
async_server_threads=0,
warmup_seconds=WARMUP_SECONDS):
"""Creates a basic ping pong scenario."""
scenario = {
'name': name,
'num_servers': 1,
'num_clients': 1,
'client_config': {
'client_type': client_type,
'security_params': _get_secargs(secure),
'outstanding_rpcs_per_channel': 1,
'client_channels': 1,
'async_client_threads': 1,
'rpc_type': rpc_type,
'load_params': {
'closed_loop': {}
},
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': server_type,
'security_params': _get_secargs(secure),
'core_limit': server_core_limit,
'async_server_threads': async_server_threads,
},
'warmup_seconds': warmup_seconds,
'benchmark_seconds': BENCHMARK_SECONDS
}
if use_generic_payload:
if server_type != 'ASYNC_GENERIC_SERVER':
raise Exception('Use ASYNC_GENERIC_SERVER for generic payload.')
scenario['client_config']['payload_config'] = EMPTY_GENERIC_PAYLOAD
scenario['server_config']['payload_config'] = EMPTY_GENERIC_PAYLOAD
else:
# For proto payload, only the client should get the config.
scenario['client_config']['payload_config'] = EMPTY_PROTO_PAYLOAD
if use_unconstrained_client:
scenario['num_clients'] = 0 # use as many client as available.
# TODO(jtattermusch): for SYNC_CLIENT, this will create 100*64 threads
# and that's probably too much (at least for wrapped languages).
scenario['client_config']['outstanding_rpcs_per_channel'] = DEEP
scenario['client_config']['client_channels'] = WIDE
scenario['client_config']['async_client_threads'] = 0
else:
scenario['client_config']['outstanding_rpcs_per_channel'] = 1
scenario['client_config']['client_channels'] = 1
scenario['client_config']['async_client_threads'] = 1
if server_language:
# the SERVER_LANGUAGE field is recognized by run_performance_tests.py
scenario['SERVER_LANGUAGE'] = server_language
return scenario
class CXXLanguage: class CXXLanguage:
def __init__(self): def __init__(self):
@ -83,205 +152,59 @@ class CXXLanguage:
def scenarios(self): def scenarios(self):
# TODO(ctiller): add 70% load latency test # TODO(ctiller): add 70% load latency test
for secure in [True, False]: for secure in [True, False]:
if secure: secstr = 'secure' if secure else 'insecure'
secstr = 'secure'
secargs = SECURE_SECARGS yield _ping_pong_scenario(
else: 'cpp_generic_async_streaming_ping_pong_%s' % secstr, rpc_type='STREAMING',
secstr = 'insecure' client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
secargs = None use_generic_payload=True, server_core_limit=1, async_server_threads=1,
secure=secure)
yield {
'name': 'cpp_generic_async_streaming_ping_pong_%s' yield _ping_pong_scenario(
% secstr, 'cpp_protobuf_async_streaming_ping_pong_%s' % secstr, rpc_type='STREAMING',
'num_servers': 1, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'num_clients': 1, server_core_limit=1, async_server_threads=1,
'client_config': { secure=secure)
'client_type': 'ASYNC_CLIENT',
'security_params': secargs, yield _ping_pong_scenario(
'outstanding_rpcs_per_channel': 1, 'cpp_protobuf_async_unary_ping_pong_%s' % secstr, rpc_type='UNARY',
'client_channels': 1, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'async_client_threads': 1, server_core_limit=1, async_server_threads=1,
'rpc_type': 'STREAMING', secure=secure)
'load_params': {
'closed_loop': {} yield _ping_pong_scenario(
}, 'cpp_protobuf_sync_unary_ping_pong_%s' % secstr, rpc_type='UNARY',
'payload_config': EMPTY_GENERIC_PAYLOAD, client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
'histogram_params': HISTOGRAM_PARAMS, server_core_limit=1, async_server_threads=1,
}, secure=secure)
'server_config': {
'server_type': 'ASYNC_GENERIC_SERVER', yield _ping_pong_scenario(
'security_params': secargs, 'cpp_protobuf_async_unary_qps_unconstrained_%s' % secstr, rpc_type='UNARY',
'core_limit': 1, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'async_server_threads': 1, server_core_limit=SINGLE_MACHINE_CORES/2,
'payload_config': EMPTY_GENERIC_PAYLOAD, use_unconstrained_client=True,
}, secure=secure)
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS yield _ping_pong_scenario(
} 'cpp_protobuf_async_streaming_qps_unconstrained_%s' % secstr, rpc_type='STREAMING',
yield { client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'name': 'cpp_generic_async_streaming_qps_unconstrained_%s' server_core_limit=SINGLE_MACHINE_CORES/2,
% secstr, use_unconstrained_client=True,
'num_servers': 1, secure=secure)
'num_clients': 0,
'client_config': { yield _ping_pong_scenario(
'client_type': 'ASYNC_CLIENT', 'cpp_generic_async_streaming_qps_unconstrained_%s' % secstr, rpc_type='STREAMING',
'security_params': secargs, client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
'outstanding_rpcs_per_channel': DEEP, use_unconstrained_client=True, use_generic_payload=True,
'client_channels': WIDE, server_core_limit=SINGLE_MACHINE_CORES/2,
'async_client_threads': 0, secure=secure)
'rpc_type': 'STREAMING',
'load_params': { yield _ping_pong_scenario(
'closed_loop': {} 'cpp_generic_async_streaming_qps_one_server_core_%s' % secstr, rpc_type='STREAMING',
}, client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
'payload_config': EMPTY_GENERIC_PAYLOAD, use_unconstrained_client=True, use_generic_payload=True,
'histogram_params': HISTOGRAM_PARAMS, server_core_limit=1, async_server_threads=1,
}, secure=secure)
'server_config': {
'server_type': 'ASYNC_GENERIC_SERVER',
'security_params': secargs,
'core_limit': SINGLE_MACHINE_CORES/2,
'async_server_threads': 0,
'payload_config': EMPTY_GENERIC_PAYLOAD,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS
}
yield {
'name': 'cpp_generic_async_streaming_qps_one_server_core_%s'
% secstr,
'num_servers': 1,
'num_clients': 0,
'client_config': {
'client_type': 'ASYNC_CLIENT',
'security_params': secargs,
'outstanding_rpcs_per_channel': DEEP,
'client_channels': WIDE,
'async_client_threads': 0,
'rpc_type': 'STREAMING',
'load_params': {
'closed_loop': {}
},
'payload_config': EMPTY_GENERIC_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'ASYNC_GENERIC_SERVER',
'security_params': secargs,
'core_limit': 1,
'async_server_threads': 1,
'payload_config': EMPTY_GENERIC_PAYLOAD,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS
}
yield {
'name': 'cpp_protobuf_async_streaming_qps_unconstrained_%s'
% secstr,
'num_servers': 1,
'num_clients': 0,
'client_config': {
'client_type': 'ASYNC_CLIENT',
'security_params': secargs,
'outstanding_rpcs_per_channel': DEEP,
'client_channels': WIDE,
'async_client_threads': 0,
'rpc_type': 'STREAMING',
'load_params': {
'closed_loop': {}
},
'payload_config': EMPTY_PROTO_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'ASYNC_SERVER',
'security_params': secargs,
'core_limit': SINGLE_MACHINE_CORES/2,
'async_server_threads': 0,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS
}
yield {
'name': 'cpp_protobuf_async_streaming_ping_pong_%s'
% secstr,
'num_servers': 1,
'num_clients': 1,
'client_config': {
'client_type': 'ASYNC_CLIENT',
'security_params': secargs,
'outstanding_rpcs_per_channel': 1,
'client_channels': 1,
'async_client_threads': 1,
'rpc_type': 'STREAMING',
'load_params': {
'closed_loop': {}
},
'payload_config': EMPTY_PROTO_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'ASYNC_SERVER',
'security_params': secargs,
'core_limit': 1,
'async_server_threads': 1,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS
}
yield {
'name': 'cpp_protobuf_sync_unary_ping_pong_%s'
% secstr,
'num_servers': 1,
'num_clients': 1,
'client_config': {
'client_type': 'SYNC_CLIENT',
'security_params': secargs,
'outstanding_rpcs_per_channel': 1,
'client_channels': 1,
'async_client_threads': 0,
'rpc_type': 'UNARY',
'load_params': {
'closed_loop': {}
},
'payload_config': EMPTY_PROTO_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'SYNC_SERVER',
'security_params': secargs,
'core_limit': 1,
'async_server_threads': 0,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS
}
yield {
'name': 'cpp_protobuf_async_unary_ping_pong_%s'
% secstr,
'num_servers': 1,
'num_clients': 1,
'client_config': {
'client_type': 'ASYNC_CLIENT',
'security_params': secargs,
'outstanding_rpcs_per_channel': 1,
'client_channels': 1,
'async_client_threads': 1,
'rpc_type': 'UNARY',
'load_params': {
'closed_loop': {}
},
'payload_config': EMPTY_PROTO_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'ASYNC_SERVER',
'security_params': secargs,
'core_limit': 1,
'async_server_threads': 1,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS
}
def __str__(self): def __str__(self):
return 'c++' return 'c++'
@ -299,113 +222,42 @@ class CSharpLanguage:
return 100 return 100
def scenarios(self): def scenarios(self):
secargs = SECURE_SECARGS yield _ping_pong_scenario(
yield { 'csharp_generic_async_streaming_ping_pong', rpc_type='STREAMING',
'name': 'csharp_generic_async_streaming_ping_pong', client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
'num_servers': 1, use_generic_payload=True)
'num_clients': 1,
'client_config': { yield _ping_pong_scenario(
'client_type': 'ASYNC_CLIENT', 'csharp_protobuf_async_streaming_ping_pong', rpc_type='STREAMING',
'security_params': secargs, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER')
'outstanding_rpcs_per_channel': 1,
'client_channels': 1, yield _ping_pong_scenario(
'async_client_threads': 1, 'csharp_protobuf_async_unary_ping_pong', rpc_type='UNARY',
'rpc_type': 'STREAMING', client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER')
'load_params': {
'closed_loop': {} yield _ping_pong_scenario(
}, 'csharp_protobuf_sync_to_async_unary_ping_pong', rpc_type='UNARY',
'payload_config': EMPTY_GENERIC_PAYLOAD, client_type='SYNC_CLIENT', server_type='ASYNC_SERVER')
'histogram_params': HISTOGRAM_PARAMS,
}, yield _ping_pong_scenario(
'server_config': { 'csharp_protobuf_async_unary_qps_unconstrained', rpc_type='UNARY',
'server_type': 'ASYNC_GENERIC_SERVER', client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'security_params': secargs, use_unconstrained_client=True)
'core_limit': 0,
'async_server_threads': 0, yield _ping_pong_scenario(
'payload_config': EMPTY_GENERIC_PAYLOAD, 'csharp_protobuf_async_streaming_qps_unconstrained', rpc_type='STREAMING',
}, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'warmup_seconds': WARMUP_SECONDS, use_unconstrained_client=True)
'benchmark_seconds': BENCHMARK_SECONDS
} yield _ping_pong_scenario(
yield { 'csharp_to_cpp_protobuf_sync_unary_ping_pong', rpc_type='UNARY',
'name': 'csharp_protobuf_async_unary_ping_pong', client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
'num_servers': 1, server_language='c++', server_core_limit=1, async_server_threads=1)
'num_clients': 1,
'client_config': { yield _ping_pong_scenario(
'client_type': 'ASYNC_CLIENT', 'csharp_to_cpp_protobuf_async_streaming_ping_pong', rpc_type='STREAMING',
'security_params': secargs, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'outstanding_rpcs_per_channel': 1, server_language='c++', server_core_limit=1, async_server_threads=1)
'client_channels': 1,
'async_client_threads': 1,
'rpc_type': 'UNARY',
'load_params': {
'closed_loop': {}
},
'payload_config': EMPTY_PROTO_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'ASYNC_SERVER',
'security_params': secargs,
'core_limit': 0,
'async_server_threads': 0,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS
}
yield {
'name': 'csharp_protobuf_sync_to_async_unary_ping_pong',
'num_servers': 1,
'num_clients': 1,
'client_config': {
'client_type': 'SYNC_CLIENT',
'security_params': secargs,
'outstanding_rpcs_per_channel': 1,
'client_channels': 1,
'async_client_threads': 1,
'rpc_type': 'UNARY',
'load_params': {
'closed_loop': {}
},
'payload_config': EMPTY_PROTO_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'ASYNC_SERVER',
'security_params': secargs,
'core_limit': 0,
'async_server_threads': 0,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS
}
yield {
'name': 'csharp_to_cpp_protobuf_sync_unary_ping_pong',
'num_servers': 1,
'num_clients': 1,
'client_config': {
'client_type': 'SYNC_CLIENT',
'security_params': secargs,
'outstanding_rpcs_per_channel': 1,
'client_channels': 1,
'async_client_threads': 1,
'rpc_type': 'UNARY',
'load_params': {
'closed_loop': {}
},
'payload_config': EMPTY_PROTO_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'SYNC_SERVER',
'security_params': secargs,
'core_limit': 1,
'async_server_threads': 1,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS,
'SERVER_LANGUAGE': 'c++' # recognized by run_performance_tests.py
}
def __str__(self): def __str__(self):
return 'csharp' return 'csharp'
@ -424,34 +276,43 @@ class NodeLanguage:
return 200 return 200
def scenarios(self): def scenarios(self):
# TODO(jtattermusch): add more scenarios # TODO(jtattermusch): make this scenario work
secargs = SECURE_SECARGS #yield _ping_pong_scenario(
yield { # 'node_generic_async_streaming_ping_pong', rpc_type='STREAMING',
'name': 'node_protobuf_unary_ping_pong', # client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
'num_servers': 1, # use_generic_payload=True)
'num_clients': 1,
'client_config': { # TODO(jtattermusch): make this scenario work
'client_type': 'ASYNC_CLIENT', #yield _ping_pong_scenario(
'security_params': secargs, # 'node_protobuf_async_streaming_ping_pong', rpc_type='STREAMING',
'outstanding_rpcs_per_channel': 1, # client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER')
'client_channels': 1,
'async_client_threads': 1, yield _ping_pong_scenario(
'rpc_type': 'UNARY', 'node_protobuf_unary_ping_pong', rpc_type='UNARY',
'load_params': { client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER')
'closed_loop': {}
}, yield _ping_pong_scenario(
'payload_config': EMPTY_PROTO_PAYLOAD, 'node_protobuf_async_unary_qps_unconstrained', rpc_type='UNARY',
'histogram_params': HISTOGRAM_PARAMS, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
}, use_unconstrained_client=True)
'server_config': {
'server_type': 'ASYNC_SERVER', # TODO(jtattermusch): make this scenario work
'security_params': secargs, #yield _ping_pong_scenario(
'core_limit': 0, # 'node_protobuf_async_streaming_qps_unconstrained', rpc_type='STREAMING',
'async_server_threads': 1, # client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
}, # use_unconstrained_client=True)
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS # TODO(jtattermusch): make this scenario work
} #yield _ping_pong_scenario(
# 'node_to_cpp_protobuf_async_unary_ping_pong', rpc_type='UNARY',
# client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
# server_language='c++', server_core_limit=1, async_server_threads=1)
# TODO(jtattermusch): make this scenario work
#yield _ping_pong_scenario(
# 'node_to_cpp_protobuf_async_streaming_ping_pong', rpc_type='STREAMING',
# client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
# server_language='c++', server_core_limit=1, async_server_threads=1)
def __str__(self): def __str__(self):
return 'node' return 'node'
@ -468,114 +329,49 @@ class PythonLanguage:
return 500 return 500
def scenarios(self): def scenarios(self):
yield { # TODO(jtattermusch): this scenario reports QPS 0.0
'name': 'python_to_cpp_protobuf_streaming_ping_pong', yield _ping_pong_scenario(
'num_servers': 1, 'python_generic_async_streaming_ping_pong', rpc_type='STREAMING',
'num_clients': 1, client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
'client_config': { use_generic_payload=True)
'client_type': 'ASYNC_CLIENT',
'security_params': SECURE_SECARGS, # TODO(jtattermusch): make this scenario work
'outstanding_rpcs_per_channel': 1, #yield _ping_pong_scenario(
'client_channels': 1, # 'python_protobuf_async_streaming_ping_pong', rpc_type='STREAMING',
'async_client_threads': 1, # client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER')
'rpc_type': 'STREAMING',
'load_params': { # TODO(jtattermusch): make this scenario work
'closed_loop': {} #yield _ping_pong_scenario(
}, # 'python_protobuf_async_unary_ping_pong', rpc_type='UNARY',
'payload_config': EMPTY_PROTO_PAYLOAD, # client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER')
'histogram_params': HISTOGRAM_PARAMS,
}, yield _ping_pong_scenario(
'server_config': { 'python_protobuf_sync_unary_ping_pong', rpc_type='UNARY',
'server_type': 'SYNC_SERVER', client_type='SYNC_CLIENT', server_type='SYNC_SERVER')
'security_params': SECURE_SECARGS,
'core_limit': 0, # TODO(jtattermusch): make this scenario work
'async_server_threads': 1, #yield _ping_pong_scenario(
}, # 'python_protobuf_sync_unary_qps_unconstrained', rpc_type='UNARY',
'warmup_seconds': WARMUP_SECONDS, # client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
'benchmark_seconds': BENCHMARK_SECONDS, # use_unconstrained_client=True)
'SERVER_LANGUAGE': 'c++'
} # TODO(jtattermusch): make this scenario work
yield { #yield _ping_pong_scenario(
'name': 'python_protobuf_sync_unary_ping_pong', # 'python_protobuf_async_streaming_qps_unconstrained', rpc_type='STREAMING',
'num_servers': 1, # client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'num_clients': 1, # use_unconstrained_client=True)
'client_config': {
'client_type': 'SYNC_CLIENT', yield _ping_pong_scenario(
'security_params': SECURE_SECARGS, 'python_to_cpp_protobuf_sync_unary_ping_pong', rpc_type='UNARY',
'outstanding_rpcs_per_channel': 1, client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
'client_channels': 1, server_language='c++', server_core_limit=1, async_server_threads=1)
'async_client_threads': 1,
'rpc_type': 'UNARY', # TODO(jtattermusch): make this scenario work
'load_params': { #yield _ping_pong_scenario(
'closed_loop': {} # 'python_to_cpp_protobuf_sync_streaming_ping_pong', rpc_type='STREAMING',
}, # client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
'payload_config': EMPTY_PROTO_PAYLOAD, # server_language='c++', server_core_limit=1, async_server_threads=1)
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'SYNC_SERVER',
'security_params': SECURE_SECARGS,
'core_limit': 0,
'async_server_threads': 1,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS,
}
yield {
'name': 'python_protobuf_async_unary_ping_pong',
'num_servers': 1,
'num_clients': 1,
'client_config': {
'client_type': 'ASYNC_CLIENT',
'security_params': SECURE_SECARGS,
'outstanding_rpcs_per_channel': 1,
'client_channels': 1,
'async_client_threads': 1,
'rpc_type': 'UNARY',
'load_params': {
'closed_loop': {}
},
'payload_config': EMPTY_PROTO_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'SYNC_SERVER',
'security_params': SECURE_SECARGS,
'core_limit': 0,
'async_server_threads': 1,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS,
}
yield {
'name': 'python_to_cpp_single_channel_throughput',
'num_servers': 1,
'num_clients': 1,
'client_config': {
'client_type': 'ASYNC_CLIENT',
'security_params': SECURE_SECARGS,
'outstanding_rpcs_per_channel': 1,
'client_channels': 1,
'async_client_threads': 1,
'rpc_type': 'STREAMING',
'load_params': {
'closed_loop': {}
},
'payload_config': BIG_GENERIC_PAYLOAD,
'histogram_params': HISTOGRAM_PARAMS,
},
'server_config': {
'server_type': 'ASYNC_GENERIC_SERVER',
'security_params': SECURE_SECARGS,
'core_limit': SINGLE_MACHINE_CORES/2,
'async_server_threads': 1,
'payload_config': BIG_GENERIC_PAYLOAD,
},
'warmup_seconds': WARMUP_SECONDS,
'benchmark_seconds': BENCHMARK_SECONDS,
'SERVER_LANGUAGE': 'c++'
}
def __str__(self): def __str__(self):
return 'python' return 'python'
@ -592,34 +388,35 @@ class RubyLanguage:
return 300 return 300
def scenarios(self): def scenarios(self):
# TODO(jtattermusch): add more scenarios yield _ping_pong_scenario(
secargs = SECURE_SECARGS 'ruby_protobuf_sync_streaming_ping_pong', rpc_type='STREAMING',
yield { client_type='SYNC_CLIENT', server_type='SYNC_SERVER')
'name': 'ruby_protobuf_unary_ping_pong',
'num_servers': 1, yield _ping_pong_scenario(
'num_clients': 1, 'ruby_protobuf_unary_ping_pong', rpc_type='UNARY',
'client_config': { client_type='SYNC_CLIENT', server_type='SYNC_SERVER')
'client_type': 'SYNC_CLIENT',
'security_params': secargs, # TODO: scenario reports QPS of 0.0
'outstanding_rpcs_per_channel': 1, #yield _ping_pong_scenario(
'client_channels': 1, # 'ruby_protobuf_sync_unary_qps_unconstrained', rpc_type='UNARY',
'async_client_threads': 1, # client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
'rpc_type': 'UNARY', # use_unconstrained_client=True)
'load_params': {
'closed_loop': {} # TODO: scenario reports QPS of 0.0
}, #yield _ping_pong_scenario(
'payload_config': EMPTY_PROTO_PAYLOAD, # 'ruby_protobuf_sync_streaming_qps_unconstrained', rpc_type='STREAMING',
'histogram_params': HISTOGRAM_PARAMS, # client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
}, # use_unconstrained_client=True)
'server_config': {
'server_type': 'SYNC_SERVER', yield _ping_pong_scenario(
'security_params': secargs, 'ruby_to_cpp_protobuf_sync_unary_ping_pong', rpc_type='UNARY',
'core_limit': 0, client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
'async_server_threads': 1, server_language='c++', server_core_limit=1, async_server_threads=1)
},
'warmup_seconds': WARMUP_SECONDS, yield _ping_pong_scenario(
'benchmark_seconds': BENCHMARK_SECONDS 'ruby_to_cpp_protobuf_sync_streaming_ping_pong', rpc_type='STREAMING',
} client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
server_language='c++', server_core_limit=1, async_server_threads=1)
def __str__(self): def __str__(self):
return 'ruby' return 'ruby'
@ -638,41 +435,59 @@ class JavaLanguage:
return 400 return 400
def scenarios(self): def scenarios(self):
# TODO(jtattermusch): add more scenarios
for secure in [True, False]: for secure in [True, False]:
if secure: secstr = 'secure' if secure else 'insecure'
secstr = 'secure'
secargs = SECURE_SECARGS yield _ping_pong_scenario(
else: 'java_generic_async_streaming_ping_pong_%s' % secstr, rpc_type='STREAMING',
secstr = 'insecure' client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
secargs = None use_generic_payload=True, async_server_threads=1,
secure=secure, warmup_seconds=JAVA_WARMUP_SECONDS)
yield {
'name': 'java_protobuf_unary_ping_pong_%s' % secstr, yield _ping_pong_scenario(
'num_servers': 1, 'java_protobuf_async_streaming_ping_pong_%s' % secstr, rpc_type='STREAMING',
'num_clients': 1, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'client_config': { async_server_threads=1,
'client_type': 'SYNC_CLIENT', secure=secure, warmup_seconds=JAVA_WARMUP_SECONDS)
'security_params': secargs,
'outstanding_rpcs_per_channel': 1, yield _ping_pong_scenario(
'client_channels': 1, 'java_protobuf_async_unary_ping_pong_%s' % secstr, rpc_type='UNARY',
'async_client_threads': 1, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
'rpc_type': 'UNARY', async_server_threads=1,
'load_params': { secure=secure, warmup_seconds=JAVA_WARMUP_SECONDS)
'closed_loop': {}
}, yield _ping_pong_scenario(
'payload_config': EMPTY_PROTO_PAYLOAD, 'java_protobuf_unary_ping_pong_%s' % secstr, rpc_type='UNARY',
'histogram_params': HISTOGRAM_PARAMS, client_type='SYNC_CLIENT', server_type='SYNC_SERVER',
}, async_server_threads=1,
'server_config': { secure=secure, warmup_seconds=JAVA_WARMUP_SECONDS)
'server_type': 'SYNC_SERVER',
'security_params': secargs, yield _ping_pong_scenario(
'core_limit': 0, 'java_protobuf_async_unary_qps_unconstrained_%s' % secstr, rpc_type='UNARY',
'async_server_threads': 1, client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
}, use_unconstrained_client=True,
'warmup_seconds': JAVA_WARMUP_SECONDS, secure=secure, warmup_seconds=JAVA_WARMUP_SECONDS)
'benchmark_seconds': BENCHMARK_SECONDS
} yield _ping_pong_scenario(
'java_protobuf_async_streaming_qps_unconstrained_%s' % secstr, rpc_type='STREAMING',
client_type='ASYNC_CLIENT', server_type='ASYNC_SERVER',
use_unconstrained_client=True,
secure=secure, warmup_seconds=JAVA_WARMUP_SECONDS)
yield _ping_pong_scenario(
'java_generic_async_streaming_qps_unconstrained_%s' % secstr, rpc_type='STREAMING',
client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
use_unconstrained_client=True, use_generic_payload=True,
secure=secure, warmup_seconds=JAVA_WARMUP_SECONDS)
yield _ping_pong_scenario(
'java_generic_async_streaming_qps_one_server_core_%s' % secstr, rpc_type='STREAMING',
client_type='ASYNC_CLIENT', server_type='ASYNC_GENERIC_SERVER',
use_unconstrained_client=True, use_generic_payload=True,
async_server_threads=1,
secure=secure, warmup_seconds=JAVA_WARMUP_SECONDS)
# TODO(jtattermusch): add scenarios java vs C++
def __str__(self): def __str__(self):
return 'java' return 'java'

Write Preview
Loading…
Cancel
Save