92 lines
3.5 KiB
Python
92 lines
3.5 KiB
Python
import errno
|
|
import fcntl
|
|
import os
|
|
import pathlib
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
import unittest.mock
|
|
|
|
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
|
|
|
from machine_load import memory
|
|
from machine_load.slots import slot_count
|
|
from machine_load import slots
|
|
|
|
|
|
class SlotCount(unittest.TestCase):
|
|
def test_one_slot_per_four_cpus_and_never_none(self):
|
|
for cpus, slots in ((16, 4), (8, 2), (7, 1), (4, 1), (1, 1), (None, 1)):
|
|
self.assertEqual(slot_count(cpus), slots, cpus)
|
|
|
|
|
|
class MemoryShare(unittest.TestCase):
|
|
def test_has_room_from_a_quarter_of_memory_available(self):
|
|
self.assertFalse(memory.Memory(available=3, total=16).has_room())
|
|
self.assertTrue(memory.Memory(available=4, total=16).has_room())
|
|
|
|
def test_reads_available_and_total_memory_from_meminfo(self):
|
|
meminfo = "MemTotal: 16387072 kB\nMemFree: 981236 kB\nMemAvailable: 4096000 kB\n"
|
|
self.assertEqual(memory.parsed(meminfo), memory.Memory(available=4096000, total=16387072))
|
|
for unread in ("MemTotal: 16 kB\n", "MemTotal: x kB\nMemAvailable: 1 kB\n", ""):
|
|
self.assertIsNone(memory.parsed(unread), unread)
|
|
|
|
def test_reads_a_meminfo_file_and_none_where_it_cannot(self):
|
|
with tempfile.TemporaryDirectory() as temp:
|
|
meminfo = pathlib.Path(temp, "meminfo")
|
|
meminfo.write_text("MemTotal: 8 kB\nMemAvailable: 2 kB\n")
|
|
self.assertEqual(memory.read_memory(meminfo), memory.Memory(available=2, total=8))
|
|
self.assertIsNone(memory.read_memory(pathlib.Path(temp, "gone")))
|
|
|
|
|
|
class SlotShare(unittest.TestCase):
|
|
def test_splits_the_three_quarters_a_worker_leaves_evenly_across_the_slots_in_mib(self):
|
|
self.assertEqual(memory.Memory(available=0, total=32 * 1024 * 1024).slot_share(4), 6144)
|
|
self.assertEqual(memory.Memory(available=0, total=8000000).slot_share(2), 2929)
|
|
|
|
|
|
class SlotFolder(unittest.TestCase):
|
|
def test_every_session_shares_the_slots_under_the_users_state_folder(self):
|
|
self.assertEqual(slots.slot_folder({}), pathlib.Path.home() / ".local" / "state" / "run-heavy")
|
|
self.assertEqual(slots.slot_folder({"XDG_STATE_HOME": "/s"}), pathlib.Path("/s/run-heavy"))
|
|
|
|
|
|
class TakenSlot(unittest.TestCase):
|
|
def test_a_lock_that_fails_for_another_reason_than_a_holder_closes_its_file_and_raises(self):
|
|
closed = []
|
|
with tempfile.TemporaryDirectory() as folder, unittest.mock.patch("fcntl.flock", side_effect=OSError(errno.ENOLCK, "No locks available")), unittest.mock.patch("os.close", side_effect=closed.append):
|
|
with self.assertRaises(OSError):
|
|
slots.taken_slot(pathlib.Path(folder), 2)
|
|
self.assertEqual(len(closed), 1)
|
|
self.assertIsInstance(closed[0], int)
|
|
os.close(closed[0])
|
|
|
|
|
|
class WaitedSlot(unittest.TestCase):
|
|
def test_waits_while_every_slot_is_held_saying_so_once_then_takes_the_freed_one(self):
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
held = [open(pathlib.Path(folder, f"slot-{slot}"), "a") for slot in range(2)]
|
|
for file in held:
|
|
fcntl.flock(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
|
said, slept = [], []
|
|
|
|
def sleep(seconds):
|
|
slept.append(seconds)
|
|
if len(slept) == 2:
|
|
held[1].close()
|
|
|
|
slot, fd = slots.waited_slot(pathlib.Path(folder), 2, lambda: said.append(True), sleep)
|
|
os.close(fd)
|
|
held[0].close()
|
|
self.assertEqual((slot, said, slept), (1, [True], [slots.POLL_SECONDS] * 2))
|
|
|
|
def test_takes_a_free_slot_at_once(self):
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
slot, fd = slots.waited_slot(pathlib.Path(folder), 2, lambda: self.fail("said it waits"), lambda seconds: self.fail("slept"))
|
|
os.close(fd)
|
|
self.assertEqual(slot, 0)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|