def Run(benchmark_spec):
"""Runs the pgbench benchark on the client vm, against the db server.
Args:
benchmark_spec: benchmark_spec object which contains the database server
and client_vm
Returns:
a list of sample objects
"""
UpdateBenchmarkSpecWithRunStageFlags(benchmark_spec)
db = benchmark_spec.relational_db
connection_string = db.MakePsqlConnectionString(TEST_DB_NAME)
common_metadata = {
'scale_factor': benchmark_spec.scale_factor,
'postgres_db_size_MB': db.postgres_db_size_MB,
'seconds_per_test': benchmark_spec.seconds_per_test,
'seconds_to_pause_before_steps': benchmark_spec.seconds_to_pause,
}
for client in benchmark_spec.client_counts:
time.sleep(benchmark_spec.seconds_to_pause)
jobs = min(client, 16)
command = (
'pgbench {0} --client={1} --jobs={2} --time={3} --progress=1 '
'--report-latencies'.format(connection_string, client, jobs,
benchmark_spec.seconds_per_test))
_, stderr = benchmark_spec.vms[0].RobustRemoteCommand(command,
should_log=True)
samples = MakeSamplesFromOutput(stderr, client, jobs, common_metadata)
publisher.PublishRunStageSamples(benchmark_spec, samples)
return []
def Run(benchmark_spec):
"""Run the MySQL Service benchmark and publish results.
Args:
benchmark_spec: The benchmark specification. Contains all data that is
required to run the benchmark.
Returns:
Results.
"""
logging.info('Start benchmarking MySQL Service, '
'Cloud Provider is %s.', FLAGS.cloud)
client_vm = benchmark_spec.vms[0]
db = benchmark_spec.relational_db
for thread_count in FLAGS.sysbench_thread_counts:
metadata = CreateMetadataFromFlags(db)
metadata['sysbench_thread_count'] = thread_count
# The run phase is common across providers. The VMs[0] object contains all
# information and states necessary to carry out the run.
run_results = _RunSysbench(client_vm, metadata, benchmark_spec,
thread_count)
print(run_results)
publisher.PublishRunStageSamples(benchmark_spec, run_results)
if (FLAGS.use_managed_db
and benchmark_spec.relational_db.spec.high_availability
and FLAGS.sysbench_pre_failover_seconds):
last_client_count = FLAGS.sysbench_thread_counts[
len(FLAGS.sysbench_thread_counts) - 1]
failover_results = _PerformFailoverTest(client_vm, metadata,
benchmark_spec,
last_client_count)
print(failover_results)
publisher.PublishRunStageSamples(benchmark_spec, failover_results)
# all results have already been published
# database results take a long time to gather. If later client counts
# or failover tests fail, still want the data from the earlier tests.
# so, results are published as they are found.
return []
def _RunTest(benchmark_spec, sender, receiver, dest_ip, ip_type, conf,
cooldown_s):
"""Run a single NTTTCP test, and publish the results."""
try:
results = ntttcp.RunNtttcp(sender, receiver, dest_ip, ip_type,
conf.udp, conf.threads, conf.time_s,
conf.packet_size, cooldown_s)
publisher.PublishRunStageSamples(benchmark_spec, results)
return True
except IOError:
logging.info('Failed to publish %s IP results for config %s', ip_type,
str(conf))
return False
def RunPgBench(benchmark_spec,
relational_db,
vm,
test_db_name,
client_counts,
job_counts,
seconds_to_pause,
seconds_per_test,
metadata,
file=None,
path=None):
"""Run Pgbench on the client VM.
Args:
benchmark_spec: Benchmark spec of the run
relational_db: Relational database object
vm: Client VM
test_db_name: The name of the database
client_counts: Number of client
job_counts: Number of job
seconds_to_pause: Seconds to pause between test
seconds_per_test: Seconds per test
metadata: Metadata of the benchmark
file: Filename of the benchmark
path: File path of the benchmar.
"""
connection_string = relational_db.client_vm_query_tools.GetConnectionString(
database_name=test_db_name)
if file and path:
metadata['pgbench_file'] = file
samples = []
if job_counts and len(client_counts) != len(job_counts):
raise ValueError('Length of clients and jobs must be the same.')
for i in range(len(client_counts)):
time.sleep(seconds_to_pause)
client = client_counts[i]
if job_counts:
jobs = job_counts[i]
else:
jobs = min(client, 16)
command = (f'pgbench {connection_string} --client={client} '
f'--jobs={jobs} --time={seconds_per_test} --progress=1 '
'--report-latencies')
if file and path:
command = f'cd {path} && {command} --file={file}'
_, stderr = vm.RobustRemoteCommand(command)
samples = MakeSamplesFromOutput(stderr, client, jobs, metadata)
publisher.PublishRunStageSamples(benchmark_spec, samples)
