mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-02-07 15:03:34 +00:00
113 lines
3.2 KiB
Lua
113 lines
3.2 KiB
Lua
-- Copyright 2022 Justine Alexandra Roberts Tunney
|
|
--
|
|
-- Permission to use, copy, modify, and/or distribute this software for
|
|
-- any purpose with or without fee is hereby granted, provided that the
|
|
-- above copyright notice and this permission notice appear in all copies.
|
|
--
|
|
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
|
|
-- WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
|
|
-- WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
|
|
-- AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
|
-- DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
-- PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
-- TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
-- PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
assert(unix.pledge("stdio proc"))
|
|
|
|
-- let's use futexes to implement a scalable mutex in lua
|
|
--
|
|
-- this example is designed to be the kind of thing that would be
|
|
-- extremely expensive if we were using spin locks, because we'll
|
|
-- have a lot of processes that wait a long time for something to
|
|
-- happen. futexes solve that by asking the kernel to help us out
|
|
-- and let the waiting processes sleep until the actual event.
|
|
--
|
|
-- here we have fifty processes, waiting one just one process, to
|
|
-- to finish a long-running task. if we used spin locks, then the
|
|
-- waiter procesess would eat up all the cpu. if you benchmark it
|
|
-- then be sure to note that WALL TIME will be the same, it's the
|
|
-- CPU USER TIME that gets pwnd.
|
|
--
|
|
-- uses 67 ms cpu time with futexes
|
|
-- uses 5,000 ms cpu time with spinlocks
|
|
millis = 300
|
|
waiters = 100
|
|
|
|
words = 2
|
|
mem = unix.mapshared(words * 8)
|
|
LOCK = 0 -- word index of our lock
|
|
RESULT = 1 -- word index of our result
|
|
|
|
-- From Futexes Are Tricky Version 1.1 § Mutex, Take 3;
|
|
-- Ulrich Drepper, Red Hat Incorporated, June 27, 2004.
|
|
function Lock()
|
|
local ok, old = mem:cmpxchg(LOCK, 0, 1)
|
|
if not ok then
|
|
if old == 1 then
|
|
old = mem:xchg(LOCK, 2)
|
|
end
|
|
while old > 0 do
|
|
mem:wait(LOCK, 2)
|
|
old = mem:xchg(LOCK, 2)
|
|
end
|
|
end
|
|
end
|
|
function Unlock()
|
|
local old = mem:fetch_add(LOCK, -1)
|
|
if old == 2 then
|
|
mem:store(LOCK, 0)
|
|
mem:wake(LOCK, 1)
|
|
end
|
|
end
|
|
|
|
-- -- try it out with spin locks instead
|
|
-- function Lock()
|
|
-- while mem:xchg(LOCK, 1) == 1 do
|
|
-- end
|
|
-- end
|
|
-- function Unlock()
|
|
-- mem:store(LOCK, 0)
|
|
-- end
|
|
|
|
function Worker()
|
|
assert(unix.nanosleep(math.floor(millis / 1000),
|
|
millis % 1000 * 1000 * 1000))
|
|
mem:store(RESULT, 123)
|
|
Unlock()
|
|
end
|
|
|
|
function Waiter()
|
|
Lock()
|
|
assert(mem:load(RESULT) == 123)
|
|
Unlock()
|
|
end
|
|
|
|
Lock()
|
|
|
|
for i = 1,waiters do
|
|
pid = assert(unix.fork())
|
|
if pid == 0 then
|
|
Waiter()
|
|
unix.exit(0)
|
|
end
|
|
end
|
|
|
|
Worker()
|
|
|
|
while true do
|
|
rc, ws = unix.wait(0)
|
|
if not rc then
|
|
assert(ws:errno() == unix.ECHILD)
|
|
break
|
|
end
|
|
if unix.WIFEXITED(ws) then
|
|
if unix.WEXITSTATUS(ws) ~= 0 then
|
|
print('process %d exited with %s' % {rc, unix.WEXITSTATUS(ws)})
|
|
unix.exit(1)
|
|
end
|
|
else
|
|
print('process %d terminated with %s' % {rc, unix.WTERMSIG(ws)})
|
|
unix.exit(1)
|
|
end
|
|
end
|