igormunkin/relay-1mops.lua Secret

## relay-1mops.lua
#!/usr/bin/tarantool
-- vim:ts=4 ss=4 sw=4 expandtab
-- Usage: tarantool relay-1mops.lua [num_ops] [nodes]
-- num_ops should be a number multiple of num_fibers * ops_per_txn
-- nodes should be a number from 1 to 31

local clock = require('clock')
local fiber = require('fiber')
local popen = require('popen')
local yaml = require('yaml')

-- TUNE OPTIONS HERE
-- working dir is cleared/created for every run, set mwd
-- during the test a subdir will be created for each replica
local mwd = './relay-test.data'

-- turn true to test the qsync
local test_qsync = false

-- number of operations performed by test
local num_ops = tonumber(arg[1] or 1e6)

-- number of fibers
local num_fibers = 50

-- number of operations per transaction
local ops_per_txn = 100

-- check the number of operations value
local txns, tail = math.modf(num_ops / num_fibers / ops_per_txn)
assert(txns > 0 and tail == 0,
       ('Invalid number of iterations: %s'):format(num_ops))

-- number of nodes - master and replicas
local nodes, tail = math.modf(tonumber(arg[2] or 0) + 1)
assert(nodes > 0 and nodes < 32 and tail == 0,
       ('Invalid number of nodes: %s'):format(nodes))

-- posterior evaluation shows that 256Mb is enough to make
-- 4 million replaces
local default_memtx_memory = 256 * 1024 * 1024
local memtx_memory = math.max(math.ceil(num_ops / 1e6 * default_memtx_memory),
                              default_memtx_memory)

-- END OF TUNABLE OPTIONS

print(('making %d operations, %d operations per txn using %d fibers'):format(
       num_ops, ops_per_txn, num_fibers))

--- transactions per fiber
local trans_per_fiber = num_ops/ops_per_txn/num_fibers

os.execute(('rm -rf %s'):format(mwd))
os.execute(('mkdir -p %s'):format(mwd))

box.cfg({
  listen = 3301,
  log_level = 0,
  memtx_memory = memtx_memory,
  read_only = false,
  replication = 'replicator:password@localhost:3301',
  work_dir = mwd,
})

if test_qsync then
  box.cfg({ replication_synchro_quorum = nodes })
end

box.schema.user.create('replicator', { password = 'password' })
box.schema.user.grant('replicator', 'replication')

-- number of nodes, storage for popen handles
local nodes_ph = {}

-- run replicas (if needed)
if nodes > 1 then
  print(('starting %d replicas'):format(nodes - 1))
  for i = 2, nodes do
    -- subdir for replica's data
    local rwd = ('relay-test.replica-%s'):format(i)
    os.execute(('rm -rf %s'):format(rwd))
    os.execute(('mkdir -p %s'):format(rwd))
    -- command line for replica to start
    local cmd = { arg[-1], '-e', ([[
      box.cfg({
        listen = %d,
        log_level = 0,
        memtx_memory = %d,
        read_only = false,
        replication = 'replicator:password@localhost:3301',
        work_dir = '%s',
      })
    ]]):format(3300 + i, memtx_memory, rwd) }
    local res, err = popen.new(cmd, {
      stdin = 'devnull',
      stdout = 'devnull',
      stderr = 'devnull',
    })
    assert(res, ('Error running replica %d: %s'):format(i, err))
    nodes_ph[i] = res
  end

  -- wait for all replicas to connect
  while #box.info.replication < nodes do
    fiber.sleep(0.1)
  end
end

local space = box.schema.create_space('test',
                                      test_qsync and { is_sync = true } or { })

space:create_index('pk', { type = 'HASH' })

-- each fiber runs the fiber_load that has evenly distributed workload
function fiber_load(start, s)
  for i = 1, trans_per_fiber do
    box.begin()
    for j = 1, ops_per_txn do
      s:replace{ start, start }
      start = start + 1
    end
    box.commit()
  end
end

-- fiber storage to join them
local fibers_storage = { }

-- start timer
local start = {
  lsn = box.info.replication[1].lsn,
  proc = clock.proc(),
  time = clock.time(),
}

for i = 1, num_fibers do
  fibers_storage[i] = fiber.create(fiber_load, i*num_ops, space)
  fibers_storage[i]:wakeup() -- needed for backward compatibility with 1.7
end

-- wait for all fibers to finish
for i = 1, num_fibers do
  while fibers_storage[i]:status() ~= 'dead' do
    fiber.yield()
  end -- the loop is needed for backward compatibility with 1.7
end

local ops_done = box.info.replication[1].lsn

