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)	Apple M1 (Rosetta 2) (wall clock)	Apple M1 (Rosetta 2) (ops/sec)	Relation (Rosetta 2/M1)
--------	-----------------------	--------------------	-----------------------------------	--------------------------------	-------------------------
Run 1	0.513485	1947476	0.779232	1283314	1.517536053
Run 2	0.515587	1939536	0.803177	1245055	1.557791411
Run 3	0.514109	1945113	0.805633	1241259	1.567047066
Run 4	0.520584	1920919	0.826969	1209234	1.588540946
Run 5	0.518380	1929087	0.806673	1239659	1.556142212
Run 6	0.537575	1860205	0.812485	1230791	1.511389108
Run 7	0.530633	1884541	0.809894	1234729	1.526278991
Run 8	0.533390	1874800	0.795565	1256968	1.491525900
Run 9	0.516247	1937057	0.776764	1287392	1.504636347
Run 10	0.515243	1940832	0.793976	1259483	1.540973871
Run 11	0.517204	1933472	0.799150	1251329	1.545134995
Run 12	0.522334	1914484	0.784650	1274453	1.502199742
Run 13	0.515059	1941525	0.814270	1228093	1.580925680
Run 14	0.530446	1885205	0.810215	1234240	1.527422207
Run 15	0.523705	1909471	0.800976	1248476	1.529441193
--------	-----------------------	--------------------	-----------------------------------	--------------------------------	-------------------------
Med	0.518380	1929087	0.803177	1245055	1.549398125
Avg	0.521599	1917581.533	0.8013086	1248298.333	1.536254881
Min	0.513485	1860205	0.776764	1209234	1.512729681
Max	0.537575	1947476	0.826969	1287392	1.538332326