def test_three_consumers(self):
self.logger.info("BENCHMARK: Three consumers")
self.perf = ConsumerPerformanceService(self.test_context,
3,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
throughput=-1,
threads=1)
self.perf.run()
self.logger.info("Three consumers: %s", throughput(self.perf))
def __init__(self, test_context):
super(NativeVsRestConsumerPerformance,
self).__init__(test_context,
num_zk=1,
num_brokers=1,
num_rest=1,
topics={
'test-rep-one': {
'partitions': 6,
'replication-factor': 1
}
})
if True:
# Works on both aws and local
msgs = 1000000
else:
# Can use locally on Vagrant VMs, but may use too much memory for aws
msgs = 50000000
msg_size = 100
batch_size = 8196
acks = 1 # default for REST proxy, which isn't yet configurable
nthreads = 1 # not configurable for REST proxy
self.producer = ProducerPerformanceService(test_context,
1,
self.kafka,
topic="test",
num_records=msgs + 1000,
record_size=msg_size,
throughput=-1,
settings={
'batch.size':
batch_size,
'acks': acks
})
self.consumer_perf = ConsumerPerformanceService(test_context,
1,
self.kafka,
topic="test",
num_records=msgs,
throughput=-1,
threads=nthreads)
self.rest_consumer_perf = RestConsumerPerformanceService(
test_context,
1,
self.rest,
topic="test",
num_records=msgs,
throughput=-1)
def test_single_consumer(self):
# All consumer tests use the messages from the first benchmark, so
# they'll get messages of the default message size
self.logger.info("BENCHMARK: Single consumer")
self.perf = ConsumerPerformanceService(self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
throughput=-1,
threads=1)
self.perf.run()
self.logger.info("Single consumer: %s" % throughput(self.perf))
def __init__(self, test_context):
super(NativeVsRestConsumerPerformance, self).__init__(test_context, num_zk=1, num_brokers=1, num_rest=1, topics={
'test-rep-one' : { 'partitions': 6, 'replication-factor': 1 }
})
if True:
# Works on both aws and local
msgs = 1000000
else:
# Can use locally on Vagrant VMs, but may use too much memory for aws
msgs = 50000000
msg_size = 100
batch_size = 8196
acks = 1 # default for REST proxy, which isn't yet configurable
nthreads = 1 # not configurable for REST proxy
self.producer = ProducerPerformanceService(
test_context, 1, self.kafka,
topic="test", num_records=msgs+1000, record_size=msg_size, throughput=-1,
settings={'batch.size':batch_size, 'acks': acks}
)
self.consumer_perf = ConsumerPerformanceService(
test_context, 1, self.kafka,
topic="test", num_records=msgs, throughput=-1, threads=nthreads
)
self.rest_consumer_perf = RestConsumerPerformanceService(
test_context, 1, self.rest,
topic="test", num_records=msgs, throughput=-1
)
def test_long_term_throughput(self):
self.logger.info("BENCHMARK: Long production")
self.perf = ProducerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=self.msgs_large, record_size=self.msg_size_default, throughput=-1,
settings={'acks':1, 'batch.size':self.batch_size, 'buffer.memory':self.buffer_memory},
intermediate_stats=True
)
self.perf.run()
summary = ["Throughput over long run, data > memory:"]
# FIXME we should be generating a graph too
# Try to break it into 5 blocks, but fall back to a smaller number if
# there aren't even 5 elements
block_size = max(len(self.perf.stats[0]) / 5, 1)
nblocks = len(self.perf.stats[0]) / block_size
for i in range(nblocks):
subset = self.perf.stats[0][i*block_size:min((i+1)*block_size, len(self.perf.stats[0]))]
if len(subset) == 0:
summary.append(" Time block %d: (empty)" % i)
else:
summary.append(" Time block %d: %f rec/sec (%f MB/s)" % (i,
sum([stat['records_per_sec'] for stat in subset])/float(len(subset)),
sum([stat['mbps'] for stat in subset])/float(len(subset))))
self.logger.info("\n".join(summary))
def test_producer_and_consumer(self):
self.logger.info("BENCHMARK: Producer + Consumer")
self.producer = ProducerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
record_size=self.msg_size_default,
throughput=-1,
settings={
'acks': 1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
})
self.consumer = ConsumerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
throughput=-1,
threads=1)
Service.run_parallel(self.producer, self.consumer)
summary = [
"Producer + consumer:",
" Producer: %s" % throughput(self.producer),
" Consumer: %s" % throughput(self.consumer)
]
self.logger.info("\n".join(summary))
def test_three_consumers(self):
self.logger.info("BENCHMARK: Three consumers")
self.perf = ConsumerPerformanceService(
self.test_context, 3, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, throughput=-1, threads=1
)
self.perf.run()
self.logger.info("Three consumers: %s", throughput(self.perf))
class NativeVsRestConsumerPerformance(RestProxyTest):
def __init__(self, test_context):
super(NativeVsRestConsumerPerformance, self).__init__(test_context, num_zk=1, num_brokers=1, num_rest=1, topics={
'test-rep-one' : { 'partitions': 6, 'replication-factor': 1 }
})
if True:
# Works on both aws and local
msgs = 1000000
else:
# Can use locally on Vagrant VMs, but may use too much memory for aws
msgs = 50000000
msg_size = 100
batch_size = 8196
acks = 1 # default for REST proxy, which isn't yet configurable
nthreads = 1 # not configurable for REST proxy
self.producer = ProducerPerformanceService(
test_context, 1, self.kafka,
topic="test", num_records=msgs+1000, record_size=msg_size, throughput=-1,
settings={'batch.size':batch_size, 'acks': acks}
)
self.consumer_perf = ConsumerPerformanceService(
test_context, 1, self.kafka,
topic="test", num_records=msgs, throughput=-1, threads=nthreads
)
self.rest_consumer_perf = RestConsumerPerformanceService(
test_context, 1, self.rest,
topic="test", num_records=msgs, throughput=-1
)
def test(self):
# Seed data. FIXME currently the REST consumer isn't properly finishing
# unless we have some extra messages -- the last set isn't getting
# properly returned for some reason.
self.producer.run()
self.consumer_perf.run()
self.rest_consumer_perf.run()
self.logger.info("Consumer performance: %f MB/s, %f msg/sec", self.consumer_perf.results[0]['mbps'], self.consumer_perf.results[0]['records_per_sec'])
self.logger.info("REST Consumer performance: %f MB/s, %f msg/sec", self.rest_consumer_perf.results[0]['mbps'], self.rest_consumer_perf.results[0]['records_per_sec'])
def test_three_producers_async(self):
self.logger.info("BENCHMARK: Three producers, async 3x replication")
self.perf = ProducerPerformanceService(
self.test_context, 3, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, record_size=self.msg_size_default, throughput=-1,
settings={'acks':1, 'batch.size':self.batch_size, 'buffer.memory':self.buffer_memory}
)
self.perf.run()
self.logger.info("Three producers, async 3x replication: %s" % throughput(self.perf))
def test_single_producer_no_replication(self):
self.logger.info("BENCHMARK: Single producer, no replication")
self.perf = ProducerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-one", num_records=self.msgs_default, record_size=self.msg_size_default, throughput=-1,
settings={'acks':1, 'batch.size':self.batch_size, 'buffer.memory':self.buffer_memory}
)
self.perf.run()
self.logger.info("Single producer, no replication: %s", throughput(self.perf))
def test_single_consumer(self):
# All consumer tests use the messages from the first benchmark, so
# they'll get messages of the default message size
self.logger.info("BENCHMARK: Single consumer")
self.perf = ConsumerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, throughput=-1, threads=1
)
self.perf.run()
self.logger.info("Single consumer: %s" % throughput(self.perf))
def test_end_to_end_latency(self):
self.logger.info("BENCHMARK: End to end latency")
self.perf = EndToEndLatencyService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=10000
)
self.perf.run()
self.logger.info("End-to-end latency: median %f ms, 99%% %f ms, 99.9%% %f ms" % \
(self.perf.results[0]['latency_50th_ms'],
self.perf.results[0]['latency_99th_ms'],
self.perf.results[0]['latency_999th_ms']))
def test_end_to_end_latency(self):
self.logger.info("BENCHMARK: End to end latency")
self.perf = EndToEndLatencyService(self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=10000)
self.perf.run()
self.logger.info("End-to-end latency: median %f ms, 99%% %f ms, 99.9%% %f ms" % \
(self.perf.results[0]['latency_50th_ms'],
self.perf.results[0]['latency_99th_ms'],
self.perf.results[0]['latency_999th_ms']))
def test_single_producer_sync(self):
self.logger.info("BENCHMARK: Single producer, sync 3x replication")
self.perf = ProducerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
record_size=self.msg_size_default,
throughput=-1,
settings={
'acks': -1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
})
self.perf.run()
self.logger.info("Single producer, sync 3x replication: %s" %
throughput(self.perf))
def test_long_term_throughput(self):
self.logger.info("BENCHMARK: Long production")
self.perf = ProducerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_large,
record_size=self.msg_size_default,
throughput=-1,
settings={
'acks': 1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
},
intermediate_stats=True)
self.perf.run()
summary = ["Throughput over long run, data > memory:"]
# FIXME we should be generating a graph too
# Try to break it into 5 blocks, but fall back to a smaller number if
# there aren't even 5 elements
block_size = max(len(self.perf.stats[0]) / 5, 1)
nblocks = len(self.perf.stats[0]) / block_size
for i in range(nblocks):
subset = self.perf.stats[0][i * block_size:min(
(i + 1) * block_size, len(self.perf.stats[0]))]
if len(subset) == 0:
summary.append(" Time block %d: (empty)" % i)
else:
summary.append(
" Time block %d: %f rec/sec (%f MB/s)" %
(i, sum([stat['records_per_sec']
for stat in subset]) / float(len(subset)),
sum([stat['mbps']
for stat in subset]) / float(len(subset))))
self.logger.info("\n".join(summary))
class NativeVsRestConsumerPerformance(RestProxyTest):
def __init__(self, test_context):
super(NativeVsRestConsumerPerformance,
self).__init__(test_context,
num_zk=1,
num_brokers=1,
num_rest=1,
topics={
'test-rep-one': {
'partitions': 6,
'replication-factor': 1
}
})
if True:
# Works on both aws and local
msgs = 1000000
else:
# Can use locally on Vagrant VMs, but may use too much memory for aws
msgs = 50000000
msg_size = 100
batch_size = 8196
acks = 1 # default for REST proxy, which isn't yet configurable
nthreads = 1 # not configurable for REST proxy
self.producer = ProducerPerformanceService(test_context,
1,
self.kafka,
topic="test",
num_records=msgs + 1000,
record_size=msg_size,
throughput=-1,
settings={
'batch.size':
batch_size,
'acks': acks
})
self.consumer_perf = ConsumerPerformanceService(test_context,
1,
self.kafka,
topic="test",
num_records=msgs,
throughput=-1,
threads=nthreads)
self.rest_consumer_perf = RestConsumerPerformanceService(
test_context,
1,
self.rest,
topic="test",
num_records=msgs,
throughput=-1)
def test(self):
# Seed data. FIXME currently the REST consumer isn't properly finishing
# unless we have some extra messages -- the last set isn't getting
# properly returned for some reason.
self.producer.run()
self.consumer_perf.run()
self.rest_consumer_perf.run()
self.logger.info("Consumer performance: %f MB/s, %f msg/sec",
self.consumer_perf.results[0]['mbps'],
self.consumer_perf.results[0]['records_per_sec'])
self.logger.info("REST Consumer performance: %f MB/s, %f msg/sec",
self.rest_consumer_perf.results[0]['mbps'],
self.rest_consumer_perf.results[0]['records_per_sec'])
class KafkaBenchmark(KafkaTest):
'''A benchmark of Kafka producer/consumer performance. This replicates the test
run here:
https://engineering.linkedin.com/kafka/benchmarking-apache-kafka-2-million-writes-second-three-cheap-machines
'''
def __init__(self, test_context):
super(KafkaBenchmark, self).__init__(test_context, num_zk=1, num_brokers=3, topics={
'test-rep-one' : { 'partitions': 6, 'replication-factor': 1 },
'test-rep-three' : { 'partitions': 6, 'replication-factor': 3 }
})
if True:
# Works on both aws and local
self.msgs = 1000000
self.msgs_default = 1000000
else:
# Can use locally on Vagrant VMs, but may use too much memory for aws
self.msgs = 50000000
self.msgs_default = 50000000
self.msgs_large = 10000000
self.msg_size_default = 100
self.batch_size = 8*1024
self.buffer_memory = 64*1024*1024
self.msg_sizes = [10, 100, 1000, 10000, 100000]
self.target_data_size = 128*1024*1024
self.target_data_size_gb = self.target_data_size/float(1024*1024*1024)
def test_single_producer_no_replication(self):
self.logger.info("BENCHMARK: Single producer, no replication")
self.perf = ProducerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-one", num_records=self.msgs_default, record_size=self.msg_size_default, throughput=-1,
settings={'acks':1, 'batch.size':self.batch_size, 'buffer.memory':self.buffer_memory}
)
self.perf.run()
self.logger.info("Single producer, no replication: %s", throughput(self.perf))
def test_single_producer_replication(self):
self.logger.info("BENCHMARK: Single producer, async 3x replication")
self.perf = ProducerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, record_size=self.msg_size_default, throughput=-1,
settings={'acks':1, 'batch.size':self.batch_size, 'buffer.memory':self.buffer_memory}
)
self.perf.run()
self.logger.info("Single producer, async 3x replication: %s" % throughput(self.perf))
def test_single_producer_sync(self):
self.logger.info("BENCHMARK: Single producer, sync 3x replication")
self.perf = ProducerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, record_size=self.msg_size_default, throughput=-1,
settings={'acks':-1, 'batch.size':self.batch_size, 'buffer.memory':self.buffer_memory}
)
self.perf.run()
self.logger.info("Single producer, sync 3x replication: %s" % throughput(self.perf))
def test_three_producers_async(self):
self.logger.info("BENCHMARK: Three producers, async 3x replication")
self.perf = ProducerPerformanceService(
self.test_context, 3, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, record_size=self.msg_size_default, throughput=-1,
settings={'acks':1, 'batch.size':self.batch_size, 'buffer.memory':self.buffer_memory}
)
self.perf.run()
self.logger.info("Three producers, async 3x replication: %s" % throughput(self.perf))
def test_multiple_message_size(self):
# TODO this would be a great place to use parametrization
self.perfs = {}
for msg_size in self.msg_sizes:
self.logger.info("BENCHMARK: Message size %d (%f GB total, single producer, async 3x replication)", msg_size, self.target_data_size_gb)
# Always generate the same total amount of data
nrecords = int(self.target_data_size / msg_size)
self.perfs["perf-" + str(msg_size)] = ProducerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=nrecords, record_size=msg_size, throughput=-1,
settings={'acks': 1, 'batch.size': self.batch_size, 'buffer.memory': self.buffer_memory}
)
self.msg_size_perf = {}
for msg_size in self.msg_sizes:
perf = self.perfs["perf-" + str(msg_size)]
perf.run()
self.msg_size_perf[msg_size] = perf
summary = ["Message size:"]
for msg_size in self.msg_sizes:
summary.append(" %d: %s" % (msg_size, throughput(self.msg_size_perf[msg_size])))
self.logger.info("\n".join(summary))
def test_long_term_throughput(self):
self.logger.info("BENCHMARK: Long production")
self.perf = ProducerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=self.msgs_large, record_size=self.msg_size_default, throughput=-1,
settings={'acks':1, 'batch.size':self.batch_size, 'buffer.memory':self.buffer_memory},
intermediate_stats=True
)
self.perf.run()
summary = ["Throughput over long run, data > memory:"]
# FIXME we should be generating a graph too
# Try to break it into 5 blocks, but fall back to a smaller number if
# there aren't even 5 elements
block_size = max(len(self.perf.stats[0]) / 5, 1)
nblocks = len(self.perf.stats[0]) / block_size
for i in range(nblocks):
subset = self.perf.stats[0][i*block_size:min((i+1)*block_size, len(self.perf.stats[0]))]
if len(subset) == 0:
summary.append(" Time block %d: (empty)" % i)
else:
summary.append(" Time block %d: %f rec/sec (%f MB/s)" % (i,
sum([stat['records_per_sec'] for stat in subset])/float(len(subset)),
sum([stat['mbps'] for stat in subset])/float(len(subset))))
self.logger.info("\n".join(summary))
def test_end_to_end_latency(self):
self.logger.info("BENCHMARK: End to end latency")
self.perf = EndToEndLatencyService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=10000
)
self.perf.run()
self.logger.info("End-to-end latency: median %f ms, 99%% %f ms, 99.9%% %f ms" % \
(self.perf.results[0]['latency_50th_ms'],
self.perf.results[0]['latency_99th_ms'],
self.perf.results[0]['latency_999th_ms']))
def test_producer_and_consumer(self):
self.logger.info("BENCHMARK: Producer + Consumer")
self.producer = ProducerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, record_size=self.msg_size_default, throughput=-1,
settings={'acks':1, 'batch.size':self.batch_size, 'buffer.memory':self.buffer_memory}
)
self.consumer = ConsumerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, throughput=-1, threads=1
)
Service.run_parallel(self.producer, self.consumer)
summary = [
"Producer + consumer:",
" Producer: %s" % throughput(self.producer),
" Consumer: %s" % throughput(self.consumer)]
self.logger.info("\n".join(summary))
def test_single_consumer(self):
# All consumer tests use the messages from the first benchmark, so
# they'll get messages of the default message size
self.logger.info("BENCHMARK: Single consumer")
self.perf = ConsumerPerformanceService(
self.test_context, 1, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, throughput=-1, threads=1
)
self.perf.run()
self.logger.info("Single consumer: %s" % throughput(self.perf))
def test_three_consumers(self):
self.logger.info("BENCHMARK: Three consumers")
self.perf = ConsumerPerformanceService(
self.test_context, 3, self.kafka,
topic="test-rep-three", num_records=self.msgs_default, throughput=-1, threads=1
)
self.perf.run()
self.logger.info("Three consumers: %s", throughput(self.perf))
class KafkaBenchmark(KafkaTest):
'''A benchmark of Kafka producer/consumer performance. This replicates the test
run here:
https://engineering.linkedin.com/kafka/benchmarking-apache-kafka-2-million-writes-second-three-cheap-machines
'''
def __init__(self, test_context):
super(KafkaBenchmark, self).__init__(test_context,
num_zk=1,
num_brokers=3,
topics={
'test-rep-one': {
'partitions': 6,
'replication-factor': 1
},
'test-rep-three': {
'partitions': 6,
'replication-factor': 3
}
})
if True:
# Works on both aws and local
self.msgs = 1000000
self.msgs_default = 1000000
else:
# Can use locally on Vagrant VMs, but may use too much memory for aws
self.msgs = 50000000
self.msgs_default = 50000000
self.msgs_large = 10000000
self.msg_size_default = 100
self.batch_size = 8 * 1024
self.buffer_memory = 64 * 1024 * 1024
self.msg_sizes = [10, 100, 1000, 10000, 100000]
self.target_data_size = 128 * 1024 * 1024
self.target_data_size_gb = self.target_data_size / float(
1024 * 1024 * 1024)
def test_single_producer_no_replication(self):
self.logger.info("BENCHMARK: Single producer, no replication")
self.perf = ProducerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-one",
num_records=self.msgs_default,
record_size=self.msg_size_default,
throughput=-1,
settings={
'acks': 1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
})
self.perf.run()
self.logger.info("Single producer, no replication: %s",
throughput(self.perf))
def test_single_producer_replication(self):
self.logger.info("BENCHMARK: Single producer, async 3x replication")
self.perf = ProducerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
record_size=self.msg_size_default,
throughput=-1,
settings={
'acks': 1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
})
self.perf.run()
self.logger.info("Single producer, async 3x replication: %s" %
throughput(self.perf))
def test_single_producer_sync(self):
self.logger.info("BENCHMARK: Single producer, sync 3x replication")
self.perf = ProducerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
record_size=self.msg_size_default,
throughput=-1,
settings={
'acks': -1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
})
self.perf.run()
self.logger.info("Single producer, sync 3x replication: %s" %
throughput(self.perf))
def test_three_producers_async(self):
self.logger.info("BENCHMARK: Three producers, async 3x replication")
self.perf = ProducerPerformanceService(
self.test_context,
3,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
record_size=self.msg_size_default,
throughput=-1,
settings={
'acks': 1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
})
self.perf.run()
self.logger.info("Three producers, async 3x replication: %s" %
throughput(self.perf))
def test_multiple_message_size(self):
# TODO this would be a great place to use parametrization
self.perfs = {}
for msg_size in self.msg_sizes:
self.logger.info(
"BENCHMARK: Message size %d (%f GB total, single producer, async 3x replication)",
msg_size, self.target_data_size_gb)
# Always generate the same total amount of data
nrecords = int(self.target_data_size / msg_size)
self.perfs["perf-" + str(msg_size)] = ProducerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=nrecords,
record_size=msg_size,
throughput=-1,
settings={
'acks': 1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
})
self.msg_size_perf = {}
for msg_size in self.msg_sizes:
perf = self.perfs["perf-" + str(msg_size)]
perf.run()
self.msg_size_perf[msg_size] = perf
summary = ["Message size:"]
for msg_size in self.msg_sizes:
summary.append(
" %d: %s" %
(msg_size, throughput(self.msg_size_perf[msg_size])))
self.logger.info("\n".join(summary))
def test_long_term_throughput(self):
self.logger.info("BENCHMARK: Long production")
self.perf = ProducerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_large,
record_size=self.msg_size_default,
throughput=-1,
settings={
'acks': 1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
},
intermediate_stats=True)
self.perf.run()
summary = ["Throughput over long run, data > memory:"]
# FIXME we should be generating a graph too
# Try to break it into 5 blocks, but fall back to a smaller number if
# there aren't even 5 elements
block_size = max(len(self.perf.stats[0]) / 5, 1)
nblocks = len(self.perf.stats[0]) / block_size
for i in range(nblocks):
subset = self.perf.stats[0][i * block_size:min(
(i + 1) * block_size, len(self.perf.stats[0]))]
if len(subset) == 0:
summary.append(" Time block %d: (empty)" % i)
else:
summary.append(
" Time block %d: %f rec/sec (%f MB/s)" %
(i, sum([stat['records_per_sec']
for stat in subset]) / float(len(subset)),
sum([stat['mbps']
for stat in subset]) / float(len(subset))))
self.logger.info("\n".join(summary))
def test_end_to_end_latency(self):
self.logger.info("BENCHMARK: End to end latency")
self.perf = EndToEndLatencyService(self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=10000)
self.perf.run()
self.logger.info("End-to-end latency: median %f ms, 99%% %f ms, 99.9%% %f ms" % \
(self.perf.results[0]['latency_50th_ms'],
self.perf.results[0]['latency_99th_ms'],
self.perf.results[0]['latency_999th_ms']))
def test_producer_and_consumer(self):
self.logger.info("BENCHMARK: Producer + Consumer")
self.producer = ProducerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
record_size=self.msg_size_default,
throughput=-1,
settings={
'acks': 1,
'batch.size': self.batch_size,
'buffer.memory': self.buffer_memory
})
self.consumer = ConsumerPerformanceService(
self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
throughput=-1,
threads=1)
Service.run_parallel(self.producer, self.consumer)
summary = [
"Producer + consumer:",
" Producer: %s" % throughput(self.producer),
" Consumer: %s" % throughput(self.consumer)
]
self.logger.info("\n".join(summary))
def test_single_consumer(self):
# All consumer tests use the messages from the first benchmark, so
# they'll get messages of the default message size
self.logger.info("BENCHMARK: Single consumer")
self.perf = ConsumerPerformanceService(self.test_context,
1,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
throughput=-1,
threads=1)
self.perf.run()
self.logger.info("Single consumer: %s" % throughput(self.perf))
def test_three_consumers(self):
self.logger.info("BENCHMARK: Three consumers")
self.perf = ConsumerPerformanceService(self.test_context,
3,
self.kafka,
topic="test-rep-three",
num_records=self.msgs_default,
throughput=-1,
threads=1)
self.perf.run()
self.logger.info("Three consumers: %s", throughput(self.perf))