-- stop timer for master
local stop = {
  lsn = ops_done - start.lsn,
  proc = clock.proc() - start.proc,
  time = clock.time() - start.time,
}

assert(num_ops == stop.lsn,
       ('Missing data: %d/%d inserted'):format(stop.lsn, num_ops))

print(('master done in time: %f, cpu: %f\nmaster speed: %d ops/sec'):format(
      stop.time, stop.proc, math.floor(stop.lsn / stop.time)))

-- wait for all replicas and kill them
if nodes > 1 then
  local done = false
  repeat
    for i = 2, nodes do
      local r_vclock = box.info.replication[i].downstream.vclock
      if r_vclock and r_vclock[1] < ops_done then
        done = false
        break
      end
      done = true
    end
    if not done then
      fiber.sleep(0.001)
    end
  until done
  -- stop timer for replicas
  stop = {
    lsn = box.info.replication[nodes].downstream.vclock[1] - start.lsn,
    time = clock.time() - start.time,
    proc = clock.proc() - start.proc,
  }

  print(('replicas done in time: %f, cpu: %f\nreplicas speed: %f ops/sec'):format(
        stop.time, stop.proc, math.floor(stop.lsn / stop.time)))

  for _, replica in pairs(nodes_ph) do
    replica:kill()
    replica:wait()
  end
end

os.exit(0)
	#!/usr/bin/tarantool
	-- vim:ts=4 ss=4 sw=4 expandtab
	-- Usage: tarantool relay-1mops.lua [num_ops] [nodes]
	-- num_ops should be a number multiple of num_fibers * ops_per_txn
	-- nodes should be a number from 1 to 31

	local clock = require('clock')
	local fiber = require('fiber')
	local popen = require('popen')
	local yaml = require('yaml')

	-- TUNE OPTIONS HERE
	-- working dir is cleared/created for every run, set mwd
	-- during the test a subdir will be created for each replica
	local mwd = './relay-test.data'

	-- turn true to test the qsync
	local test_qsync = false

	-- number of operations performed by test
	local num_ops = tonumber(arg[1] or 1e6)

	-- number of fibers
	local num_fibers = 50

	-- number of operations per transaction
	local ops_per_txn = 100

	-- check the number of operations value
	local txns, tail = math.modf(num_ops / num_fibers / ops_per_txn)
	assert(txns > 0 and tail == 0,
	('Invalid number of iterations: %s'):format(num_ops))

	-- number of nodes - master and replicas
	local nodes, tail = math.modf(tonumber(arg[2] or 0) + 1)
	assert(nodes > 0 and nodes < 32 and tail == 0,
	('Invalid number of nodes: %s'):format(nodes))

	-- posterior evaluation shows that 256Mb is enough to make
	-- 4 million replaces
	local default_memtx_memory = 256 * 1024 * 1024
	local memtx_memory = math.max(math.ceil(num_ops / 1e6 * default_memtx_memory),
	default_memtx_memory)

	-- END OF TUNABLE OPTIONS

	print(('making %d operations, %d operations per txn using %d fibers'):format(
	num_ops, ops_per_txn, num_fibers))

	--- transactions per fiber
	local trans_per_fiber = num_ops/ops_per_txn/num_fibers

	os.execute(('rm -rf %s'):format(mwd))
	os.execute(('mkdir -p %s'):format(mwd))

	box.cfg({
	listen = 3301,
	log_level = 0,
	memtx_memory = memtx_memory,
	read_only = false,
	replication = 'replicator:password@localhost:3301',
	work_dir = mwd,
	})

	if test_qsync then
	box.cfg({ replication_synchro_quorum = nodes })
	end

	box.schema.user.create('replicator', { password = 'password' })
	box.schema.user.grant('replicator', 'replication')

	-- number of nodes, storage for popen handles
	local nodes_ph = {}

	-- run replicas (if needed)
	if nodes > 1 then
	print(('starting %d replicas'):format(nodes - 1))
	for i = 2, nodes do
	-- subdir for replica's data
	local rwd = ('relay-test.replica-%s'):format(i)
	os.execute(('rm -rf %s'):format(rwd))
	os.execute(('mkdir -p %s'):format(rwd))
	-- command line for replica to start
	local cmd = { arg[-1], '-e', ([[
	box.cfg({
	listen = %d,
	log_level = 0,
	memtx_memory = %d,
	read_only = false,
	replication = 'replicator:password@localhost:3301',
	work_dir = '%s',
	})
	]]):format(3300 + i, memtx_memory, rwd) }
	local res, err = popen.new(cmd, {
	stdin = 'devnull',
	stdout = 'devnull',
	stderr = 'devnull',
	})
	assert(res, ('Error running replica %d: %s'):format(i, err))
	nodes_ph[i] = res
	end

	-- wait for all replicas to connect
	while #box.info.replication < nodes do
	fiber.sleep(0.1)
	end
	end

	local space = box.schema.create_space('test',
	test_qsync and { is_sync = true } or { })

	space:create_index('pk', { type = 'HASH' })

	-- each fiber runs the fiber_load that has evenly distributed workload
	function fiber_load(start, s)
	for i = 1, trans_per_fiber do
	box.begin()
	for j = 1, ops_per_txn do
	s:replace{ start, start }
	start = start + 1
	end
	box.commit()
	end
	end

	-- fiber storage to join them
	local fibers_storage = { }

	-- start timer
	local start = {
	lsn = box.info.replication[1].lsn,
	proc = clock.proc(),
	time = clock.time(),
	}

	for i = 1, num_fibers do
	fibers_storage[i] = fiber.create(fiber_load, i*num_ops, space)
	fibers_storage[i]:wakeup() -- needed for backward compatibility with 1.7
	end

	-- wait for all fibers to finish
	for i = 1, num_fibers do
	while fibers_storage[i]:status() ~= 'dead' do
	fiber.yield()
	end -- the loop is needed for backward compatibility with 1.7
	end

	local ops_done = box.info.replication[1].lsn

	-- stop timer for master
	local stop = {
	lsn = ops_done - start.lsn,
	proc = clock.proc() - start.proc,
	time = clock.time() - start.time,
	}

	assert(num_ops == stop.lsn,
	('Missing data: %d/%d inserted'):format(stop.lsn, num_ops))

	print(('master done in time: %f, cpu: %f\nmaster speed: %d ops/sec'):format(
	stop.time, stop.proc, math.floor(stop.lsn / stop.time)))

	-- wait for all replicas and kill them
	if nodes > 1 then
	local done = false
	repeat
	for i = 2, nodes do
	local r_vclock = box.info.replication[i].downstream.vclock
	if r_vclock and r_vclock[1] < ops_done then
	done = false
	break
	end
	done = true
	end
	if not done then
	fiber.sleep(0.001)
	end
	until done
	-- stop timer for replicas
	stop = {
	lsn = box.info.replication[nodes].downstream.vclock[1] - start.lsn,
	time = clock.time() - start.time,
	proc = clock.proc() - start.proc,
	}

	print(('replicas done in time: %f, cpu: %f\nreplicas speed: %f ops/sec'):format(
	stop.time, stop.proc, math.floor(stop.lsn / stop.time)))

	for _, replica in pairs(nodes_ph) do
	replica:kill()
	replica:wait()
	end
	end

	os.exit(0)
	Apple M1 (wall clock)	Apple M1 (ops/sec)	Intel(R) Core(TM) i7-8700B CPU @ 3.20GHz (wall clock)	Intel(R) Core(TM) i7-8700B CPU @ 3.20GHz (ops/sec)	Relation (i7-8700B/M1)
