def run_test(self):
num_nodes = len(self.nodes)
# setup monitor to report the current block count periodically
cur_block_count = self.nodes[0].getblockcount()
monitor_thread = threading.Thread(target=self.monitor,
args=(cur_block_count, ),
daemon=True)
monitor_thread.start()
# generate blocks
threads = {}
rpc_times = []
for i in range(1, self.options.num_blocks + 1):
wait_sec = random.expovariate(1000 /
self.options.generation_period_ms)
start = time.time()
# find an idle node to generate block
p = random.randint(0, num_nodes - 1)
retry = 0
while retry < 10:
pre_thread = threads.get(p)
if pre_thread is not None and pre_thread.is_alive():
p = random.randint(0, num_nodes - 1)
retry += 1
else:
break
if retry >= 10:
self.log.warn(
"too many nodes are busy to generate block, stop to analyze logs."
)
break
thread = GenerateThread(self.nodes, p, self.options.txs_per_block,
self.options.generate_tx_data_len,
self.log, rpc_times)
thread.start()
threads[p] = thread
if i % self.options.block_sync_step == 0:
self.log.info("[PROGRESS] %d blocks generated async", i)
elapsed = time.time() - start
if elapsed < wait_sec:
self.log.debug("%d generating block %.2f", p, elapsed)
time.sleep(wait_sec - elapsed)
else:
self.log.warn("%d generating block slowly %.2f", p, elapsed)
monitor_thread.join()
self.sync_blocks()
self.log.info("generateoneblock RPC latency: {}".format(
Statistics(rpc_times, 3).__dict__))
self.log.info("Best block: {}".format(
RpcClient(self.nodes[0]).best_block_hash()))
def generate_blocks_async(self):
num_nodes = len(self.nodes)
max_retry = 200
# generate blocks
threads = {}
rpc_times = []
for i in range(1, self.options.num_blocks + 1):
wait_sec = random.expovariate(1000 /
self.options.generation_period_ms)
start = time.time()
# find an idle node to generate block
p = random.randint(0, num_nodes - 1)
retry = 0
while retry < max_retry:
pre_thread = threads.get(p)
if pre_thread is not None and pre_thread.is_alive():
p = random.randint(0, num_nodes - 1)
retry += 1
time.sleep(0.05)
else:
break
if retry >= max_retry:
self.log.warn(
"too many nodes are busy to generate block, stop to analyze logs."
)
break
if self.enable_tx_propagation:
# Generate a block with the transactions in the node's local tx pool
thread = SimpleGenerateThread(
self.nodes, p, self.options.max_block_size_in_bytes,
self.log, rpc_times)
else:
# Generate a fixed-size block with fake tx
thread = GenerateThread(self.nodes, p,
self.options.txs_per_block,
self.options.generate_tx_data_len,
self.log, rpc_times)
thread.start()
threads[p] = thread
if i % self.options.report_progress_blocks == 0:
self.log.info("[PROGRESS] %d blocks generated async", i)
self.progress = i
elapsed = time.time() - start
if elapsed < wait_sec:
self.log.debug("%d generating block %.2f", p, elapsed)
time.sleep(wait_sec - elapsed)
elif elapsed > 0.01:
self.log.warn("%d generating block slowly %.2f", p, elapsed)
self.log.info("generateoneblock RPC latency: {}".format(
Statistics(rpc_times, 3).__dict__))
def run_test(self):
num_nodes = len(self.nodes)
if self.tx_propagation_enabled:
#setup usable accounts
start_time = time.time()
current_index = 1
for i in range(len(self.nodes)):
client = RpcClient(self.nodes[i])
client.send_usable_genesis_accounts(current_index)
current_index += self.options.txgen_account_count
self.log.info(
"Time spend (s) on setting up genesis accounts: {}".format(
time.time() - start_time))
# setup monitor to report the current block count periodically
cur_block_count = self.nodes[0].getblockcount()
# The monitor will check the block_count of nodes[0]
monitor_thread = threading.Thread(target=self.monitor,
args=(cur_block_count, 100),
daemon=True)
monitor_thread.start()
# generate blocks
threads = {}
rpc_times = []
for i in range(1, self.options.num_blocks + 1):
wait_sec = random.expovariate(1000 /
self.options.generation_period_ms)
start = time.time()
# find an idle node to generate block
p = random.randint(0, num_nodes - 1)
retry = 0
while retry < 10:
pre_thread = threads.get(p)
if pre_thread is not None and pre_thread.is_alive():
p = random.randint(0, num_nodes - 1)
retry += 1
time.sleep(0.01)
else:
break
if retry >= 10:
self.log.warn(
"too many nodes are busy to generate block, stop to analyze logs."
)
break
if self.tx_propagation_enabled:
# Generate a block with the transactions in the node's local tx pool
thread = SimpleGenerateThread(
self.nodes, p, self.options.txs_per_block,
self.options.generate_tx_data_len, self.log, rpc_times)
else:
# Generate a fixed-size block with fake tx
thread = GenerateThread(self.nodes, p,
self.options.txs_per_block,
self.options.generate_tx_data_len,
self.log, rpc_times)
thread.start()
threads[p] = thread
if i % self.options.block_sync_step == 0:
self.log.info("[PROGRESS] %d blocks generated async", i)
self.progress = i
elapsed = time.time() - start
if elapsed < wait_sec:
self.log.debug("%d generating block %.2f", p, elapsed)
time.sleep(wait_sec - elapsed)
elif elapsed > 0.01:
self.log.warn("%d generating block slowly %.2f", p, elapsed)
monitor_thread.join()
self.log.info("Goodput: {}".format(self.nodes[0].getgoodput()))
self.sync_blocks()
self.log.info("generateoneblock RPC latency: {}".format(
Statistics(rpc_times, 3).__dict__))
self.log.info("Best block: {}".format(
RpcClient(self.nodes[0]).best_block_hash()))
def run_test(self):
num_nodes = len(self.nodes)
if self.tx_propagation_enabled:
# Setup balance for each node
client = RpcClient(self.nodes[0])
for i in range(num_nodes):
pub_key = self.nodes[i].key
addr = self.nodes[i].addr
self.log.info("%d has addr=%s pubkey=%s", i, encode_hex(addr),
pub_key)
tx = client.new_tx(value=int(default_config["TOTAL_COIN"] /
(num_nodes + 1)) - 21000,
receiver=encode_hex(addr),
nonce=i)
client.send_tx(tx)
# setup monitor to report the current block count periodically
cur_block_count = self.nodes[0].getblockcount()
# The monitor will check the block_count of nodes[0]
monitor_thread = threading.Thread(target=self.monitor,
args=(cur_block_count, 100),
daemon=True)
monitor_thread.start()
# generate blocks
threads = {}
rpc_times = []
for i in range(1, self.options.num_blocks + 1):
wait_sec = random.expovariate(1000 /
self.options.generation_period_ms)
start = time.time()
# find an idle node to generate block
p = random.randint(0, num_nodes - 1)
retry = 0
while retry < 10:
pre_thread = threads.get(p)
if pre_thread is not None and pre_thread.is_alive():
p = random.randint(0, num_nodes - 1)
retry += 1
else:
break
if retry >= 10:
self.log.warn(
"too many nodes are busy to generate block, stop to analyze logs."
)
break
if self.tx_propagation_enabled:
# Generate a block with the transactions in the node's local tx pool
thread = SimpleGenerateThread(
self.nodes, p, self.options.txs_per_block,
self.options.generate_tx_data_len, self.log, rpc_times)
else:
# Generate a fixed-size block with fake tx
thread = GenerateThread(self.nodes, p,
self.options.txs_per_block,
self.options.generate_tx_data_len,
self.log, rpc_times)
thread.start()
threads[p] = thread
if i % self.options.block_sync_step == 0:
self.log.info("[PROGRESS] %d blocks generated async", i)
elapsed = time.time() - start
if elapsed < wait_sec:
self.log.debug("%d generating block %.2f", p, elapsed)
time.sleep(wait_sec - elapsed)
else:
self.log.warn("%d generating block slowly %.2f", p, elapsed)
monitor_thread.join()
self.sync_blocks()
self.log.info("generateoneblock RPC latency: {}".format(
Statistics(rpc_times, 3).__dict__))
self.log.info("Best block: {}".format(
RpcClient(self.nodes[0]).best_block_hash()))