def _write_stat_per_test(self, stat_file_name, time_result_dict):
"""Write stat of per-test results to csv file
note: take the full dictionary of test and calculate overall stat
"""
full_list = [] # list containing 1st to 5kth data point
current_num_threads = len(time_result_dict)
test_category = self._get_output_filename(stat_file_name)
for i in range(len(time_result_dict)):
time_list = time_result_dict.get('thread-{}'.format(i))
full_list += time_list
stat_dict = generate_stat_for_concurrent_thread(
'test-{}'.format(len(time_result_dict)),
full_list,
stat_file_name,
len(full_list), 1)
generate_bar_chart_stat(
stat_dict,
'Concurrent Subscription Stat - per test '
'({0}-{1}-clients)'
.format(test_category, current_num_threads),
'{0}-per-test-{1}-clients.svg'
.format(test_category, current_num_threads),
'test'
)
def _write_stat_per_client_bucketized(
self, stat_file_name,
time_result_dict,
current_num_threads,
is_attach):
"""Write bucketized stat of per-client results to csv file
note: each bucket is a split of a client i
"""
for i in range(current_num_threads):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
stat_dict = generate_stat_for_concurrent_thread(
thread_name,
time_list,
stat_file_name,
self.bucket_size,
self.num_buckets
)
generate_line_chart_bucketized_stat(
stat_dict,
'Concurrent Subscription Stat - per client bucketized '
'client-{0} total-{1}-clients'.format(i, current_num_threads),
'stat-client-{0}-bucketized-{1}-clients.svg'
.format(i, current_num_threads),
self.bucket_size,
self.num_buckets
)
def _write_stat_per_client_bucketized(self, stat_file_name,
time_result_dict,
current_num_threads):
"""Write bucketized stat of per-client results to csv file
note: each bucket is a split of a client i
"""
test_category = self._get_output_filename(stat_file_name)
for i in range(current_num_threads):
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
stat_dict = generate_stat_for_concurrent_thread(
thread_name,
time_list,
stat_file_name,
self.bucket_size,
self.num_buckets
)
# create line chart with each client being grouped by buckets
generate_line_chart_bucketized_stat(
stat_dict,
'Concurrent Subscription Stat - per client bucketized -'
'Client-{0} by {1}-{2}-clients'
.format(i, test_category, current_num_threads),
'{0}-client-{1}-bucketized-{2}-clients.svg'
.format(test_category, i, current_num_threads),
self.bucket_size,
self.num_buckets
)
def _write_stat_per_client(self, stat_file_name, time_result_dict,
current_num_threads, is_attach):
"""Write stat of per-client results to csv file
note: take the full list of a client i; calculate stat on the list
"""
stat_dict = {}
return_stat = {}
num_clients = len(time_result_dict)
for i in range(current_num_threads):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
# for each client i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
thread_name, time_list, stat_file_name, len(time_list), 1)
# for each chunk i, add stat into final return_dict
stat_dict.update({i: return_stat.get(0, (0, 0, 0, 0))})
# create graph based on stats of all clients
generate_bar_chart_stat(
stat_dict, 'Concurrent Subscription Stat - per client '
'({} clients)'.format(num_clients),
'stat-per-client-{}-clients.svg'.format(num_clients), 'client')
def write_stat_per_test_bucketized(
time_result_dict, is_attach=True):
stat_dict = {}
return_stat = {}
num_clients = len(time_result_dict)
for i in range(10):
chunks_bucket_i = []
for j in range(len(time_result_dict)):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(j))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(j))
# slice out bucket-size from each client's result and merge
chunks_bucket_i += time_list[
i * 125: (i + 1) * 125
]
# for each chunk i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
'bucket-{}'.format(i),
chunks_bucket_i,
'csv-test-per-client.csv',
len(chunks_bucket_i), 1)
# for each chunk i, add stat into final return_dict
stat_dict.update({
i: return_stat.get(0, (0, 0, 0, 0))
})
# create graph based on stats of all chunks
generate_line_chart_bucketized_stat(
stat_dict,
'Concurrent Subscription Stat - per test bucketized '
'({} clients)'.format(num_clients),
'stat-test-bucketized-{}-clients.svg'.format(num_clients),
500,
10
)
def _write_stat_per_test(self, stat_file_name, time_result_dict):
"""Write stat of per-test results to csv file
note: take the full dictionary of test and calculate overall stat
"""
full_list = [] # list containing 1st to 5kth data point
current_num_threads = len(time_result_dict)
test_category = self._get_output_filename(stat_file_name)
for i in range(len(time_result_dict)):
time_list = time_result_dict.get('thread-{}'.format(i))
full_list += time_list
stat_dict = generate_stat_for_concurrent_thread(
'test-{}'.format(len(time_result_dict)),
full_list,
stat_file_name,
len(full_list),
1
)
generate_bar_chart_stat(
stat_dict,
'Concurrent Subscription Statistics - per test: '
'({0}-{1}-clients)'
.format(test_category, current_num_threads),
'{0}-per-test-{1}-clients.svg'
.format(test_category, current_num_threads),
'test'
)
def _write_stat_per_test_bucketized(
self,
stat_file_name,
time_result_dict):
"""Write bucketized stat of per-test to csv file
note: each bucket of all clients would merge into a chunk;
generate stat for each such chunk. For example::
Input: # of clients = 10
thread-0: [(50 data) | (50 data)|...]
thread-1: [(50 data) | (50 data)|...]
...
thread-9: [(50 data) | (50 data)|...]
Output:
sublist [500 data grouped from all clients' first buckets],
[500 data grouped from all clients' next buckets],
...
[500 data grouped from all clients' last buckets];
line chart of statistics on these chunks.
"""
# parameters for generating bucketized line chart
stat_dict = {}
return_stat = {}
current_num_threads = len(time_result_dict)
test_category = self._get_output_filename(stat_file_name)
for i in range(self.num_buckets):
chunks_bucket_i = []
for j in range(len(time_result_dict)):
time_list = time_result_dict.get('thread-{0}'.format(j))
# slice out bucket-size from each client's result and merge
chunks_bucket_i += time_list[
i * self.bucket_size: (i + 1) * self.bucket_size
]
# for each chunk i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
'bucket-{0}'.format(i),
chunks_bucket_i,
stat_file_name,
len(chunks_bucket_i),
1
)
# for each chunk i, add stat into final return_dict
stat_dict.update({i: return_stat.get(0, (0, 0, 0, 0))})
# create line chart with all clients grouped by a chunk of buckets
generate_line_chart_stat_bucketized_candlepin(
stat_dict,
'Concurrent Subscription Statistics - per test bucketized: '
'({0}-{1}-clients)'
.format(test_category, current_num_threads),
'{0}-test-bucketized-{1}-clients.svg'
.format(test_category, current_num_threads),
self.bucket_size,
self.num_buckets
)
def _write_stat_per_test(self, stat_file_name, time_result_dict,
is_attach):
"""Write stat of per-test results to csv file
note: take the full dictionary of test and calculate overall stat
"""
full_list = [] # list containing 1st to 5kth data point
num_clients = len(time_result_dict)
for i in range(len(time_result_dict)):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
full_list += time_list
stat_dict = generate_stat_for_concurrent_thread(
'test-{}'.format(len(time_result_dict)), full_list, stat_file_name,
len(full_list), 1)
generate_bar_chart_stat(
stat_dict, 'Concurrent Subscription Stat - per test '
'({} clients)'.format(num_clients),
'stat-per-test-{}-clients.svg'.format(num_clients), 'test')
def _write_stat_per_client_bucketized(self, stat_file_name,
time_result_dict,
current_num_threads, is_attach):
"""Write bucketized stat of per-client results to csv file
note: each bucket is a split of a client i
"""
for i in range(current_num_threads):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
stat_dict = generate_stat_for_concurrent_thread(
thread_name, time_list, stat_file_name, self.bucket_size,
self.num_buckets)
generate_line_chart_bucketized_stat(
stat_dict,
'Concurrent Subscription Stat - per client bucketized '
'client-{0} total-{1}-clients'.format(i, current_num_threads),
'stat-client-{0}-bucketized-{1}-clients.svg'.format(
i,
current_num_threads), self.bucket_size, self.num_buckets)
def _write_stat_per_client_bucketized(self, stat_file_name,
time_result_dict,
current_num_threads):
"""Write bucketized stat of per-client results to csv file
note: each bucket is just a split of a client i. For example::
Input: # of clients = 1
{thread-i: [(50 data) | (50 data)|...]}
Output:
line chart of statistics on these buckets.
"""
test_category = self._get_output_filename(stat_file_name)
for i in range(current_num_threads):
time_list = time_result_dict.get('thread-{0}'.format(i))
thread_name = 'client-{0}'.format(i)
stat_dict = generate_stat_for_concurrent_thread(
thread_name, time_list, stat_file_name, self.bucket_size,
self.num_buckets)
# create line chart with each client being grouped by buckets
generate_line_chart_stat_bucketized_candlepin(
stat_dict,
'Concurrent Subscription Statistics - per client bucketized: '
'Client-{0} by {1}-{2}-clients'.format(i, test_category,
current_num_threads),
'{0}-client-{1}-bucketized-{2}-clients.svg'.format(
test_category, i,
current_num_threads), self.bucket_size, self.num_buckets)
def write_stat_per_client(time_result_dict,
current_num_threads, is_attach=True):
stat_dict = {}
return_stat = {}
num_clients = len(time_result_dict)
for i in range(current_num_threads):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
# for each client i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
thread_name,
time_list,
'csv-test-per-client.csv',
len(time_list), 1)
# for each chunk i, add stat into final return_dict
stat_dict.update({
i: return_stat.get(0, (0, 0, 0, 0))
})
# create graph based on stats of all clients
generate_bar_chart_stat(
stat_dict,
'Concurrent Subscription Stat - per client '
'({} clients)'.format(num_clients),
'stat-per-client-{}-clients.svg'.format(num_clients),
'client'
)
def _write_stat_per_client(self, stat_file_name, time_result_dict,
current_num_threads):
"""Write stat of per-client results to csv file
note: take the full list of a client i; calculate stat on the list
"""
# parameters for generating bucketized line chart
stat_dict = {}
return_stat = {}
current_num_threads = len(time_result_dict)
test_category = self._get_output_filename(stat_file_name)
for i in range(current_num_threads):
time_list = time_result_dict.get('thread-{0}'.format(i))
thread_name = 'client-{0}'.format(i)
# for each client i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
thread_name, time_list, stat_file_name, len(time_list), 1)
# for each chunk i, add stat into final return_dict
stat_dict.update({i: return_stat.get(0, (0, 0, 0, 0))})
# create graph based on stats of all clients
generate_bar_chart_stat(
stat_dict, 'Concurrent Subscription Statistics - per client: '
'({0}-{1}-clients)'.format(test_category, current_num_threads),
'{0}-per-client-{1}-clients.svg'.format(test_category,
current_num_threads),
'client')
def _write_stat_per_test(self, stat_file_name,
time_result_dict, is_attach):
"""Write stat of per-test results to csv file
note: take the full dictionary of test and calculate overall stat
"""
full_list = [] # list containing 1st to 5kth data point
num_clients = len(time_result_dict)
for i in range(len(time_result_dict)):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
full_list += time_list
stat_dict = generate_stat_for_concurrent_thread(
'test-{}'.format(len(time_result_dict)),
full_list,
stat_file_name,
len(full_list), 1)
generate_bar_chart_stat(
stat_dict,
'Concurrent Subscription Stat - per test '
'({} clients)'.format(num_clients),
'stat-per-test-{}-clients.svg'.format(num_clients),
'test'
)
def _write_stat_per_test_bucketized(
self,
stat_file_name,
time_result_dict):
"""Write bucketized stat of per-test to csv file
note: each bucket of all clients would merge into a chunk;
generate stat for each such chunk. For example::
Input: # of clients = 10
thread-0: [(50 data) | (50 data)|...]
thread-1: [(50 data) | (50 data)|...]
...
thread-9: [(50 data) | (50 data)|...]
Output:
sublist [500 data grouped from all clients' first buckets],
[500 data grouped from all clients' next buckets],
...
[500 data grouped from all clients' last buckets];
line chart of statistics on these chunks.
"""
# parameters for generating bucketized line chart
stat_dict = {}
return_stat = {}
current_num_threads = len(time_result_dict)
test_category = self._get_output_filename(stat_file_name)
for i in range(self.num_buckets):
chunks_bucket_i = []
for j in range(len(time_result_dict)):
time_list = time_result_dict.get('thread-{}'.format(j))
# slice out bucket-size from each client's result and merge
chunks_bucket_i += time_list[
i * self.bucket_size: (i + 1) * self.bucket_size
]
# for each chunk i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
'bucket-{}'.format(i),
chunks_bucket_i,
stat_file_name,
len(chunks_bucket_i),
1
)
# for each chunk i, add stat into final return_dict
stat_dict.update({i: return_stat.get(0, (0, 0, 0, 0))})
# create line chart with all clients grouped by a chunk of buckets
generate_line_chart_stat_bucketized_candlepin(
stat_dict,
'Concurrent Subscription Statistics - per test bucketized: '
'({0}-{1}-clients)'
.format(test_category, current_num_threads),
'{0}-test-bucketized-{1}-clients.svg'
.format(test_category, current_num_threads),
self.bucket_size,
self.num_buckets
)
def write_stat_per_client_bucketized(
time_result_dict,
current_num_threads,
is_attach=True):
for i in range(current_num_threads):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
stat_dict, buckets = generate_stat_for_concurrent_thread(
thread_name,
time_list,
'csv-test-per-client.csv',
125,
4
)
generate_line_chart_bucketized_stat(
stat_dict,
'Concurrent Subscription Stat - per client bucketized '
'client-{0} total-{1}-clients'.format(i, current_num_threads),
'stat-client-{}-bucketized.svg'.format(i),
125,
10
)
def _write_stat_per_test_bucketized(
self, stat_file_name,
time_result_dict,
is_attach):
"""Write bucketized stat of per-test to csv file
note: each bucket of all clients would merge into a chunk;
generate stat for each such chunk. For example::
Input: # of clients = 10
thread-0: [(50 data) | (50 data)|...]
thread-1: [(50 data) | (50 data)|...]
...
thread-9: [(50 data) | (50 data)|...]
Output:
sublist [500 data in all first buckets of each thread]
[500]...[500]
"""
# parameters for generating bucketized line chart
stat_dict = {}
return_stat = {}
num_clients = len(time_result_dict)
for i in range(self.num_buckets):
chunks_bucket_i = []
for j in range(len(time_result_dict)):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(j))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(j))
# slice out bucket-size from each client's result and merge
chunks_bucket_i += time_list[
i * self.bucket_size: (i + 1) * self.bucket_size
]
# for each chunk i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
'bucket-{}'.format(i),
chunks_bucket_i,
stat_file_name,
len(chunks_bucket_i), 1)
# for each chunk i, add stat into final return_dict
stat_dict.update({
i: return_stat.get(0, (0, 0, 0, 0))
})
# create graph based on stats of all chunks
generate_bar_chart_stat(
stat_dict,
'Concurrent Subscription Stat - per test bucketized '
'({} clients)'.format(num_clients),
'stat-test-bucketized-{}-clients.svg'.format(num_clients),
self.bucket_size,
self.num_buckets
)
def write_stat_per_client_bucketized(time_result_dict,
current_num_threads,
is_attach=True):
for i in range(current_num_threads):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
stat_dict, buckets = generate_stat_for_concurrent_thread(
thread_name, time_list, 'csv-test-per-client.csv', 125, 4)
generate_line_chart_bucketized_stat(
stat_dict, 'Concurrent Subscription Stat - per client bucketized '
'client-{0} total-{1}-clients'.format(i, current_num_threads),
'stat-client-{}-bucketized.svg'.format(i), 125, 10)
def write_stat_per_test(time_result_dict, is_attach=True):
full_list = [] # list containing 1st to 5kth data point
num_clients = len(time_result_dict)
for i in range(len(time_result_dict)):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
full_list += time_list
stat_dict = generate_stat_for_concurrent_thread(
'test-{}'.format(len(time_result_dict)), full_list,
'csv-test-per-client.csv', len(full_list), 1)
generate_bar_chart_stat(
stat_dict, 'Concurrent Subscription Stat - per test '
'({} clients)'.format(num_clients),
'stat-per-test-{}-clients.svg'.format(num_clients), 'test')
def _write_stat_per_test_bucketized(self, stat_file_name, time_result_dict,
is_attach):
"""Write bucketized stat of per-test to csv file
note: each bucket of all clients would merge into a chunk;
generate stat for each such chunk. For example::
Input: # of clients = 10
thread-0: [(50 data) | (50 data)|...]
thread-1: [(50 data) | (50 data)|...]
...
thread-9: [(50 data) | (50 data)|...]
Output:
sublist [500 data in all first buckets of each thread]
[500]...[500]
"""
# parameters for generating bucketized line chart
stat_dict = {}
return_stat = {}
num_clients = len(time_result_dict)
for i in range(self.num_buckets):
chunks_bucket_i = []
for j in range(len(time_result_dict)):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(j))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(j))
# slice out bucket-size from each client's result and merge
chunks_bucket_i += time_list[i * self.bucket_size:(i + 1) *
self.bucket_size]
# for each chunk i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
'bucket-{}'.format(i), chunks_bucket_i, stat_file_name,
len(chunks_bucket_i), 1)
# for each chunk i, add stat into final return_dict
stat_dict.update({i: return_stat.get(0, (0, 0, 0, 0))})
# create graph based on stats of all chunks
generate_bar_chart_stat(
stat_dict, 'Concurrent Subscription Stat - per test bucketized '
'({} clients)'.format(num_clients),
'stat-test-bucketized-{}-clients.svg'.format(num_clients),
self.bucket_size, self.num_buckets)
def _write_stat_per_client(
self,
stat_file_name,
time_result_dict,
current_num_threads):
"""Write stat of per-client results to csv file
note: take the full list of a client i; calculate stat on the list
"""
# parameters for generating bucketized line chart
stat_dict = {}
return_stat = {}
current_num_threads = len(time_result_dict)
test_category = self._get_output_filename(stat_file_name)
for i in range(current_num_threads):
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
# for each client i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
thread_name,
time_list,
stat_file_name,
len(time_list),
1
)
# for each chunk i, add stat into final return_dict
stat_dict.update({i: return_stat.get(0, (0, 0, 0, 0))})
# create graph based on stats of all clients
generate_bar_chart_stat(
stat_dict,
'Concurrent Subscription Statistics - per client: '
'({0}-{1}-clients)'
.format(test_category, current_num_threads),
'{0}-per-client-{1}-clients.svg'
.format(test_category, current_num_threads),
'client'
)
def _write_stat_per_client_bucketized(
self,
stat_file_name,
time_result_dict,
current_num_threads):
"""Write bucketized stat of per-client results to csv file
note: each bucket is just a split of a client i. For example::
Input: # of clients = 1
{thread-i: [(50 data) | (50 data)|...]}
Output:
line chart of statistics on these buckets.
"""
test_category = self._get_output_filename(stat_file_name)
for i in range(current_num_threads):
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
stat_dict = generate_stat_for_concurrent_thread(
thread_name,
time_list,
stat_file_name,
self.bucket_size,
self.num_buckets
)
# create line chart with each client being grouped by buckets
generate_line_chart_stat_bucketized_candlepin(
stat_dict,
'Concurrent Subscription Statistics - per client bucketized: '
'Client-{0} by {1}-{2}-clients'
.format(i, test_category, current_num_threads),
'{0}-client-{1}-bucketized-{2}-clients.svg'
.format(test_category, i, current_num_threads),
self.bucket_size,
self.num_buckets
)
def write_stat_per_client(time_result_dict,
current_num_threads,
is_attach=True):
stat_dict = {}
return_stat = {}
num_clients = len(time_result_dict)
for i in range(current_num_threads):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
# for each client i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
thread_name, time_list, 'csv-test-per-client.csv', len(time_list),
1)
# for each chunk i, add stat into final return_dict
stat_dict.update({i: return_stat.get(0, (0, 0, 0, 0))})
# create graph based on stats of all clients
generate_bar_chart_stat(
stat_dict, 'Concurrent Subscription Stat - per client '
'({} clients)'.format(num_clients),
'stat-per-client-{}-clients.svg'.format(num_clients), 'client')
def _write_stat_per_client(self, stat_file_name, time_result_dict,
current_num_threads, is_attach):
"""Write stat of per-client results to csv file
note: take the full list of a client i; calculate stat on the list
"""
stat_dict = {}
return_stat = {}
num_clients = len(time_result_dict)
for i in range(current_num_threads):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(i))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(i))
thread_name = 'client-{}'.format(i)
# for each client i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
thread_name,
time_list,
stat_file_name,
len(time_list), 1)
# for each chunk i, add stat into final return_dict
stat_dict.update({
i: return_stat.get(0, (0, 0, 0, 0))
})
# create graph based on stats of all clients
generate_bar_chart_stat(
stat_dict,
'Concurrent Subscription Stat - per client '
'({} clients)'.format(num_clients),
'stat-per-client-{}-clients.svg'.format(num_clients),
'client'
)
def write_stat_per_test_bucketized(time_result_dict, is_attach=True):
stat_dict = {}
return_stat = {}
num_clients = len(time_result_dict)
for i in range(10):
chunks_bucket_i = []
for j in range(len(time_result_dict)):
if is_attach:
time_list = time_result_dict.get('thread-{}'.format(j))[2]
else:
time_list = time_result_dict.get('thread-{}'.format(j))
# slice out bucket-size from each client's result and merge
chunks_bucket_i += time_list[i * 125:(i + 1) * 125]
# for each chunk i, compute and output its stat
return_stat = generate_stat_for_concurrent_thread(
'bucket-{}'.format(i), chunks_bucket_i, 'csv-test-per-client.csv',
len(chunks_bucket_i), 1)
# for each chunk i, add stat into final return_dict
stat_dict.update({i: return_stat.get(0, (0, 0, 0, 0))})
# create graph based on stats of all chunks
generate_line_chart_bucketized_stat(
stat_dict, 'Concurrent Subscription Stat - per test bucketized '
'({} clients)'.format(num_clients),
'stat-test-bucketized-{}-clients.svg'.format(num_clients), 500, 10)