--------	-----------------------	--------------------	-------------------------------------------------------	----------------------------------------------------	------------------------
Run 1	0.513485	1947476	0.748003	1336893	1.456718307
Run 2	0.515587	1939536	0.746805	1339037	1.448455838
Run 3	0.514109	1945113	0.761108	1313874	1.480440918
Run 4	0.520584	1920919	0.754540	1325310	1.449410662
Run 5	0.518380	1929087	0.749934	1333450	1.446687758
Run 6	0.537575	1860205	0.744439	1343293	1.384809561
Run 7	0.530633	1884541	0.739956	1351431	1.394477916
Run 8	0.533390	1874800	0.743603	1344803	1.394107501
Run 9	0.516247	1937057	0.749837	1333623	1.452477206
Run 10	0.515243	1940832	0.782833	1277411	1.519347182
Run 11	0.517204	1933472	0.757378	1320344	1.464369958
Run 12	0.522334	1914484	0.764940	1307292	1.464465266
Run 13	0.515059	1941525	0.761197	1313720	1.477883116
Run 14	0.530446	1885205	0.759262	1317068	1.431365304
Run 15	0.523705	1909471	0.741279	1349019	1.415451447
--------	-----------------------	--------------------	-------------------------------------------------------	----------------------------------------------------	------------------------
Med	0.518380	1929087	0.749934	1333450	1.446687758
Avg	0.521599	1917581.533	0.7536742667	1327104.533	1.444931167
Min	0.513485	1860205	0.739956	1277411	1.441046963
Max	0.537575	1947476	0.782833	1351431	1.456230293