From 87470490676ee6dc087e3ebe2a3ce3cfbd4afbd9 Mon Sep 17 00:00:00 2001 From: Sanjit Bhat Date: Wed, 13 Sep 2023 02:01:38 -0400 Subject: [PATCH 01/12] release lab thread --- .gitignore | 9 + Makefile | 218 ++++++++++++++- conf/lab.mk | 1 + grade-lab-thread | 65 +++++ gradelib.py | 611 ++++++++++++++++++++++++++++++++++++++++++ notxv6/barrier.c | 78 ++++++ notxv6/ph.c | 150 +++++++++++ user/uthread.c | 162 +++++++++++ user/uthread_switch.S | 11 + 9 files changed, 1294 insertions(+), 11 deletions(-) create mode 100644 conf/lab.mk create mode 100755 grade-lab-thread create mode 100644 gradelib.py create mode 100644 notxv6/barrier.c create mode 100644 notxv6/ph.c create mode 100644 user/uthread.c create mode 100644 user/uthread_switch.S diff --git a/.gitignore b/.gitignore index 07216f3..3d25221 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,12 @@ mkfs kernel/kernel user/usys.S .gdbinit +myapi.key +*-handin.tar.gz +xv6.out* +.vagrant/ +submissions/ +ph +barrier +/lab-*.json +.DS_Store \ No newline at end of file diff --git a/Makefile b/Makefile index 39a99d7..5844ba3 100644 --- a/Makefile +++ b/Makefile @@ -1,14 +1,16 @@ + +# To compile and run with a lab solution, set the lab name in conf/lab.mk +# (e.g., LAB=util). Run make grade to test solution with the lab's +# grade script (e.g., grade-lab-util). + +-include conf/lab.mk + K=kernel U=user OBJS = \ $K/entry.o \ - $K/start.o \ - $K/console.o \ - $K/printf.o \ - $K/uart.o \ $K/kalloc.o \ - $K/spinlock.o \ $K/string.o \ $K/main.o \ $K/vm.o \ @@ -30,6 +32,34 @@ OBJS = \ $K/plic.o \ $K/virtio_disk.o +OBJS_KCSAN = \ + $K/start.o \ + $K/console.o \ + $K/printf.o \ + $K/uart.o \ + $K/spinlock.o + +ifdef KCSAN +OBJS_KCSAN += \ + $K/kcsan.o +endif + +ifeq ($(LAB),$(filter $(LAB), lock)) +OBJS += \ + $K/stats.o\ + $K/sprintf.o +endif + + +ifeq ($(LAB),net) +OBJS += \ + $K/e1000.o \ + $K/net.o \ + $K/sysnet.o \ + $K/pci.o +endif + + # riscv64-unknown-elf- or riscv64-linux-gnu- # perhaps in /opt/riscv/bin #TOOLPREFIX = @@ -57,12 +87,28 @@ OBJCOPY = $(TOOLPREFIX)objcopy OBJDUMP = $(TOOLPREFIX)objdump CFLAGS = -Wall -Werror -O -fno-omit-frame-pointer -ggdb -gdwarf-2 + +ifdef LAB +LABUPPER = $(shell echo $(LAB) | tr a-z A-Z) +XCFLAGS += -DSOL_$(LABUPPER) -DLAB_$(LABUPPER) +endif + +CFLAGS += $(XCFLAGS) CFLAGS += -MD CFLAGS += -mcmodel=medany CFLAGS += -ffreestanding -fno-common -nostdlib -mno-relax CFLAGS += -I. CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector) +ifeq ($(LAB),net) +CFLAGS += -DNET_TESTS_PORT=$(SERVERPORT) +endif + +ifdef KCSAN +CFLAGS += -DKCSAN +KCSANFLAG = -fsanitize=thread -fno-inline +endif + # Disable PIE when possible (for Ubuntu 16.10 toolchain) ifneq ($(shell $(CC) -dumpspecs 2>/dev/null | grep -e '[^f]no-pie'),) CFLAGS += -fno-pie -no-pie @@ -73,11 +119,17 @@ endif LDFLAGS = -z max-page-size=4096 -$K/kernel: $(OBJS) $K/kernel.ld $U/initcode - $(LD) $(LDFLAGS) -T $K/kernel.ld -o $K/kernel $(OBJS) +$K/kernel: $(OBJS) $(OBJS_KCSAN) $K/kernel.ld $U/initcode + $(LD) $(LDFLAGS) -T $K/kernel.ld -o $K/kernel $(OBJS) $(OBJS_KCSAN) $(OBJDUMP) -S $K/kernel > $K/kernel.asm $(OBJDUMP) -t $K/kernel | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > $K/kernel.sym +$(OBJS): EXTRAFLAG := $(KCSANFLAG) + +$K/%.o: $K/%.c + $(CC) $(CFLAGS) $(EXTRAFLAG) -c -o $@ $< + + $U/initcode: $U/initcode.S $(CC) $(CFLAGS) -march=rv64g -nostdinc -I. -Ikernel -c $U/initcode.S -o $U/initcode.o $(LD) $(LDFLAGS) -N -e start -Ttext 0 -o $U/initcode.out $U/initcode.o @@ -89,6 +141,10 @@ tags: $(OBJS) _init ULIB = $U/ulib.o $U/usys.o $U/printf.o $U/umalloc.o +ifeq ($(LAB),$(filter $(LAB), lock)) +ULIB += $U/statistics.o +endif + _%: %.o $(ULIB) $(LD) $(LDFLAGS) -T $U/user.ld -o $@ $^ $(OBJDUMP) -S $@ > $*.asm @@ -107,7 +163,7 @@ $U/_forktest: $U/forktest.o $(ULIB) $(OBJDUMP) -S $U/_forktest > $U/forktest.asm mkfs/mkfs: mkfs/mkfs.c $K/fs.h $K/param.h - gcc -Werror -Wall -I. -o mkfs/mkfs mkfs/mkfs.c + gcc $(XCFLAGS) -Werror -Wall -I. -o mkfs/mkfs mkfs/mkfs.c # Prevent deletion of intermediate files, e.g. cat.o, after first build, so # that disk image changes after first build are persistent until clean. More @@ -133,8 +189,79 @@ UPROGS=\ $U/_wc\ $U/_zombie\ -fs.img: mkfs/mkfs README $(UPROGS) - mkfs/mkfs fs.img README $(UPROGS) + + + +ifeq ($(LAB),$(filter $(LAB), lock)) +UPROGS += \ + $U/_stats +endif + +ifeq ($(LAB),traps) +UPROGS += \ + $U/_call\ + $U/_bttest +endif + +ifeq ($(LAB),lazy) +UPROGS += \ + $U/_lazytests +endif + +ifeq ($(LAB),cow) +UPROGS += \ + $U/_cowtest +endif + +ifeq ($(LAB),thread) +UPROGS += \ + $U/_uthread + +$U/uthread_switch.o : $U/uthread_switch.S + $(CC) $(CFLAGS) -c -o $U/uthread_switch.o $U/uthread_switch.S + +$U/_uthread: $U/uthread.o $U/uthread_switch.o $(ULIB) + $(LD) $(LDFLAGS) -N -e main -Ttext 0 -o $U/_uthread $U/uthread.o $U/uthread_switch.o $(ULIB) + $(OBJDUMP) -S $U/_uthread > $U/uthread.asm + +ph: notxv6/ph.c + gcc -o ph -g -O2 $(XCFLAGS) notxv6/ph.c -pthread + +barrier: notxv6/barrier.c + gcc -o barrier -g -O2 $(XCFLAGS) notxv6/barrier.c -pthread +endif + +ifeq ($(LAB),pgtbl) +UPROGS += \ + $U/_pgtbltest +endif + +ifeq ($(LAB),lock) +UPROGS += \ + $U/_kalloctest\ + $U/_bcachetest +endif + +ifeq ($(LAB),fs) +UPROGS += \ + $U/_bigfile +endif + + + +ifeq ($(LAB),net) +UPROGS += \ + $U/_nettests +endif + +UEXTRA= +ifeq ($(LAB),util) + UEXTRA += user/xargstest.sh +endif + + +fs.img: mkfs/mkfs README $(UEXTRA) $(UPROGS) + mkfs/mkfs fs.img README $(UEXTRA) $(UPROGS) -include kernel/*.d user/*.d @@ -144,7 +271,8 @@ clean: $U/initcode $U/initcode.out $K/kernel fs.img \ mkfs/mkfs .gdbinit \ $U/usys.S \ - $(UPROGS) + $(UPROGS) \ + ph barrier # try to generate a unique GDB port GDBPORT = $(shell expr `id -u` % 5000 + 25000) @@ -155,12 +283,22 @@ QEMUGDB = $(shell if $(QEMU) -help | grep -q '^-gdb'; \ ifndef CPUS CPUS := 3 endif +ifeq ($(LAB),fs) +CPUS := 1 +endif + +FWDPORT = $(shell expr `id -u` % 5000 + 25999) QEMUOPTS = -machine virt -bios none -kernel $K/kernel -m 128M -smp $(CPUS) -nographic QEMUOPTS += -global virtio-mmio.force-legacy=false QEMUOPTS += -drive file=fs.img,if=none,format=raw,id=x0 QEMUOPTS += -device virtio-blk-device,drive=x0,bus=virtio-mmio-bus.0 +ifeq ($(LAB),net) +QEMUOPTS += -netdev user,id=net0,hostfwd=udp::$(FWDPORT)-:2000 -object filter-dump,id=net0,netdev=net0,file=packets.pcap +QEMUOPTS += -device e1000,netdev=net0,bus=pcie.0 +endif + qemu: $K/kernel fs.img $(QEMU) $(QEMUOPTS) @@ -171,3 +309,61 @@ qemu-gdb: $K/kernel .gdbinit fs.img @echo "*** Now run 'gdb' in another window." 1>&2 $(QEMU) $(QEMUOPTS) -S $(QEMUGDB) +ifeq ($(LAB),net) +# try to generate a unique port for the echo server +SERVERPORT = $(shell expr `id -u` % 5000 + 25099) + +server: + python3 server.py $(SERVERPORT) + +ping: + python3 ping.py $(FWDPORT) +endif + +## +## FOR testing lab grading script +## + +ifneq ($(V),@) +GRADEFLAGS += -v +endif + +print-gdbport: + @echo $(GDBPORT) + +grade: + @echo $(MAKE) clean + @$(MAKE) clean || \ + (echo "'make clean' failed. HINT: Do you have another running instance of xv6?" && exit 1) + ./grade-lab-$(LAB) $(GRADEFLAGS) + +## +## FOR submissions +## + +submit-check: + @if ! test -d .git; then \ + echo No .git directory, is this a git repository?; \ + false; \ + fi + @if test "$$(git symbolic-ref HEAD)" != refs/heads/$(LAB); then \ + git branch; \ + read -p "You are not on the $(LAB) branch. Hand-in the current branch? [y/N] " r; \ + test "$$r" = y; \ + fi + @if ! git diff-files --quiet || ! git diff-index --quiet --cached HEAD; then \ + git status -s; \ + echo; \ + echo "You have uncomitted changes. Please commit or stash them."; \ + false; \ + fi + @if test -n "`git status -s`"; then \ + git status -s; \ + read -p "Untracked files will not be handed in. Continue? [y/N] " r; \ + test "$$r" = y; \ + fi + +zipball: submit-check + git archive --format=zip --output lab.zip HEAD + +.PHONY: zipball clean grade submit-check diff --git a/conf/lab.mk b/conf/lab.mk new file mode 100644 index 0000000..1e20dd0 --- /dev/null +++ b/conf/lab.mk @@ -0,0 +1 @@ +LAB=thread diff --git a/grade-lab-thread b/grade-lab-thread new file mode 100755 index 0000000..e43d7c6 --- /dev/null +++ b/grade-lab-thread @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 + +import re +import subprocess +from gradelib import * + + +r = Runner(save("xv6.out")) + +@test(20, "uthread") +def test_uthread(): + r.run_qemu(shell_script([ + 'uthread' + ])) + expected = ['thread_a started', 'thread_b started', 'thread_c started'] + expected.extend(['thread_%s %d' % (tid, n) for n in range(100) for tid in ('c', 'a', 'b')]) + expected.extend(['thread_c: exit after 100', 'thread_a: exit after 100', 'thread_b: exit after 100']) + expected.append('thread_schedule: no runnable threads') + if not re.findall('\n'.join(expected), r.qemu.output, re.M): + raise AssertionError('Output does not match expected output') + +# test the first ph task: add locks to eliminate the missing keys. +@test(10, "ph_safe") +def test_ph_safe(): + subprocess.run(['make', 'ph'], check=True) + result = subprocess.run(['./ph', '2'], stdout=subprocess.PIPE, check=True) + out = result.stdout.decode("utf-8") + matches = re.findall(r'^\d+: (\d+) keys missing$', out, re.MULTILINE) + assert_equal(len(matches), 2) + assert_equal(int(matches[0]), 0) + assert_equal(int(matches[1]), 0) + +# test the second ph task: locking that allows put() parallelism +@test(10, "ph_fast") +def test_ph_fast(): + subprocess.run(['make', 'ph'], check=True) + result = subprocess.run(['./ph', '2'], stdout=subprocess.PIPE, check=True) + out = result.stdout.decode("utf-8") + rate2 = re.findall(r' (\d+) puts.second$', out, re.MULTILINE) + assert_equal(len(rate2), 1) + result = subprocess.run(['./ph', '1'], stdout=subprocess.PIPE) + out = result.stdout.decode("utf-8") + rate1 = re.findall(r' (\d+) puts.second$', out, re.MULTILINE) + assert_equal(len(rate1), 1) + rate1 = float(rate1[0]) + rate2 = float(rate2[0]) + # demand that 2 threads yield at least 1.25x the + # throughput of a single thread. + if rate2 < 1.25 * rate1: + raise AssertionError('Parallel put() speedup is less than 1.25x') + +@test(14, "barrier") +def test_barrier(): + subprocess.run(['make', 'barrier']) + result = subprocess.run(['./barrier', '2'], stdout=subprocess.PIPE) + out = result.stdout.decode("utf-8") + if not re.match(r'^OK; passed$', out): + raise AssertionError('Barrier failed') + +@test(1, "time") +def test_time(): + check_time() + +run_tests() + diff --git a/gradelib.py b/gradelib.py new file mode 100644 index 0000000..e8d7814 --- /dev/null +++ b/gradelib.py @@ -0,0 +1,611 @@ +from __future__ import print_function + +import sys, os, re, time, socket, select, subprocess, errno, shutil, random, string +from subprocess import check_call, Popen +from optparse import OptionParser + +__all__ = [] + +################################################################## +# Test structure +# + +__all__ += ["test", "end_part", "run_tests", "get_current_test"] + +TESTS = [] +TOTAL = POSSIBLE = 0 +PART_TOTAL = PART_POSSIBLE = 0 +CURRENT_TEST = None + +def test(points, title=None, parent=None): + """Decorator for declaring test functions. If title is None, the + title of the test will be derived from the function name by + stripping the leading "test_" and replacing underscores with + spaces.""" + + def register_test(fn, title=title): + if not title: + assert fn.__name__.startswith("test_") + title = fn.__name__[5:].replace("_", " ") + if parent: + title = " " + title + + def run_test(): + global TOTAL, POSSIBLE, CURRENT_TEST + + # Handle test dependencies + if run_test.complete: + return run_test.ok + run_test.complete = True + parent_failed = False + if parent: + parent_failed = not parent() + + # Run the test + fail = None + start = time.time() + CURRENT_TEST = run_test + sys.stdout.write("== Test %s == " % title) + if parent: + sys.stdout.write("\n") + sys.stdout.flush() + try: + if parent_failed: + raise AssertionError('Parent failed: %s' % parent.__name__) + fn() + except AssertionError as e: + fail = str(e) + + # Display and handle test result + POSSIBLE += points + if points: + print("%s: %s" % (title, \ + (color("red", "FAIL") if fail else color("green", "OK"))), end=' ') + if time.time() - start > 0.1: + print("(%.1fs)" % (time.time() - start), end=' ') + print() + if fail: + print(" %s" % fail.replace("\n", "\n ")) + else: + TOTAL += points + for callback in run_test.on_finish: + callback(fail) + CURRENT_TEST = None + + run_test.ok = not fail + return run_test.ok + + # Record test metadata on the test wrapper function + run_test.__name__ = fn.__name__ + run_test.title = title + run_test.complete = False + run_test.ok = False + run_test.on_finish = [] + TESTS.append(run_test) + return run_test + return register_test + +def end_part(name): + def show_part(): + global PART_TOTAL, PART_POSSIBLE + print("Part %s score: %d/%d" % \ + (name, TOTAL - PART_TOTAL, POSSIBLE - PART_POSSIBLE)) + print() + PART_TOTAL, PART_POSSIBLE = TOTAL, POSSIBLE + show_part.title = "" + TESTS.append(show_part) + +def run_tests(): + """Set up for testing and run the registered test functions.""" + + # Handle command line + global options + parser = OptionParser(usage="usage: %prog [-v] [filters...]") + parser.add_option("-v", "--verbose", action="store_true", + help="print commands") + parser.add_option("--color", choices=["never", "always", "auto"], + default="auto", help="never, always, or auto") + (options, args) = parser.parse_args() + + # Start with a full build to catch build errors + make() + + # Clean the file system if there is one + reset_fs() + + # Run tests + limit = list(map(str.lower, args)) + try: + for test in TESTS: + if not limit or any(l in test.title.lower() for l in limit): + test() + if not limit: + print("Score: %d/%d" % (TOTAL, POSSIBLE)) + except KeyboardInterrupt: + pass + if TOTAL < POSSIBLE: + sys.exit(1) + +def get_current_test(): + if not CURRENT_TEST: + raise RuntimeError("No test is running") + return CURRENT_TEST + +################################################################## +# Assertions +# + +__all__ += ["assert_equal", "assert_lines_match"] + +def assert_equal(got, expect, msg=""): + if got == expect: + return + if msg: + msg += "\n" + raise AssertionError("%sgot:\n %s\nexpected:\n %s" % + (msg, str(got).replace("\n", "\n "), + str(expect).replace("\n", "\n "))) + +def assert_lines_match(text, *regexps, **kw): + """Assert that all of regexps match some line in text. If a 'no' + keyword argument is given, it must be a list of regexps that must + *not* match any line in text.""" + + def assert_lines_match_kw(no=[]): + return no + no = assert_lines_match_kw(**kw) + + # Check text against regexps + lines = text.splitlines() + good = set() + bad = set() + for i, line in enumerate(lines): + if any(re.match(r, line) for r in regexps): + good.add(i) + regexps = [r for r in regexps if not re.match(r, line)] + if any(re.match(r, line) for r in no): + bad.add(i) + + if not regexps and not bad: + return + + # We failed; construct an informative failure message + show = set() + for lineno in good.union(bad): + for offset in range(-2, 3): + show.add(lineno + offset) + if regexps: + show.update(n for n in range(len(lines) - 5, len(lines))) + + msg = [] + last = -1 + for lineno in sorted(show): + if 0 <= lineno < len(lines): + if lineno != last + 1: + msg.append("...") + last = lineno + msg.append("%s %s" % (color("red", "BAD ") if lineno in bad else + color("green", "GOOD") if lineno in good + else " ", + lines[lineno])) + if last != len(lines) - 1: + msg.append("...") + if bad: + msg.append("unexpected lines in output") + for r in regexps: + msg.append(color("red", "MISSING") + " '%s'" % r) + raise AssertionError("\n".join(msg)) + +################################################################## +# Utilities +# + +__all__ += ["make", "maybe_unlink", "reset_fs", "color", "random_str", "check_time", "check_answers"] + +MAKE_TIMESTAMP = 0 + +def pre_make(): + """Delay prior to running make to ensure file mtimes change.""" + while int(time.time()) == MAKE_TIMESTAMP: + time.sleep(0.1) + +def post_make(): + """Record the time after make completes so that the next run of + make can be delayed if needed.""" + global MAKE_TIMESTAMP + MAKE_TIMESTAMP = int(time.time()) + +def make(*target): + pre_make() + if Popen(("make",) + target).wait(): + sys.exit(1) + post_make() + +def show_command(cmd): + from pipes import quote + print("\n$", " ".join(map(quote, cmd))) + +def maybe_unlink(*paths): + for path in paths: + try: + os.unlink(path) + except EnvironmentError as e: + if e.errno != errno.ENOENT: + raise + +COLORS = {"default": "\033[0m", "red": "\033[31m", "green": "\033[32m"} + +def color(name, text): + if options.color == "always" or (options.color == "auto" and os.isatty(1)): + return COLORS[name] + text + COLORS["default"] + return text + +def reset_fs(): + if os.path.exists("obj/fs/clean-fs.img"): + shutil.copyfile("obj/fs/clean-fs.img", "obj/fs/fs.img") + +def random_str(n=8): + letters = string.ascii_letters + string.digits + return ''.join(random.choice(letters) for _ in range(n)) + +def check_time(): + try: + print("") + with open('time.txt') as f: + d = f.read().strip() + if not re.match(r'^\d+$', d): + raise AssertionError('time.txt does not contain a single integer (number of hours spent on the lab)') + except IOError: + raise AssertionError('Cannot read time.txt') + +def check_answers(file, n=10): + try: + with open(file) as f: + d = f.read().strip() + if len(d) < n: + raise AssertionError('%s does not seem to contain enough text' % file) + except IOError: + raise AssertionError('Cannot read %s' % file) + + +################################################################## +# Controllers +# + +__all__ += ["QEMU", "GDBClient"] + +class QEMU(object): + _GDBPORT = None + + def __init__(self, *make_args): + # Check that QEMU is not currently running + try: + GDBClient(self.get_gdb_port(), timeout=0).close() + except socket.error: + pass + else: + print("""\ +GDB stub found on port %d. +QEMU appears to already be running. Please exit it if possible or use +'killall qemu' or 'killall qemu.real'.""" % self.get_gdb_port(), file=sys.stderr) + sys.exit(1) + + if options.verbose: + show_command(("make",) + make_args) + cmd = ("make", "-s", "--no-print-directory") + make_args + self.proc = Popen(cmd, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + stdin=subprocess.PIPE) + # Accumulated output as a string + self.output = "" + # Accumulated output as a bytearray + self.outbytes = bytearray() + self.on_output = [] + + @staticmethod + def get_gdb_port(): + if QEMU._GDBPORT is None: + p = Popen(["make", "-s", "--no-print-directory", "print-gdbport"], + stdout=subprocess.PIPE) + (out, _) = p.communicate() + if p.returncode: + raise RuntimeError( + "Failed to get gdbport: make exited with %d" % + p.returncode) + QEMU._GDBPORT = int(out) + return QEMU._GDBPORT + + def fileno(self): + if self.proc: + return self.proc.stdout.fileno() + + def handle_read(self): + buf = os.read(self.proc.stdout.fileno(), 4096) + self.outbytes.extend(buf) + self.output = self.outbytes.decode("utf-8", "replace") + for callback in self.on_output: + callback(buf) + if buf == b"": + self.wait() + return + + def write(self, buf): + if isinstance(buf, str): + buf = buf.encode('utf-8') + self.proc.stdin.write(buf) + self.proc.stdin.flush() + + def wait(self): + if self.proc: + self.proc.wait() + self.proc = None + + def kill(self): + if self.proc: + self.proc.terminate() + +class GDBClient(object): + def __init__(self, port, timeout=15): + start = time.time() + while True: + self.sock = socket.socket() + try: + self.sock.settimeout(1) + self.sock.connect(("localhost", port)) + break + except socket.error: + if time.time() >= start + timeout: + raise + self.__buf = "" + + def fileno(self): + if self.sock: + return self.sock.fileno() + + def handle_read(self): + try: + data = self.sock.recv(4096).decode("ascii", "replace") + except socket.error: + data = "" + if data == "": + self.sock.close() + self.sock = None + return + self.__buf += data + + while True: + m = re.search(r"\$([^#]*)#[0-9a-zA-Z]{2}", self.__buf) + if not m: + break + pkt = m.group(1) + self.__buf = self.__buf[m.end():] + + if pkt.startswith("T05"): + # Breakpoint + raise TerminateTest + + def __send(self, cmd): + packet = "$%s#%02x" % (cmd, sum(map(ord, cmd)) % 256) + self.sock.sendall(packet.encode("ascii")) + + def __send_break(self): + self.sock.sendall(b"\x03") + + def close(self): + if self.sock: + self.sock.close() + self.sock = None + + def cont(self): + self.__send("c") + + def breakpoint(self, addr): + self.__send("Z1,%x,1" % addr) + + +################################################################## +# QEMU test runner +# + +__all__ += ["TerminateTest", "Runner"] + +class TerminateTest(Exception): + pass + +class Runner(): + def __init__(self, *default_monitors): + self.__default_monitors = default_monitors + + def run_qemu(self, *monitors, **kw): + """Run a QEMU-based test. monitors should functions that will + be called with this Runner instance once QEMU and GDB are + started. Typically, they should register callbacks that throw + TerminateTest when stop events occur. The target_base + argument gives the make target to run. The make_args argument + should be a list of additional arguments to pass to make. The + timeout argument bounds how long to run before returning.""" + + def run_qemu_kw(target_base="qemu", make_args=[], timeout=30): + return target_base, make_args, timeout + target_base, make_args, timeout = run_qemu_kw(**kw) + + # Start QEMU + pre_make() + self.qemu = QEMU(target_base + "-gdb", *make_args) + self.gdb = None + + try: + # Wait for QEMU to start or make to fail. This will set + # self.gdb if QEMU starts. + self.qemu.on_output = [self.__monitor_start] + self.__react([self.qemu], timeout=90) + self.qemu.on_output = [] + if self.gdb is None: + print("Failed to connect to QEMU; output:") + print(self.qemu.output) + sys.exit(1) + post_make() + + # QEMU and GDB are up + self.reactors = [self.qemu, self.gdb] + + # Start monitoring + for m in self.__default_monitors + monitors: + m(self) + + # Run and react + self.gdb.cont() + self.__react(self.reactors, timeout) + finally: + # Shutdown QEMU + try: + if self.gdb is None: + sys.exit(1) + self.qemu.kill() + self.__react(self.reactors, 5) + self.gdb.close() + self.qemu.wait() + except: + print("""\ +Failed to shutdown QEMU. You might need to 'killall qemu' or +'killall qemu.real'. +""") + raise + + def __monitor_start(self, output): + if b"\n" in output: + try: + self.gdb = GDBClient(self.qemu.get_gdb_port(), timeout=2) + raise TerminateTest + except socket.error: + pass + if not len(output): + raise TerminateTest + + def __react(self, reactors, timeout): + deadline = time.time() + timeout + try: + while True: + timeleft = deadline - time.time() + if timeleft < 0: + sys.stdout.write("Timeout! ") + sys.stdout.flush() + return + + rset = [r for r in reactors if r.fileno() is not None] + if not rset: + return + + rset, _, _ = select.select(rset, [], [], timeleft) + for reactor in rset: + reactor.handle_read() + except TerminateTest: + pass + + def user_test(self, binary, *monitors, **kw): + """Run a user test using the specified binary. Monitors and + keyword arguments are as for run_qemu. This runs on a disk + snapshot unless the keyword argument 'snapshot' is False.""" + + maybe_unlink("obj/kern/init.o", "obj/kern/kernel") + if kw.pop("snapshot", True): + kw.setdefault("make_args", []).append("QEMUEXTRA+=-snapshot") + self.run_qemu(target_base="run-%s" % binary, *monitors, **kw) + + def match(self, *args, **kwargs): + """Shortcut to call assert_lines_match on the most recent QEMU + output.""" + + assert_lines_match(self.qemu.output, *args, **kwargs) + +################################################################## +# Monitors +# + +__all__ += ["save", "stop_breakpoint", "call_on_line", "stop_on_line", "shell_script"] + +def save(path): + """Return a monitor that writes QEMU's output to path. If the + test fails, copy the output to path.test-name.""" + + def setup_save(runner): + f.seek(0) + f.truncate() + runner.qemu.on_output.append(f.write) + get_current_test().on_finish.append(save_on_finish) + + def save_on_finish(fail): + f.flush() + save_path = path + "." + get_current_test().__name__[5:] + if fail: + shutil.copyfile(path, save_path) + print(" QEMU output saved to %s" % save_path) + elif os.path.exists(save_path): + os.unlink(save_path) + print(" (Old %s failure log removed)" % save_path) + + f = open(path, "wb") + return setup_save + +def stop_breakpoint(addr): + """Returns a monitor that stops when addr is reached. addr may be + a number or the name of a symbol.""" + + def setup_breakpoint(runner): + if isinstance(addr, str): + addrs = [int(sym[:16], 16) for sym in open("kernel/kernel.sym") + if sym[17:].strip() == addr] + assert len(addrs), "Symbol %s not found" % addr + runner.gdb.breakpoint(addrs[0]) + else: + runner.gdb.breakpoint(addr) + return setup_breakpoint + +def call_on_line(regexp, callback): + """Returns a monitor that calls 'callback' when QEMU prints a line + matching 'regexp'.""" + + def setup_call_on_line(runner): + buf = bytearray() + def handle_output(output): + buf.extend(output) + while b"\n" in buf: + line, buf[:] = buf.split(b"\n", 1) + line = line.decode("utf-8", "replace") + if re.match(regexp, line): + callback(line) + runner.qemu.on_output.append(handle_output) + return setup_call_on_line + +def stop_on_line(regexp): + """Returns a monitor that stops when QEMU prints a line matching + 'regexp'.""" + + def stop(line): + raise TerminateTest + return call_on_line(regexp, stop) + +def shell_script(script, terminate_match=None): + """Returns a monitor that plays the script, and stops when the script is + done executing.""" + + def setup_call_on_line(runner): + class context: + n = 0 + buf = bytearray() + def handle_output(output): + context.buf.extend(output) + if terminate_match is not None: + if re.match(terminate_match, context.buf.decode('utf-8', 'replace')): + raise TerminateTest + if b'$ ' in context.buf: + context.buf = bytearray() + if context.n < len(script): + runner.qemu.write(script[context.n]) + runner.qemu.write('\n') + context.n += 1 + else: + if terminate_match is None: + raise TerminateTest + runner.qemu.on_output.append(handle_output) + return setup_call_on_line diff --git a/notxv6/barrier.c b/notxv6/barrier.c new file mode 100644 index 0000000..12793e8 --- /dev/null +++ b/notxv6/barrier.c @@ -0,0 +1,78 @@ +#include +#include +#include +#include +#include + +static int nthread = 1; +static int round = 0; + +struct barrier { + pthread_mutex_t barrier_mutex; + pthread_cond_t barrier_cond; + int nthread; // Number of threads that have reached this round of the barrier + int round; // Barrier round +} bstate; + +static void +barrier_init(void) +{ + assert(pthread_mutex_init(&bstate.barrier_mutex, NULL) == 0); + assert(pthread_cond_init(&bstate.barrier_cond, NULL) == 0); + bstate.nthread = 0; +} + +static void +barrier() +{ + // YOUR CODE HERE + // + // Block until all threads have called barrier() and + // then increment bstate.round. + // + +} + +static void * +thread(void *xa) +{ + long n = (long) xa; + long delay; + int i; + + for (i = 0; i < 20000; i++) { + int t = bstate.round; + assert (i == t); + barrier(); + usleep(random() % 100); + } + + return 0; +} + +int +main(int argc, char *argv[]) +{ + pthread_t *tha; + void *value; + long i; + double t1, t0; + + if (argc < 2) { + fprintf(stderr, "%s: %s nthread\n", argv[0], argv[0]); + exit(-1); + } + nthread = atoi(argv[1]); + tha = malloc(sizeof(pthread_t) * nthread); + srandom(0); + + barrier_init(); + + for(i = 0; i < nthread; i++) { + assert(pthread_create(&tha[i], NULL, thread, (void *) i) == 0); + } + for(i = 0; i < nthread; i++) { + assert(pthread_join(tha[i], &value) == 0); + } + printf("OK; passed\n"); +} diff --git a/notxv6/ph.c b/notxv6/ph.c new file mode 100644 index 0000000..82afe76 --- /dev/null +++ b/notxv6/ph.c @@ -0,0 +1,150 @@ +#include +#include +#include +#include +#include +#include + +#define NBUCKET 5 +#define NKEYS 100000 + +struct entry { + int key; + int value; + struct entry *next; +}; +struct entry *table[NBUCKET]; +int keys[NKEYS]; +int nthread = 1; + + +double +now() +{ + struct timeval tv; + gettimeofday(&tv, 0); + return tv.tv_sec + tv.tv_usec / 1000000.0; +} + +static void +insert(int key, int value, struct entry **p, struct entry *n) +{ + struct entry *e = malloc(sizeof(struct entry)); + e->key = key; + e->value = value; + e->next = n; + *p = e; +} + +static +void put(int key, int value) +{ + int i = key % NBUCKET; + + // is the key already present? + struct entry *e = 0; + for (e = table[i]; e != 0; e = e->next) { + if (e->key == key) + break; + } + if(e){ + // update the existing key. + e->value = value; + } else { + // the new is new. + insert(key, value, &table[i], table[i]); + } + +} + +static struct entry* +get(int key) +{ + int i = key % NBUCKET; + + + struct entry *e = 0; + for (e = table[i]; e != 0; e = e->next) { + if (e->key == key) break; + } + + return e; +} + +static void * +put_thread(void *xa) +{ + int n = (int) (long) xa; // thread number + int b = NKEYS/nthread; + + for (int i = 0; i < b; i++) { + put(keys[b*n + i], n); + } + + return NULL; +} + +static void * +get_thread(void *xa) +{ + int n = (int) (long) xa; // thread number + int missing = 0; + + for (int i = 0; i < NKEYS; i++) { + struct entry *e = get(keys[i]); + if (e == 0) missing++; + } + printf("%d: %d keys missing\n", n, missing); + return NULL; +} + +int +main(int argc, char *argv[]) +{ + pthread_t *tha; + void *value; + double t1, t0; + + + if (argc < 2) { + fprintf(stderr, "Usage: %s nthreads\n", argv[0]); + exit(-1); + } + nthread = atoi(argv[1]); + tha = malloc(sizeof(pthread_t) * nthread); + srandom(0); + assert(NKEYS % nthread == 0); + for (int i = 0; i < NKEYS; i++) { + keys[i] = random(); + } + + // + // first the puts + // + t0 = now(); + for(int i = 0; i < nthread; i++) { + assert(pthread_create(&tha[i], NULL, put_thread, (void *) (long) i) == 0); + } + for(int i = 0; i < nthread; i++) { + assert(pthread_join(tha[i], &value) == 0); + } + t1 = now(); + + printf("%d puts, %.3f seconds, %.0f puts/second\n", + NKEYS, t1 - t0, NKEYS / (t1 - t0)); + + // + // now the gets + // + t0 = now(); + for(int i = 0; i < nthread; i++) { + assert(pthread_create(&tha[i], NULL, get_thread, (void *) (long) i) == 0); + } + for(int i = 0; i < nthread; i++) { + assert(pthread_join(tha[i], &value) == 0); + } + t1 = now(); + + printf("%d gets, %.3f seconds, %.0f gets/second\n", + NKEYS*nthread, t1 - t0, (NKEYS*nthread) / (t1 - t0)); +} diff --git a/user/uthread.c b/user/uthread.c new file mode 100644 index 0000000..06349f5 --- /dev/null +++ b/user/uthread.c @@ -0,0 +1,162 @@ +#include "kernel/types.h" +#include "kernel/stat.h" +#include "user/user.h" + +/* Possible states of a thread: */ +#define FREE 0x0 +#define RUNNING 0x1 +#define RUNNABLE 0x2 + +#define STACK_SIZE 8192 +#define MAX_THREAD 4 + + +struct thread { + char stack[STACK_SIZE]; /* the thread's stack */ + int state; /* FREE, RUNNING, RUNNABLE */ +}; +struct thread all_thread[MAX_THREAD]; +struct thread *current_thread; +extern void thread_switch(uint64, uint64); + +void +thread_init(void) +{ + // main() is thread 0, which will make the first invocation to + // thread_schedule(). it needs a stack so that the first thread_switch() can + // save thread 0's state. thread_schedule() won't run the main thread ever + // again, because its state is set to RUNNING, and thread_schedule() selects + // a RUNNABLE thread. + current_thread = &all_thread[0]; + current_thread->state = RUNNING; +} + +void +thread_schedule(void) +{ + struct thread *t, *next_thread; + + /* Find another runnable thread. */ + next_thread = 0; + t = current_thread + 1; + for(int i = 0; i < MAX_THREAD; i++){ + if(t >= all_thread + MAX_THREAD) + t = all_thread; + if(t->state == RUNNABLE) { + next_thread = t; + break; + } + t = t + 1; + } + + if (next_thread == 0) { + printf("thread_schedule: no runnable threads\n"); + exit(-1); + } + + if (current_thread != next_thread) { /* switch threads? */ + next_thread->state = RUNNING; + t = current_thread; + current_thread = next_thread; + /* YOUR CODE HERE + * Invoke thread_switch to switch from t to next_thread: + * thread_switch(??, ??); + */ + } else + next_thread = 0; +} + +void +thread_create(void (*func)()) +{ + struct thread *t; + + for (t = all_thread; t < all_thread + MAX_THREAD; t++) { + if (t->state == FREE) break; + } + t->state = RUNNABLE; + // YOUR CODE HERE +} + +void +thread_yield(void) +{ + current_thread->state = RUNNABLE; + thread_schedule(); +} + +volatile int a_started, b_started, c_started; +volatile int a_n, b_n, c_n; + +void +thread_a(void) +{ + int i; + printf("thread_a started\n"); + a_started = 1; + while(b_started == 0 || c_started == 0) + thread_yield(); + + for (i = 0; i < 100; i++) { + printf("thread_a %d\n", i); + a_n += 1; + thread_yield(); + } + printf("thread_a: exit after %d\n", a_n); + + current_thread->state = FREE; + thread_schedule(); +} + +void +thread_b(void) +{ + int i; + printf("thread_b started\n"); + b_started = 1; + while(a_started == 0 || c_started == 0) + thread_yield(); + + for (i = 0; i < 100; i++) { + printf("thread_b %d\n", i); + b_n += 1; + thread_yield(); + } + printf("thread_b: exit after %d\n", b_n); + + current_thread->state = FREE; + thread_schedule(); +} + +void +thread_c(void) +{ + int i; + printf("thread_c started\n"); + c_started = 1; + while(a_started == 0 || b_started == 0) + thread_yield(); + + for (i = 0; i < 100; i++) { + printf("thread_c %d\n", i); + c_n += 1; + thread_yield(); + } + printf("thread_c: exit after %d\n", c_n); + + current_thread->state = FREE; + thread_schedule(); +} + +int +main(int argc, char *argv[]) +{ + a_started = b_started = c_started = 0; + a_n = b_n = c_n = 0; + thread_init(); + thread_create(thread_a); + thread_create(thread_b); + thread_create(thread_c); + thread_schedule(); + exit(0); +} diff --git a/user/uthread_switch.S b/user/uthread_switch.S new file mode 100644 index 0000000..5defb12 --- /dev/null +++ b/user/uthread_switch.S @@ -0,0 +1,11 @@ + .text + + /* + * save the old thread's registers, + * restore the new thread's registers. + */ + + .globl thread_switch +thread_switch: + /* YOUR CODE HERE */ + ret /* return to ra */ From 217952ff163928ed37ced7259b6cab88b5c5744a Mon Sep 17 00:00:00 2001 From: Sanjit Bhat Date: Wed, 13 Sep 2023 16:14:41 -0400 Subject: [PATCH 02/12] revert answers --- grade-lab-thread | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/grade-lab-thread b/grade-lab-thread index e43d7c6..18df65f 100755 --- a/grade-lab-thread +++ b/grade-lab-thread @@ -19,6 +19,11 @@ def test_uthread(): if not re.findall('\n'.join(expected), r.qemu.output, re.M): raise AssertionError('Output does not match expected output') +@test(5, "answers-thread.txt") +def test_answers(): + # just a simple sanity check, will be graded manually + check_answers("answers-thread.txt") + # test the first ph task: add locks to eliminate the missing keys. @test(10, "ph_safe") def test_ph_safe(): From 0db1b44fac1e9365875600aec80a19b55699f1f5 Mon Sep 17 00:00:00 2001 From: Sanjit Bhat Date: Tue, 19 Sep 2023 14:23:08 -0400 Subject: [PATCH 03/12] update grading and zipball rule --- .gitignore | 5 ++--- Makefile | 5 +++-- gradelib.py | 21 +++++++++++++++++++-- 3 files changed, 24 insertions(+), 7 deletions(-) diff --git a/.gitignore b/.gitignore index 3d25221..5c33438 100644 --- a/.gitignore +++ b/.gitignore @@ -15,12 +15,11 @@ mkfs kernel/kernel user/usys.S .gdbinit -myapi.key -*-handin.tar.gz +*.zip xv6.out* .vagrant/ submissions/ ph barrier /lab-*.json -.DS_Store \ No newline at end of file +.DS_Store diff --git a/Makefile b/Makefile index 5844ba3..c60ea76 100644 --- a/Makefile +++ b/Makefile @@ -272,6 +272,7 @@ clean: mkfs/mkfs .gdbinit \ $U/usys.S \ $(UPROGS) \ + lab.zip \ ph barrier # try to generate a unique GDB port @@ -363,7 +364,7 @@ submit-check: test "$$r" = y; \ fi -zipball: submit-check - git archive --format=zip --output lab.zip HEAD +zipball: clean submit-check + git archive --verbose --format zip --output lab.zip HEAD .PHONY: zipball clean grade submit-check diff --git a/gradelib.py b/gradelib.py index e8d7814..f0d4934 100644 --- a/gradelib.py +++ b/gradelib.py @@ -1,6 +1,6 @@ from __future__ import print_function -import sys, os, re, time, socket, select, subprocess, errno, shutil, random, string +import sys, os, re, time, socket, select, subprocess, errno, shutil, random, string, json from subprocess import check_call, Popen from optparse import OptionParser @@ -16,6 +16,7 @@ TOTAL = POSSIBLE = 0 PART_TOTAL = PART_POSSIBLE = 0 CURRENT_TEST = None +GRADES = {} def test(points, title=None, parent=None): """Decorator for declaring test functions. If title is None, the @@ -31,7 +32,7 @@ def register_test(fn, title=title): title = " " + title def run_test(): - global TOTAL, POSSIBLE, CURRENT_TEST + global TOTAL, POSSIBLE, CURRENT_TEST, GRADES # Handle test dependencies if run_test.complete: @@ -68,6 +69,9 @@ def run_test(): print(" %s" % fail.replace("\n", "\n ")) else: TOTAL += points + if points: + GRADES[title] = 0 if fail else points + for callback in run_test.on_finish: callback(fail) CURRENT_TEST = None @@ -95,6 +99,16 @@ def show_part(): show_part.title = "" TESTS.append(show_part) +def write_results(): + global options + if not options.results: + return + try: + with open(options.results, "w") as f: + f.write(json.dumps(GRADES)) + except OSError as e: + print("Provided a bad results path. Error:", e) + def run_tests(): """Set up for testing and run the registered test functions.""" @@ -105,6 +119,7 @@ def run_tests(): help="print commands") parser.add_option("--color", choices=["never", "always", "auto"], default="auto", help="never, always, or auto") + parser.add_option("--results", help="results file path") (options, args) = parser.parse_args() # Start with a full build to catch build errors @@ -120,6 +135,7 @@ def run_tests(): if not limit or any(l in test.title.lower() for l in limit): test() if not limit: + write_results() print("Score: %d/%d" % (TOTAL, POSSIBLE)) except KeyboardInterrupt: pass @@ -260,6 +276,7 @@ def check_time(): def check_answers(file, n=10): try: + print("") with open(file) as f: d = f.read().strip() if len(d) < n: From 13f5a4b511e0d7c8f559f532d3342a1dfb6d7153 Mon Sep 17 00:00:00 2001 From: Sanjit Bhat Date: Thu, 21 Sep 2023 10:30:11 -0400 Subject: [PATCH 04/12] clean all zip files, even old ones --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index c60ea76..365c91b 100644 --- a/Makefile +++ b/Makefile @@ -272,7 +272,7 @@ clean: mkfs/mkfs .gdbinit \ $U/usys.S \ $(UPROGS) \ - lab.zip \ + *.zip \ ph barrier # try to generate a unique GDB port From 705f7d36d3fa94b87e6671f4577d4121a25647bd Mon Sep 17 00:00:00 2001 From: Sanjit Bhat Date: Mon, 2 Oct 2023 17:30:42 -0500 Subject: [PATCH 05/12] ignore & clean dSYM files --- .gitignore | 1 + Makefile | 10 ++++------ 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/.gitignore b/.gitignore index 5c33438..29977c9 100644 --- a/.gitignore +++ b/.gitignore @@ -23,3 +23,4 @@ ph barrier /lab-*.json .DS_Store +*.dSYM diff --git a/Makefile b/Makefile index 365c91b..473a471 100644 --- a/Makefile +++ b/Makefile @@ -265,14 +265,12 @@ fs.img: mkfs/mkfs README $(UEXTRA) $(UPROGS) -include kernel/*.d user/*.d -clean: - rm -f *.tex *.dvi *.idx *.aux *.log *.ind *.ilg \ +clean: + rm -f *.tex *.dvi *.idx *.aux *.log *.ind *.ilg *.dSYM *.zip \ */*.o */*.d */*.asm */*.sym \ - $U/initcode $U/initcode.out $K/kernel fs.img \ - mkfs/mkfs .gdbinit \ - $U/usys.S \ + $U/initcode $U/initcode.out $K/kernel $U/usys.S \ + mkfs/mkfs fs.img .gdbinit \ $(UPROGS) \ - *.zip \ ph barrier # try to generate a unique GDB port From 9723a5f06fc2376bf3a2a8f2615557b0f7c47dcc Mon Sep 17 00:00:00 2001 From: Sanjit Bhat Date: Tue, 3 Oct 2023 15:40:54 -0500 Subject: [PATCH 06/12] Makefile: more cleaning --- Makefile | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/Makefile b/Makefile index 473a471..cced70f 100644 --- a/Makefile +++ b/Makefile @@ -266,10 +266,11 @@ fs.img: mkfs/mkfs README $(UEXTRA) $(UPROGS) -include kernel/*.d user/*.d clean: - rm -f *.tex *.dvi *.idx *.aux *.log *.ind *.ilg *.dSYM *.zip \ + rm -rf *.tex *.dvi *.idx *.aux *.log *.ind *.ilg *.dSYM *.zip \ */*.o */*.d */*.asm */*.sym \ - $U/initcode $U/initcode.out $K/kernel $U/usys.S \ - mkfs/mkfs fs.img .gdbinit \ + $U/initcode $U/initcode.out $U/usys.S $U/_* \ + $K/kernel \ + mkfs/mkfs fs.img .gdbinit __pycache__ xv6.out* \ $(UPROGS) \ ph barrier From b43a5b2b12d20ec0aa8de26dd273558b9bc4522b Mon Sep 17 00:00:00 2001 From: Sanjit Bhat Date: Tue, 3 Oct 2023 15:42:07 -0500 Subject: [PATCH 07/12] thread0 state free upon completion --- user/uthread.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/user/uthread.c b/user/uthread.c index 06349f5..18b773d 100644 --- a/user/uthread.c +++ b/user/uthread.c @@ -23,10 +23,8 @@ void thread_init(void) { // main() is thread 0, which will make the first invocation to - // thread_schedule(). it needs a stack so that the first thread_switch() can - // save thread 0's state. thread_schedule() won't run the main thread ever - // again, because its state is set to RUNNING, and thread_schedule() selects - // a RUNNABLE thread. + // thread_schedule(). It needs a stack so that the first thread_switch() can + // save thread 0's state. current_thread = &all_thread[0]; current_thread->state = RUNNING; } @@ -157,6 +155,7 @@ main(int argc, char *argv[]) thread_create(thread_a); thread_create(thread_b); thread_create(thread_c); + current_thread->state = FREE; thread_schedule(); exit(0); } From 0d65be5d1d880afafbf08c2adb605cf9f72216e2 Mon Sep 17 00:00:00 2001 From: Sanjit Bhat Date: Tue, 3 Oct 2023 15:48:00 -0500 Subject: [PATCH 08/12] Makefile: take out old clean uprogs --- Makefile | 1 - 1 file changed, 1 deletion(-) diff --git a/Makefile b/Makefile index cced70f..43d63c3 100644 --- a/Makefile +++ b/Makefile @@ -271,7 +271,6 @@ clean: $U/initcode $U/initcode.out $U/usys.S $U/_* \ $K/kernel \ mkfs/mkfs fs.img .gdbinit __pycache__ xv6.out* \ - $(UPROGS) \ ph barrier # try to generate a unique GDB port From 8acfe15f1a000e3c2da98ae9556db376d4acc3f4 Mon Sep 17 00:00:00 2001 From: novice <619671969@qq.com> Date: Thu, 29 Aug 2024 21:48:38 +0800 Subject: [PATCH 09/12] start multithreading lab :) --- packets.pcap | Bin 0 -> 17345 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 packets.pcap diff --git a/packets.pcap b/packets.pcap new file mode 100644 index 0000000000000000000000000000000000000000..74cee01825ec5ba419540c45e785d15d5a729174 GIT binary patch literal 17345 zcmb{42~IH-u&kG&iTFbZl~>j`*h#C-T&*||EoTIxJX|z zl-^zRBt7xLiMmUwyN6Arf#Q96X@E;;m}KP{p^%12Qg?Zc1WTWTrjow7SoDo6l=V_; zNs4t$Q>xXmiAqP+jPx|e*_mEWa_rO*6KQ~0MPB}nh0Cicj3hmUWMnAmg~G@3=j5~` z$>GNLG~a$MTJfa{sk8W`yu1f{+tP1@%7u4Tc}niJwE2LIEZ8MUR)sEttk)(7?N>^t%NpdUew1Q{z$gyK*QJA<%1ndwE7I=;kcKD6e8Z5So5q6^*g*5@#ej3c` z8Y8Tz7KIrBY#$94dXo{h=6e)o46sjVu%ugzFq_*bOaZWB8m#DNMp*tG6lMajy);Ix!(O{8vj4ltCT&rn!%fbF2c?mlOP{qZ{r6T>WVNGhViPP|}*U3`hcEC9Bh20QwS5q9A<3bO>* zHX5v=fe~h}_ih}mWdv&lu&p#$tv=HLUmn4l8KN+2fNi0{HaB5}RU4tO7698!gRN39 z!cLl?FdKkvqQO=)WrVFXLt(Z6E2P1GXvPTJ+Z=`20jz)q>tewO`%T2&KDyPiSGEM$ zMj9;8iV@~vjlx<1>|+{iOAAKWc^edF53mh1Sg{==>|je2CjP@Aj+N_aFdKVDn0ady z)&^i7(O`aU7-3D@qOi6A%csExwqu077BOV6YzMFpX)u3BMwqb^3UdJ1IvOn4nGt5| zg2EgDww4Av-kuSb(E)`y0W6OOyWq+QJLrbOoB_6m26OJj2(#~u!dw8hnh5K{2s7x4 z!rB9D6%9728zU^NI|}Onu$45}tsaap+ny-Q6=1nE*n(b+uqB=-%ne{GXfPiyMp%e9 z3hM~492%^q4Wlm^Qj$_PvGLt)}+E^$*Xp}}qrV}u#|qp)rO%cjAOj9`SF2|!`uxlXag z7Smt_fsC;HQ7Ehjz!uS9wxbzgc4JVO2f!B6U^T&vu$LhytS7*-Xs`ui8DVq6P*^X3 zEug_F!x>>;N1!lIfX%1D%EocR#-p&_0GmgHO^9NI`AkG%UI3d*gZ&uI2s;sj!n^@C zhX!+)%m}L!G31eWAArrK!3yITVe{fqSYLq6qQOj+jId}G3hM{3Od9NEA|vcgG79St zu$eTNY6>GPB^8By-L8;G??vlMwt5y6y^i488p}fH6zS< zCJOTf*mN4~MkXWd%`6l)2w>A_u-S7MVcBz0*kFLA(_r`JF~Y9QM`1$%HkAeo%wmKk zE<|BN0hUIC4Oq+w3(H1fegI3Q!F-o8!c@ypm^dj^{2iM@g9R*Sg!$&6u;Bnpp}`KX zV1(_jJn0!&GRm9A%mqX3pbgZ0|T2(v3dVLgr2CFY&gxxxT!omR-MT7M}#0YC!iozlQHh~5^ zR>lY`5Hp&PV`U`3#?xTdVnP$k>?rx<$v;I5fsF&$I2tVMC?hQBQxrBHV39P~yC0@uw|by!q%NYVNn2kJJs!frkHj3f)VC+5`|3!SQu@K?Jj48?fMdhMFVUs z4d!&35$19Rg~b3Ylm^Q^%LrTl6$+aKun-z7_8cQD`8*1n46tAt?9>HDSlKryEEZs6 zXs|998DXmLP*@zmM$=#(6^yXRN)#3kupk=DwTcnery7MN0BjTu_Ui+kV3q$l#aTXx z*FMrIb{UNgd#qEe3XNqw(J5Aq#_a2Kiq)X8hNn8kuAni`XFA2MqOpeOI>oM`v78q= z#cI)*(JP%|*U{J=G20y(c`9LV3e?z}u8SG*X4+@Ow<<$hDrk+=Xw`~VGwm%0yp;&8 z0FBl)(Q2-}<$|}8pfy6Hbyc*?wYOaHRx-5wHCk6h%R+mrBi>4Z)^Lqhjc8eFZ@J^G zDbO0G(W(|LEA6fBcqE`Ix-42Pw6{F*)>LQ>(P&kQmW}q- z@%yHd_=g%S@4beE{Nfhkc|7^WE&9nPl$$HW#mz$MEr~Pw>`TNeF^H>tF`Sl=u5J>q zj!jNANK4KzP$tZjzosW23i78e<`s<)0w+7X1Nv2KFV37s&;z SUT)U-9Y)!b;Udq)S$_fTOm%et literal 0 HcmV?d00001 From 506b52c16b3665bf110838e6cfd239c293cdb87d Mon Sep 17 00:00:00 2001 From: novice <619671969@qq.com> Date: Sat, 31 Aug 2024 13:43:26 +0800 Subject: [PATCH 10/12] finished multithreading lab part one Uthread:switching between threads :) --- .../clangd/index/bio.c.34489AC9E3FB27B2.idx | Bin 0 -> 3466 bytes .../clangd/index/buf.h.7DA89D0539A50AFB.idx | Bin 0 -> 870 bytes .../index/console.c.A959DCA84FDA00CD.idx | Bin 0 -> 3094 bytes .../clangd/index/defs.h.72A9C4FFB86E6400.idx | Bin 0 -> 12100 bytes .../clangd/index/elf.h.B51ED6807EFE6571.idx | Bin 0 -> 2096 bytes .../clangd/index/entry.S.7790893A73F2EC77.idx | Bin 0 -> 266 bytes .../clangd/index/exec.c.C583EF6E813AE52A.idx | Bin 0 -> 2618 bytes .../clangd/index/fcntl.h.204FC1983BB1DFC2.idx | Bin 0 -> 260 bytes .../clangd/index/file.c.E75BF18666EA6C16.idx | Bin 0 -> 3928 bytes .../clangd/index/file.h.2A63A83574D7D652.idx | Bin 0 -> 2174 bytes .cache/clangd/index/fs.c.DE158A81433875BE.idx | Bin 0 -> 9784 bytes .cache/clangd/index/fs.h.F83902F1C88C3791.idx | Bin 0 -> 1726 bytes .../index/initcode.S.373AF54AA740F373.idx | Bin 0 -> 486 bytes .../index/kalloc.c.2F15DD93067E2B26.idx | Bin 0 -> 2048 bytes .../index/kernelvec.S.06F25524429F6CAE.idx | Bin 0 -> 266 bytes .../clangd/index/log.c.D81C51C68A1AD96E.idx | Bin 0 -> 5634 bytes .../clangd/index/main.c.2DC262271CAFD048.idx | Bin 0 -> 1142 bytes .../index/memlayout.h.0B2C565D58B84A48.idx | Bin 0 -> 562 bytes .../clangd/index/param.h.37451DCC2B36E012.idx | Bin 0 -> 444 bytes .../clangd/index/pipe.c.2473E067140E4F18.idx | Bin 0 -> 2820 bytes .../clangd/index/plic.c.2EA8519EDD3A2B20.idx | Bin 0 -> 1156 bytes .../index/printf.c.0918689B2930FAE2.idx | Bin 0 -> 2012 bytes .../clangd/index/proc.c.5346DCDE506E9F58.idx | Bin 0 -> 11550 bytes .../clangd/index/proc.h.27341B4843D3B8B6.idx | Bin 0 -> 6048 bytes .../clangd/index/riscv.h.6737E35D6CB953E7.idx | Bin 0 -> 4872 bytes .../index/sleeplock.c.BC30DEE970D57711.idx | Bin 0 -> 1440 bytes .../index/sleeplock.h.56E9B1C95DBCB92F.idx | Bin 0 -> 486 bytes .../index/spinlock.c.1B29CD753041D103.idx | Bin 0 -> 1742 bytes .../index/spinlock.h.7E8FC04641EE310E.idx | Bin 0 -> 428 bytes .../clangd/index/start.c.92F9EB51DC5F96B3.idx | Bin 0 -> 1682 bytes .../clangd/index/stat.h.AEE4CE7ADDE89C85.idx | Bin 0 -> 608 bytes .../index/string.c.87F56374FD494C3A.idx | Bin 0 -> 1018 bytes .../clangd/index/swtch.S.11DB57B07ECB88BC.idx | Bin 0 -> 266 bytes .../index/syscall.c.05D088F49A8C83CC.idx | Bin 0 -> 4570 bytes .../index/syscall.h.66E962A052CADC6A.idx | Bin 0 -> 630 bytes .../index/sysfile.c.C337A604B3627C12.idx | Bin 0 -> 6948 bytes .../index/sysproc.c.E5BC46BBC06178C3.idx | Bin 0 -> 1776 bytes .../index/trampoline.S.ABB830BE366004AD.idx | Bin 0 -> 406 bytes .../clangd/index/trap.c.E331BC8CB04ABF35.idx | Bin 0 -> 3624 bytes .../clangd/index/types.h.9C15A82D28EB699F.idx | Bin 0 -> 620 bytes .../clangd/index/uart.c.382E637B5067D2B7.idx | Bin 0 -> 2172 bytes .../index/virtio.h.7AE2FDAEE3C87964.idx | Bin 0 -> 2640 bytes .../index/virtio_disk.c.8DF9309BB95BE078.idx | Bin 0 -> 7156 bytes .cache/clangd/index/vm.c.70D05D5C0213F437.idx | Bin 0 -> 6386 bytes .gdbinit.tmpl-riscv | 6 + compile_commands.json | 702 ++++++++++++++++++ user/uthread.c | 48 ++ user/uthread_switch.S | 32 + 48 files changed, 788 insertions(+) create mode 100644 .cache/clangd/index/bio.c.34489AC9E3FB27B2.idx create mode 100644 .cache/clangd/index/buf.h.7DA89D0539A50AFB.idx create mode 100644 .cache/clangd/index/console.c.A959DCA84FDA00CD.idx create mode 100644 .cache/clangd/index/defs.h.72A9C4FFB86E6400.idx create mode 100644 .cache/clangd/index/elf.h.B51ED6807EFE6571.idx create mode 100644 .cache/clangd/index/entry.S.7790893A73F2EC77.idx create mode 100644 .cache/clangd/index/exec.c.C583EF6E813AE52A.idx create mode 100644 .cache/clangd/index/fcntl.h.204FC1983BB1DFC2.idx create mode 100644 .cache/clangd/index/file.c.E75BF18666EA6C16.idx create mode 100644 .cache/clangd/index/file.h.2A63A83574D7D652.idx create mode 100644 .cache/clangd/index/fs.c.DE158A81433875BE.idx create mode 100644 .cache/clangd/index/fs.h.F83902F1C88C3791.idx create mode 100644 .cache/clangd/index/initcode.S.373AF54AA740F373.idx create mode 100644 .cache/clangd/index/kalloc.c.2F15DD93067E2B26.idx create mode 100644 .cache/clangd/index/kernelvec.S.06F25524429F6CAE.idx create mode 100644 .cache/clangd/index/log.c.D81C51C68A1AD96E.idx create mode 100644 .cache/clangd/index/main.c.2DC262271CAFD048.idx create mode 100644 .cache/clangd/index/memlayout.h.0B2C565D58B84A48.idx create mode 100644 .cache/clangd/index/param.h.37451DCC2B36E012.idx create mode 100644 .cache/clangd/index/pipe.c.2473E067140E4F18.idx create mode 100644 .cache/clangd/index/plic.c.2EA8519EDD3A2B20.idx create mode 100644 .cache/clangd/index/printf.c.0918689B2930FAE2.idx create mode 100644 .cache/clangd/index/proc.c.5346DCDE506E9F58.idx create mode 100644 .cache/clangd/index/proc.h.27341B4843D3B8B6.idx create mode 100644 .cache/clangd/index/riscv.h.6737E35D6CB953E7.idx create mode 100644 .cache/clangd/index/sleeplock.c.BC30DEE970D57711.idx create mode 100644 .cache/clangd/index/sleeplock.h.56E9B1C95DBCB92F.idx create mode 100644 .cache/clangd/index/spinlock.c.1B29CD753041D103.idx create mode 100644 .cache/clangd/index/spinlock.h.7E8FC04641EE310E.idx create mode 100644 .cache/clangd/index/start.c.92F9EB51DC5F96B3.idx create mode 100644 .cache/clangd/index/stat.h.AEE4CE7ADDE89C85.idx create mode 100644 .cache/clangd/index/string.c.87F56374FD494C3A.idx create mode 100644 .cache/clangd/index/swtch.S.11DB57B07ECB88BC.idx create mode 100644 .cache/clangd/index/syscall.c.05D088F49A8C83CC.idx create mode 100644 .cache/clangd/index/syscall.h.66E962A052CADC6A.idx create mode 100644 .cache/clangd/index/sysfile.c.C337A604B3627C12.idx create mode 100644 .cache/clangd/index/sysproc.c.E5BC46BBC06178C3.idx create mode 100644 .cache/clangd/index/trampoline.S.ABB830BE366004AD.idx create mode 100644 .cache/clangd/index/trap.c.E331BC8CB04ABF35.idx create mode 100644 .cache/clangd/index/types.h.9C15A82D28EB699F.idx create mode 100644 .cache/clangd/index/uart.c.382E637B5067D2B7.idx create mode 100644 .cache/clangd/index/virtio.h.7AE2FDAEE3C87964.idx create mode 100644 .cache/clangd/index/virtio_disk.c.8DF9309BB95BE078.idx create mode 100644 .cache/clangd/index/vm.c.70D05D5C0213F437.idx create mode 100644 compile_commands.json diff --git a/.cache/clangd/index/bio.c.34489AC9E3FB27B2.idx b/.cache/clangd/index/bio.c.34489AC9E3FB27B2.idx new file mode 100644 index 0000000000000000000000000000000000000000..2b91e98f320f1b67343dcc187b26b9ab31cf1bb3 GIT binary patch literal 3466 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/elf.h.B51ED6807EFE6571.idx b/.cache/clangd/index/elf.h.B51ED6807EFE6571.idx new file mode 100644 index 0000000000000000000000000000000000000000..5099316424cb6b08d1bf1425fd300d52bd7d4894 GIT binary patch literal 2096 zcmX|B3v5(H6uq6c`(}1$r`>JAcDuVR1hQ=d3WUnHQA&l<$e(}+L;)*E*r457%O`vz zKZQgifs~?rDiYCH2}C}clqzkYK($eVSj7NRs34!j*fbKo^UU$>?s=PY=FaENxp&%x zapUqO(b$(J)Wj>Q=BE%*2LBROm9L!Ox06IvQ&&8Bj%gaCTc=hh<%fc~qv&b}?RY$1 z*t4s4NPJZB?4s_n0sXh%ZT#7}Bmdl-8ts2-|H78VAGh5ecIot~l(IX+Qgrnbq1L3Y zY1fk3r?W8COZYb>OnR|2hyCYK{U7Nn<_Gew&`p=(Ix#nPXbI#?xk+I)z zTvalr(_i}bk+YYY>cz4Ld`LaCDgTDI}$n`8B_tvfkMCZ^YY z-muF1f-IUFqr~#~0wV#xdFj;zQdfZ~6G*2eIyup;VR~>G)iL zyfQZJ&0wpHaC9$HAr&$%Kz?{`;*&p&zFTN0#B#RE_PYSN_rNQ)eV=YCGNgHOe$ril zJa2KscRiEza6@SvouhKJ3y@1@RCYh}$%7GwQaCzIrSX>m@}VDVZq(k`I@(Y=M@Lk| zxBz)*-$iQXpTmIT<$ne^^D%ZFG`Ip9;_~t`<_8aQW(LojDF9YPa-nnzG;-~eW8p>ul zQ)LERfSkPI>^~>&1&$aBvK&wW;{xPwd$q2;RdwPE4`mXmEGNsjK#EB4g&x0hp`_d- zpE2a+twmKd%>_h%)I4-q`_Yljh92X|GgO9g0dm>pqQ8gizRq%pWvQg!1<2!@77cw= zU(s$ThbIrKuyFzM#N%@gKll5X4ntv%_BvkU0_5LX%2!_KbLN_%ESCMsZ(M+Uv2A_F zfbfz(Jmlenr8=p87wo~f3Tb2gm-z!n?0aA+nb*!!dBz1q>kU=Kp{4J48;jtWJt4*kZzd zu1_{MR^OUBFPW=Pcs$s(R$k%tz)jq+gz@0sPOpfz&ulsQBF~gB^K<@7JW*+==lqU> z!K*k6KH-ya1Ls6&i6m*|7k&vFa<>sV61SjLScD}Eu2n=tByz4*R752zORHRwE71b9 z$`g4K=Iq+%c-F>muM=8ji);x)XcZD62{R#-k6>E|t`d1<+I9=%=w9cF`>!7hA57B9 z5sm|+BC|Z&b`Xrl)i7;42WYIpwCxzk+J-H2`?YO)wvp+6vR^OII4RS%fgrfEHc>rj zb>s}w1+w6O*U#G7b@TeZ21^Sm0+<9wVA{4B>;#@;+O`+aNIcWFtzb!bfN9%KFdA3L zv~44x@n+h#59|b&!?bN1m>V8p+O`V>bEjB3--aeC7bbl6k4k;&{DMYZyqM@;{~t)Q literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/entry.S.7790893A73F2EC77.idx b/.cache/clangd/index/entry.S.7790893A73F2EC77.idx new file mode 100644 index 0000000000000000000000000000000000000000..e8940671fac11570a3b66ea7e3f69ab66dd0c028 GIT binary patch literal 266 zcmWIYbaP{3WMFVk@vO*AElFfyU|+>5uhU-bW2EU)-PkV!EuNv_#lwmdKN+1IYgPhTE0^grSh(-E6J zGiFNvGwV607o12n3p82j;j!ZR1AnvI4T@JL74jBw25PIc%Jk=3Z<)O;*GlDeJj>fQ zyKijL{M##gms_;%`&6{?P2GwIi{_a+etz*i&40$K#oK$<`^&h#Nb%f$;Qwy{(Hpcoqm2NN?3 I7b_z>04ug;@Bjb+ literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/exec.c.C583EF6E813AE52A.idx b/.cache/clangd/index/exec.c.C583EF6E813AE52A.idx new file mode 100644 index 0000000000000000000000000000000000000000..0255870826e7df257b8d6f8f02eb707bb9270ccf GIT binary patch literal 2618 zcmY*a3s_TC9KYwXvE6YQdx0<>7dBurMMZ`ZKI#B1{dB1PF=lA=+|NnE&P1ncAPvv2l zE=O-JTvBXgVHhTczoKGOUIoA~4kXOm>gOcqdxr_?8*b?M`tO?WCUd{Ju1n;(vhcis z1i9hxp#!_-$G_YY{A*jn=?^bnG_*EucwDh6T$;z)tC&1gekHfAzAgJ)N_MYYZPk=r z5@w%Uzb9PV+?2cWrOh`EU&&fz{5|h-lfmiwPu~vq{LuMe_O;g@D2E?D`F(3&q-}$( zGwR*e54bLk;J2uNGqV);?E6$<()AlJRjEhT)DOIP`S9%WoR-Ji<5PDpU3Yv%z?`2K zNBw0mR2I&<@F{4jE(n<@pI^_f$=sOQRidp}JJsz~?*7`{y(@Pb%53F9ZQ&ZPrlOFo$$n3ifR}+?zTiP{Wm7MH8KJ<=9;_4ai?Vc35^`D-!f#B1@ ze&Oll$O&ED2Q58Eb_5gU=OsU#T97Qf_4D4|%Bvy0rhz;CA!TnK8`R6bcVk(zV|1?+ zhO5m^!twJgMXL&5T?D6c=KbRP9 zNh}zOU05#su|H@y_RRC>53jT?H6n_-9M3G)DI?MHiv{tW8L3C{g5%ARX@pwqr0iq5FQJ_E0Bv1PxW>5(Qk-SJg z($C60&^?kuPKUH^f^HI`$<}Xe!(?s@PEtmWk=7=u0(Jq3lvJ{1)~0Kf8fdE$t2`0? zXim<4(@K3Tq|LaQ)|Q06^?Kj!%s5Dg5}~xqJ@Xps@+E2=q}^QI=<S!9iL_@3&N(QS8ltRhR{438EniHY*WAgTi^w z4G6Y1T009V_0Q)2Y8gn&Vv`i1BBrCJLKH>JV2~Ze*n!p&>+K+!!8HJ{0nP}cw-fQ) zn2x~G(3?3*!l3LAPO&5Oqdf4!A#m*H_i4s#@j8dX= zB0Z4W$@#{zgEc1DG>gC@MoJ|WAjfuWMX?hsZUQj{B}q~~gb$q+39|~bgK0>b(j=U@ z@#g$hFrZW>9gmVFsReEe+!5*<7t4BN6_!FJKitn11swIowF5EoHB&lrt|la`l!OWR z5HdtV&$yJ!7%9a{hr%MwIrh-!>R7 z9*?JIO;S~WRR!qz`Fv$5m7du13ACmNiXMeE``(kUJtyvm);56KfWwig0IUi?Z?~TI zh4Q5XhYxZ{N+Z&EqB>wz6Vk&Nl;NEbz@SWVrWb>@0O=Os&){u9unl-HxB>7QfB<2q zw@?3b?1AtQOjzZw3PN4zazASuC_eTDqBR8A`G1RJ;^Yq;I< zC8W0k=dHj6&91C^VPI!v(g`St6h%@fXm{do_cqKForLYk;$_j^;hm^7PC+Rg?L8lt z$aiXoN@{nt!zR>)>*#4^*519`g&&On9wV<~AR=nochI&(QsRqTl2j?X zl%ADa#*ypy*T;3j&7ou~=}D7R1Si5_z>R>@2uM`X!G3jD+o>PBV88%8fHq1vxlHx< zt|b@YJr>Q2cHC(G(R5ScOnDjynKnc_iAhc8tCJ!0Fg5AY(fsaTU=%`3c%tCb*1nOV zO{=*J%hK|-^rnHkgG{Hl)P>G9eG`3_--ou|gf|netXLy0*!~347O90ok)A&5-jmfa zV;D9ekQGSRLsAKNg2QpH2CQm8OSNMDqMF82qedpSiEb$L%(gfnE89w=vsWqoCSt<~ z3~v&c=~;#rZKT9U{DWD5gvaY<383y`(~;)*%R9;eTEZoPE<`uP**eXpKB zt$*6b@9O!pI-Tn^j4!h%-JNq}Nm8sbvvTs^H&+(zxgzs-%ac8mWcKo~G1z7bCly!b zCIO9MC`wH$E(X#o#EcpR1MZYFaxt=Su<(PVK%i#dg7rJQ_O1j9GjlKtKm-{W{9iM* zxW!4V0SYs5F!8~JgFeskkBj_z0VvGC!2nn7UTFA5W9Q^sKw(A>Mz}E0?wmxB*5ab% TVr~$FvB#fx(}$;%>lqjTuxm=C literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/file.c.E75BF18666EA6C16.idx b/.cache/clangd/index/file.c.E75BF18666EA6C16.idx new file mode 100644 index 0000000000000000000000000000000000000000..1d6ec423c79917e4de3971e424246dfd8a11ac53 GIT binary patch literal 3928 zcmY*b3s_S}7M_U#a+3)+4P!{@^Mb_EB?Y#8Apk&$|5lr2(L4bF?XCcnZfl&=_vY0w*`){1#FGY_fDq*YaZSDMkHe#)kdR55F%)b z4&7hcKV#gFJ?jbEMJsV;GX&Ev8MFXp7G^#lTWJ>F2*U6M#P@D@cE*TeldS4ZP$Bt*2oIm z%te1XQ@2LlHs+zLPeT2v%{5h@nRW-H4_spk|J@yF`og8D(6j4W$K2R~wKICtuWSrB zyY}#dLspmUtm2yO?>!RVwWFvX4h;4DKHGAnqQYZN$K2mziWeX5@p-lQVzAE|{kZk& zF5m96zYaIQ@4Dlw^DEU;mUjAlbLYG0cQ$R;T>h`{ZTqU;xZ&sDpL6x+w5Z1LV;`h> z4|+z-eK;((eMG}6dA{-YGxggCi{m3BwrqU%yIa|VO+k&{ukQkHlufc(%a+VbhX8oJ zsn@9N|I#Bc2>`Adf@;VZbTXYcU_`@4!~}tug3YPM!F54W5RE4&1xnG22QJnZzkJ*6 zdmrCjWfYOXu$=$F+taFbN{Fg^C3WnFE1zB{v83WBkjm9mPEK#xG|jkk^q1aCf( zF73&$X+&T=Hiv>xH^Xq*aFt_mop~fsk5Ba3l3Um84o0~EPT{Ulym1{z2)k1wObYkKR#eZa%OeBd# z;+GPNI5ko$oZ@g=iB|5^g42m{Z4hNRosUjSQ6L-WNl~yQnCEAd80F4%aVCk0hhii# zaw>pXYF1K|C`okMGG@76&hJbxU@4c1mdc1qqylk(j`Abn-8{Bu)oQOt9Gr_H6yaovZ7gxdNMrNoA(L$aMJ4hQFN$iRxE8X6F5+sT zrWX41v8fhLptuey>!6z8gXXmc&Ne$5^V$j7ozRmQvhJylZc6)dCN8RMVKzeuBd%0f z%Fx}Lp=&dg5U1Pv!v2Pah%~%fjxfjRbbP+KN1JmmOMv5=Xq!yEOVlO41XY}kFE7;k zks zlynos`MUW^Xr22r{!)rU+(IO@&O_NyB}Gy4DBeMz#7vUX*wba{9)uC%ieyC|G>mE} zucrAzn$o_38L1VRZ>lg=M3%_hsVk0MpH_iYEekArg?g7W<%pu45T`$kNP@UsP_hfU z6WmgG=X%k9tQ9zawQyoBj3oxd)j>@it+sg0c)n%Vo7Y_;vctmTYcPOb`4LBqr^-9w1e$#uNOsnh935^c8Sys_`(^ZGV~ zxCEC3r!1JGXgZ=CQ`i(<&rBJaGK$)=L|KUDC(A!ePth{bGG1+1S*wypx`JK7Lp4xT z0}+YaaUR(Xw09z|9HOV>}{dy=`4`pOp zzWC%XrU{X!F@Zcqo)6(=|KZ}@{*;klQr)R{wlte1lW?b#=I~H1n=7ZbQfVo# zsh4?{@oJ`mt&me)n<3i_<%E%=8+-4hS3KfcpuB}D$)+8+K46bKhZ&clGUqZKH^%oK zJ$0!U$2&tfgI5Vn(6x!4=V{#+k0C?bw{D2ji}k!VHG&y|NR1&bTolf0T4P+sh)7{0 zZn9{ygbETTj&mMD#7%RV=IlQ;tN&KO%=!3|qpPb@{HaTpEK5ywTA^CO>ksu%RZpAB zp#4#s`v&Dz9BU?%>8zSn`9*CFMZN#T!xoXndF>AzYvQiV-g^y8pinB*fQCs(i_nAfgM0u!%D%|bIzphQ8U zvt*w>JKvgpGI|IzoGF|srjoQm*H(I%NP7^AU;2W?pDjwYiUfdLrb6pQcw>HEff|Z} z6~R24QGvT0`84KC3KI{-C}O-Q5wnL`O;MsE(P_iquZ!~?x>zmqt!o`GVUEZDf8pc> z026(6ei;D}Nk_-fR|9>Gps&tc0bq2FLay5{zC82b_UYota6?$=n1~RQ5zJq*V6iuz d-3d@bKCP% zcU3%{b^h1LtlFA}CXabAtY?4KBCmay>EiViOHcf{`iKdchZ|z+PM$oL(5q@|rzLJ| z%{|)F^yT^f=}oWHtmy1cUK1PfqZV;Fc<0SIb^B8DyKZ@=PVAdnv|1}`c{O+Ok&!u$ zOWDd5Zw%YE91llLSf& zUV0;hka4~bk}t1WC#uA(63J$@g)<;f9QtK^y&y68VT!_2LW&ZiWCp}AT(4$ZZbv_#16?rgbTFhWFioW z0m}1tdS0GflU}ZpFxXoV1S11XzH7;i3(KwrK#qcwdqj`I0OeVM%A&zf=2t675GmRg zZD+|{Jn=WDg}3!gsntj*y_kiwGr+~$GZ#00Ggu#l2c>c%_ap<9cNgF8t2V+gwSXMXJUZz-5q_tsy%l)RPqqWp+cy}0OhxTK7F(IxtMQN zVgi{r@fHRsPdjq@D>*LM1vLj*$LkCXP~K2^FwgM9$2}U+(Y>AA!wgU!TUfB;i<8_v zl?ZThvtTwdKzZXmADfc5@_m1q?aB)yJB?Ly%?Zl#aL~4e}eu5nwk^0L|+0; zO^Hd+k3ds1;%f9E(A0#u8vO?}H6NDX_cZm=YgcD2)XS2f6L_?OESYs?9^X)wEIJF1 zy(mjgos-9#LFIKW9v=j447*SdnmI?`xzpsB-=#$E!NIvZ(!-tuf( W%z!^9z`8)XyQyGONyWPHg!~6HEhYf~ literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/fs.c.DE158A81433875BE.idx b/.cache/clangd/index/fs.c.DE158A81433875BE.idx new file mode 100644 index 0000000000000000000000000000000000000000..63a622e7ffd828962ff837cb867b80edccbf9918 GIT binary patch literal 9784 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 R-+(q9+P4iH+u1Ex_16u$9 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/fs.h.F83902F1C88C3791.idx b/.cache/clangd/index/fs.h.F83902F1C88C3791.idx new file mode 100644 index 0000000000000000000000000000000000000000..bd942a866909883d75f09c7c273fab17a9ccadac GIT binary patch literal 1726 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/main.c.2DC262271CAFD048.idx b/.cache/clangd/index/main.c.2DC262271CAFD048.idx new file mode 100644 index 0000000000000000000000000000000000000000..451649a21ad7f8717702783b770ce915e4d7fbbe GIT binary patch literal 1142 zcmWIYbaTsNVPJ4h@vO*AElC728H9njxTGl4nUR4(gqeY%V$R$k-)tsBfw}f3)}h@V z2b+&NaW`EMtC}+7%({a$I+Ndo{jW_9_wv?%r8x6@+aB|oi41}Qnj>)<7_lw+I z-n)#mFEHwbcOO6d`}6C|Ns%XRSABJk(>h@KpuK3_9UURo0Oo634VJHI+PF~D#O2Dx z-x6#xd(TF6f9lEIqPUso=e17^T_Nu`PMs0?d~$lS-P9`aSm+SbU zZjT!)nG;%?g5J0oOKBJ1ay>7Sly4gRbWvE}B|p!TU$0FL*JR7`w!K=Q^fn~pjAf47 z=ByCk6F1*ZSa^}=-;b$oX6EG~I)eo2QxA8E@GcZVUF>tYf37`xZOk}fWUfXZ5pO--a zD9t9qCJiQ_vJ6G3X~kYl3=B$T?H?|SILb5fND8wEbHfaE>GchCKb>mL#3L!mA}Ih9 z=8@E3(SY*=6>3gQ_7Zjj>J?%U;)E$WpT$ymam`mhps*B+6kIq{OvrVLU0obdn2&{z z52o7vt8q(rNOvaCCJ`19ewZ+iq#BDFoX6W2!|?h_NG(ti4=WEBLXoPXsv3-E$6d#s ze&Tr@&;kh-2_Bg6#maY~Cbs*Vfx^-((s1X%q#3zTg6+I_4$l)?pAMjEZ6Kw&W!F}RidyJ}WC9`BwCbgnpyI6S;~B-L5e;XGIb zF>|3r43DG&ivrwU9!VuGB|(^5vzH&gaWpvn63{wX7FiLPF#l^MF998~dq80s78$rJ z*0k=rJ&y70xS4%}E5MuHvHPVs{Wj21I}XqvU~)YjavkKfhvXLUN)YZzZP4rLLD zAOpj>5Rn_^V|_+i2^w~||?N$FJrg_SszL}9`{p-$}WaUW`c z!V(-3aMiEZt-Hs}b$uRC*q*~49wu{mobJc_UR?|nmgJBGMGhDUS*K^s&0<>)6qe(V zg9~rkB70Cv?AB?ZuqubD7)&+iq*ZH}wVJ;Gg=INp;lj@j_QthW+I|NLt8u8o4Jk^^ aNd)OEE=n%u1~C{foT_+tdEw7I1_l5Yc!i1p literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/param.h.37451DCC2B36E012.idx b/.cache/clangd/index/param.h.37451DCC2B36E012.idx new file mode 100644 index 0000000000000000000000000000000000000000..963f60d465ff92ff38a11e382ba4b4ce2253dccf GIT binary patch literal 444 zcmWIYbaUIn$iU#7;#rZKT9U}Zz`!63#Kk2=nJz%u3WzJ_Bzv4bT&+2rp*D$`!o^*H4ktIp7%FN2if8ShLwC9S<-=-srj>PQcVPmk(5RNIX z%uNCs!%&o(R;&%Qt2>I_bxO`@WkxPWRt{DkkQ4}<5X*L)^x?fOP?(W}5iXp$yfQew z;H?o*n2m#tAEK6lA%|mm;>SIjkw9S{4j#C$43BNs5?+z@~y%n_fE>M`6gP9j5+&-aq!kh&M?gNDx zI2ho<@t1j9>=^1E0)<&PSm1_yc3B_aE6MZ-D9p{l4HwpEpCa0H`rj*{FcSw8T=-Cl q@p~5`=`TQGE)FiZ=Ye6ClL)fExG1@p8^mBNT)JzUr&^3Z0|Nl4)oDQh literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/pipe.c.2473E067140E4F18.idx b/.cache/clangd/index/pipe.c.2473E067140E4F18.idx new file mode 100644 index 0000000000000000000000000000000000000000..3e93b32d06934c737d1374dca47e59820a84ee55 GIT binary patch literal 2820 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 O5ES4MQx#{CWB>rK)>PpD literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/printf.c.0918689B2930FAE2.idx b/.cache/clangd/index/printf.c.0918689B2930FAE2.idx new file mode 100644 index 0000000000000000000000000000000000000000..917b5bf45604c3b3b48822c36ddd8cfaa7124bd8 GIT binary patch literal 2012 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 WTQ-dlnfUo1f1bCXKFOnsvHt_8^ZZBv literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/riscv.h.6737E35D6CB953E7.idx b/.cache/clangd/index/riscv.h.6737E35D6CB953E7.idx new file mode 100644 index 0000000000000000000000000000000000000000..ebabe8850205d0dce9746cc828ab6dc594b92943 GIT binary patch literal 4872 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/sleeplock.h.56E9B1C95DBCB92F.idx b/.cache/clangd/index/sleeplock.h.56E9B1C95DBCB92F.idx new file mode 100644 index 0000000000000000000000000000000000000000..4ca73a27955ba4e3f2a7a21bda1b8c639af12ab6 GIT binary patch literal 486 zcmWIYbaT7M$iU#7;#rZKT9U}Zz`!63#Kk2=nK3{*9f&LDxSovWYETexdw6q#uf&%J zX@}nMAN}amw&l;OrE+{V1sVKIhtKR&DbTaEDByZt^mXR^DL1xi+P>;k?&Eo=<}mfq zqX(W!dk?wYR14shuKhjTu!LErPFbh8GB;^9(0s+7U10@p^#s`%*cccX8QB>Hzyt#) zP!0&rb}mwJJ|bek$H2{TkU{Y6XP~MMb-$^AdMvckkPC?>YCL_cnf!Tz-)X zz=DiL#YTOhmJ9&k;kUWalrxJ6fPn%)v2AbSJ;NVi+?(dN%=iBhd4Bcdcl#^n`JJ*f z%>TBNKPqq^&)c+c)?#ZkWZUFnfmiV+d|j+?(nkBHRZ*UEv5-(fB)#$$x=ZBJBBt!-rIx=jTdH3eXrgXJ!ks*pC?nnRL z;Ky#fYw5Qx(cX|$TzGZij(6Mxj~d!bQC}4EO2(d=KLw#0fpo?#gj$bkfpugJ;*pJv(icPMnE!-KAFle&<-5 zN)8nJvGa z@t}M?acFDsa@F<)s_cXj@wPtRl6$P5GFdiq`c_4)i9V6hradUi7~b(Xv|(=L>>U=; z!{J}Kb)1$r{=@2B zO`0y7;_izcuNCWu`tGk9&GYu%ZJi)jRou~;ON{BK@RRiDZ2juB9{+|QU>X1z3$W;7 zGuJEt3!*uu5o z+9XmKUR`^^{ZNN5`V0Z#I4lD)nz)c#Xs`CeVUs@7EFb}JZfed7>xL{Q0m1Ufc`Vox z_d`CVWvDO+|C~xpWkM}DFM(+v7I(mYb!DBO%^8ge$Ftc~HWOxBwq^lTJg_(3~s1n;wPaPpZ%Z%D|$Bcn2v+in}u@ zlak4XNpK_ZGdB5?z@bd~Jndv`HtEco$sl0z@&6@(0RU2G7~~Aa&Txt|40MD9jQdgP w_u8sA-85;ylpsl<80d@{d7gNJ7wSVp*eqARJA>}Q;i62Qn~NaClj;rr1I`3XwEzGB literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/spinlock.h.7E8FC04641EE310E.idx b/.cache/clangd/index/spinlock.h.7E8FC04641EE310E.idx new file mode 100644 index 0000000000000000000000000000000000000000..9549aa5f643871288930d6dd0947b5ec51b7993a GIT binary patch literal 428 zcmWIYbaPw6$iU#7;#rZKT9U}Zz`!63#Kk2=nUO#`5r`}1*mgMbH7M{L_@+4L;1TBe zh8@OwJ&rD&=fnA{GH!`DSth0`ws%DPwak)cKXl}H$yP!6o*z4br;wP*8Jvw{(#N*fTA-)ab<2&4bb#U>4&WOzu6e_F|e>PFtKv5@_-2j4xk(m z6rZuEd#70u!^gl3lxAXQ;sp~h>1kd(>TF>*=I}8v0;Spb*aX1@Oxmn5XkG5Ck_BuG ztPBiHjO>j3V1j`YVt7$%T5%VU33CG@7uar?E|}dwVUWcz;m7`bPwHL-#xn9S0RbCK z70f9>)gX7kRKsYXFvxz0#S9GRPaoQr*k^hWXb2l88xKr#QECn-$Qg=@l8d=P3?{F5 Mmn<{amVFEi04^zU+W-In literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/start.c.92F9EB51DC5F96B3.idx b/.cache/clangd/index/start.c.92F9EB51DC5F96B3.idx new file mode 100644 index 0000000000000000000000000000000000000000..3656491aaacd11bed7c1158818ac7f34e90901d9 GIT binary patch literal 1682 zcmY*Y3s4hR6n)u*EJ=3xgoKb}6TXSauLK-%rUsBUd<+dmBPotTZTQKj)<9LLmX3r5H6q5ddf`M21L6sCgdw4(+4Li^UTGy8Vmx#!+{?tS-d zNQ#d)vjKP^D``(rcF8st0Kfyj#U-ZgX$%0=OaS&YHf`8ifT`R@V!jf^m=mw!l@*?> zPeSdf10!Qw!@YZyyZg(>r+(aT?|ytNE9Y8adkygOQCb`N;*x(@m|=V|H_9j&XS5C2 zPS5t(h98;gu0P3H&}Q(yAtzR(pUCy(V9ks(>)$u}WlA!0rR$4 zl#l~s5_xRLw7P@O|E;7Y{k_Zpp)R7uCi}QAthP{O(a!huo=>`ahY=nduPQky*821M zSv}t!9?MIsARAiEWYR#{WbLP3UHOkn^~L%j>sgzvU3Rl_r)tx{3|n*b{u`T~i)vTf zBkS1aWuLU8SzUR5@A1a6pjFLb<{|Of#c!*>9(Y-7t6o2vap7K&=l4(dS(;86 zr|zhKt)H(MGp>!=S3S4la=Enc%U?Fe8s5a#M96P^w1bsPT6cyFH&<9+XXkWvPN@t2 zV$a5i4;Pmfy>=0H*`64<>f&OPlmvbNP$W(YmKJDPdX9A+Pk6ThR}#P%ngu}Mw6q|z z#m%%}XV)YUz#p2UK{SWLop2XqUNB6*_0uWWLj>^t52DykYz{K}2Valek!Q1zzz2GB z1Gqs;3obK|DiurRAW7|cesjZO zUl#}~F(r-)@yWQY{`r-95roCKm=1>8fN__VPf%K+)(?f;6*szQz$t&|8;k|>P)PJ; zaF_L_KeTta?a*WhWa}k*1(JQuvtXU|;qRdsL2)Cvs}W34q>vP&9b@!-cjiKD9P~9f z8%QJoeVNPKOi*E17%hjpbPgy|k^WCsU)g3oj1+(c(4?D*7g7~5x6&Z&8vCXjD`-LmSf^jqaj29j=_xsP zpYU9?>g9g zC0!G`SFn5kzfZ8m{8S0bM1`FzDv-vGL*F1Qh(IB$>-(#EIF<(x)?qpVu{qY3R%Xxv zJ1kX0Xy{A?mF$`uQ1*V|;@mcgcu4`LTop@C5$=d64CT literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/stat.h.AEE4CE7ADDE89C85.idx b/.cache/clangd/index/stat.h.AEE4CE7ADDE89C85.idx new file mode 100644 index 0000000000000000000000000000000000000000..4bace528f3f50dc52bf42a6b94075c1e87e22a7b GIT binary patch literal 608 zcmWIYbaRVfVqkDi@vO*AElFfyU|X9E;$?u4&eiLB z4B2d=*Em}9o8JGkVE=lHQ*O&+dBNh!+@xJV^Cu+>Hm~44t;@&2%Fe*V$;rtJCKxz? zazJqH?~01LqIg?A1`eP!I|n-tn1D&od?{%6OYeva9|I#$nw5=}6HLIQ=QW>m70tUd zg^z(5D9y&s#swx|(lZ6ccC=|c*vH4f0+i<9;NS%lFzGLSKbG_L3*TmAU}IolVqs_D z1``aN5T_NTrWOAMGGRVo*`C!7bQ-AKzcAWVID9pscBmfh>KE2%f?n~d_Kw)6`@WO-{ic)hDL7d{E U^E3>9u_MFvSc_Wg zghxk$3s|GCHE!_M6MJ;>y^ODm*I7Ypzg8bf2Tfd7%U4)g`bVESRUw=Enf3S0 zRkK35pT^o+W^HR)ZBu#TpNY;?o-e!3S?r&wU$@a!wp00}E0=e>7W1m}YqG?z_WxUK z$`D{SDYuwh=$Ofsa`#mI=N(E9H2VaO{}mVc zE&Qtg!h+(;+@v4C@GN@b1{t8V8G{)cn1D$e$3L&= zef=Pohd~Y~&CI~e1}0$AGZvjRnv`!}&%>Yuly+lqV+Rv3>5E=(UiZ5Q9pYh707@q@ zB(Z@Bm~?LOoX+U7-j_TK(m-iG20k`00h2CDO)K^QrX!gD8M(0fn~4j>zdRBaoE8Ew zZ^3*I)C=-D%xIW2P#EN8nDAqNz9)4r0%KWuB$y?cW#OKe;8W+*hPzfmPDM@w9_kWi z%4X^?^LQj|)NHh14u=V0Rz;AdeLTcPmJ(qUV*mj9MLMDY literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/swtch.S.11DB57B07ECB88BC.idx b/.cache/clangd/index/swtch.S.11DB57B07ECB88BC.idx new file mode 100644 index 0000000000000000000000000000000000000000..7ccddfba12d8a5465e9d207db459e9b731368917 GIT binary patch literal 266 zcmWIYbaP{3WMFVk@vO*AElFfyU|_?6?T6cUZPGloNNM@s+Y2`} zI^SQj^Y*n_WebdJ4}E?a^H*S@=c4JgCyYNw+-aC5vNGI1e*Oic!?AN?I{&@5J;9(~ zus)};xH2~h=wybX)U;vgc{C;Gf literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/syscall.c.05D088F49A8C83CC.idx b/.cache/clangd/index/syscall.c.05D088F49A8C83CC.idx new file mode 100644 index 0000000000000000000000000000000000000000..47af2f2ec17b6a923e48f4344819d3efc7a1e3d7 GIT binary patch literal 4570 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/syscall.h.66E962A052CADC6A.idx b/.cache/clangd/index/syscall.h.66E962A052CADC6A.idx new file mode 100644 index 0000000000000000000000000000000000000000..51d685c50c2af7799f859dc7a1b4327e573cb108 GIT binary patch literal 630 zcmWIYbaTsNVqkDi@vO*AElFfyU|vkKfhvXLUN)YZzZQQEFQ8V@3vs+rP`azU+_@XXIk!=HM0rNr8aBFZ-3Xf^r%_VF3;SL5Ls& z!`v^rr#>s$gM|4w_~5EHUt?*z=dctc%*??o08?E!aff);3`(^*<2PrKw%aR7PxSnd41ZXNB8`I!u%Zk zaNz~DiJ!BJzXbw?g*b%Z4xF>A^i1{SLqR}cRt{FU>V_ZBRCavclLZtO~P_|e#;)DTg^WU6c*$Vgd6f?so~RAt&2YZ zg}FGm_+eo(zbN^>w&kKvKw%CJ4!CN89Z&gQZJh8KC@jn&3^#k)LFtF3f7bs13Nvyr z!iCpu={u^r?89%MFee8m+>kaEubI_3CVzp#A{-)cVPIV6B!cWOE=n%u1~C|KO1W11 KxJZUEFaQA7MUpW9 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/sysfile.c.C337A604B3627C12.idx b/.cache/clangd/index/sysfile.c.C337A604B3627C12.idx new file mode 100644 index 0000000000000000000000000000000000000000..1c20ac75a106b8f6ebbd3f51bf1325262ce13f0e GIT binary patch literal 6948 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 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/sysproc.c.E5BC46BBC06178C3.idx b/.cache/clangd/index/sysproc.c.E5BC46BBC06178C3.idx new file mode 100644 index 0000000000000000000000000000000000000000..ccf3f4d5368282d7bd0388abf27022a54bc6cc1d GIT binary patch literal 1776 zcmZuweN>ZW6o2*tFYn8q0b_#!vez*LQIR7bDYn5*lOxOm1Z?6`X$>+w!$ZStexW8K z0)$K~N;2a3mD&pJU@Jf%p$~xoPZ)y2;X^FKFhWD3dbZB9mp^>Z+1)k)wv1d)yM8XhPHBhpzG_N%rkX5UFY9{i}EAHeK#P5!2 zs@Ue>mh>q7(ba}IW8Hzy!Lg|uFHF`)OzH=(6esT$YQqM3@UW!kuAxf4y~0O+_S(!3 zmFJoyq5i@%{p-y$N~6>9$8=H7nt{-hI^(P1jp{5|e`rMDT=I2()9B^ar5+{sGY%d} z8QmmTN_u-87Ju=6*+|!}qxHqLOyw*0b;Mci~~>K(PX=CN!QM1?VT!3`Yr#RdGnSy#{6tWwQQ=tr?B`&wb^59sMfT@a`CBVP4M{D6`yuDcusuNy(`qX3*H)+}wD^k;2T6Es^WK94t;PQ<%#WTR`sa?3eyRJK&zq z`Mii|^@Jb@044%N&^Cb(+t=x|?ZUUB2VM{?M(_r(!Nn#pY-#SinsMgsKnNBgSOrv+ zO<>r0$R~-poL>MzAcBKH5M>h>{`=Tw^|fJj4FtgmW&lIk1crazsJ%VMzgr7I0D?V$ zhl@>MSlCO)S)z0LAdn*18+cPTf#I@0Q*QOpMbi-YBbWv>WfK@SWWJo+jP4ztpX2hx zxslsCG|u|H>)jWhGiUm7AmdB>@^A~71{7`O07sjeq$jn`H={_%$ha~gJ_<4lH-$HA zDFsSD){5oE&WlXrrU~skU^HBf-723R4mXrWMx$1ww3LUr6p(S}k8mQNL2jj^lE!r- zX40$2$4sfnok%D0aKo=>y}@tfH>i<&xzlnU-q&!F>qy?cG$cG-M=%gkr5g5J<8|1rxy(YlVaGc>~3RcoLHV znN*N!A5Xro#z3{bbr5kNBV=|WA(KX=(U=2V7A@X-yYb@H!mkvcwf7V{LIx6$Vh37A zESuL#6cI(S+$InS6mF$|R#ka;$XtR7$hmTNHYl2k=CPKNtDJ{z;%;)sjXj@C#{IN; z{4`pQP$2ZeBnFstK1B^}XOY{V@TW0j_#cg7eT8_8KGW#UhGC~mD4Iv`?0dn*P_*?? z;%K}Y^{>X{NzWmXcFBA1*w?Vd@K<=k5vt!v9sE@eQWcuT>J+*H^w=}o`Pva z2UwpoKERNv*IM;lgDyASs`y#O|KCEa03c>nZ&vlOs~o09{UCN%*>!>QLO*X`AMpaP nzzzamR@G%^=&fmA|K(E^E(;|2Z$0$)15 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/trampoline.S.ABB830BE366004AD.idx b/.cache/clangd/index/trampoline.S.ABB830BE366004AD.idx new file mode 100644 index 0000000000000000000000000000000000000000..ea5ddc9536216a81330db8848e38006e98335a30 GIT binary patch literal 406 zcmWIYbaU%tWMFVk@vO*AElFfyU|2vDwK&fNa!E+$7F*UbwXI_#2c>JR>3*XM^G7c<9j;VTBi>$4?mwVCVt9IKJM%x57 zouFdy_@O7krE;+#8jD&tl=`DJpJj3-&y5b+}_5u)fvJ_lr{7!RjA@ll2#U zKfT!H@%=lqXaAGm_xFS62hW#NQ-3hqwa@l1uFOpWdW4}UHLW-nNWWgU?jAGO^?7VO z+;YltIv^0h}-f12Z@C?}bH6IxBscxHuV-b5n9a%GfwKn3!33SQ*&?x@CV( literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/trap.c.E331BC8CB04ABF35.idx b/.cache/clangd/index/trap.c.E331BC8CB04ABF35.idx new file mode 100644 index 0000000000000000000000000000000000000000..ff7e9dc33828f767ff3c23a66104dd61f83c9102 GIT binary patch literal 3624 zcmZ`*d010d7QgrLLbjI>2wOrRY!4AZkW~>Yf+koi3f0bsxB)5&ff0czNKxRUqJYS* zVg(%$5UW^YHf#te%85BZ(jUk-uFS?Ip>~perLTee4#>N zD+C~T-NLkl^(j##06>iXl2ek@0}y~5#7Ns;wQRBGriZ91IdhwE&PjH}t;JlsZ;H!J zr5ti!P*K5WHbduMMmx?v`=)*PzrXhNEsFle`LSktR=mC^OUz?C!uv1JZ#p=&zdGUd(S{O@ zBB9M-w6MtMOyR{9+YOSO-EbjvUn;Y@ll?7llcj2wykUGmhI8IKP%=7>ULZ%bh-Y==IYoVSs$0U z+npb^ENklA&A%gb@pyhbXVmTPo(HNTSlxMJ);51dWS9KFpF3SZ^5%r-dQ@Eve`rm_ zlQClfn2u_$eP}+#H-GmEz~?T4KI5Uq4ivCKk|qe6Ae$EPMJD(_V)oiSRc9yt1i<$_ zi{?xDc38Zv)4n>2JvdVU+>ky;#F5C$phX$91zdDwniRB`6h$BMy6rCjUOIi6?~3(@ zt-^g@7LBf?fH%^21dg1y|FAfHr%=rfZrwMv&umQlbN z9ms_s7xLc!U?)arG8*PxEU2Ks40J>aq?EiAib|nOYr_TE$WT;H`23J~m;%=5Kn(;n zko*1z+laZDvSa3koRbvrK}RA$1YcebMdi>+YXc%1AZh)EdR z0m#J_QjN2%8%+fqBxr@gR%n53ce7ZG`}wfx2PMSGfi$}nJxR=O#@7%C5n@}N0JP0{7h zt{hImG&V+ZKWJBq4weMlGDb?FNhy?ICEoiE#}NPFInw>lxW^6%Vm&14AqSUIw7`tj z`Ygp63Dy#8c{nQ%JC1G5GM{imY%{`)hr0{U2!S%HHybFUt}$L%7f%Ywdpjl=0`ZZcqEkxDx zW_b&kR4ZmG0vW0RniN1OPCP|7Lz8AG#YXTsg7?9=Q*@kD+;j|Kc!}`-){(GP2m%*y zNj&V9Ebp}!p1p}8P=0M<(Ad6vP*gUVI;!}X@5Mi+hiZ^+8#HW#LhN}_(D7#D>5&_e zAczdoO$%N$Xejg-3`NUKWLCNjK)ac^Sz+vt?#!5+%srHd65%d(mtZzUM~WkLmC+8L zMJ2Rm5>W}AE8%oZ?{U{eH6kjR4^427ceA(5|77eJywpKgXkGvweJ33janV?Qn1f@;(Y z*}ag$f+^p{+_9`T+N#|{hR#Mz6q`&p>AGI)O`H#9*n2=mQxfM&UKX-e3yE6D#lw}f zV(dz5(68H(U;y$4pb>VX=(}$3@L+a65}bpE=b$+j;1)FCy}fLh)~ka=9b{v}+HJzC zhenvj(~Yhc?G=R8ephAx*!#t-QsgF16sMa!jQjsyL`a~$g|Hdl?C{2feJKZ#84jCc zg!fEZXO<>@yx|aPlN2I_&(!7sBo076_OhP}y1i!cKn>Dvhi2{27MsQ3(TKjg(y)M{ zuR_DCOtzMX87c=>j@2Ry3Z>#>T$CO6YkacAvl#k#? zso_QnFv!2>btpH9#*ZT1O6XY${V-a04^uxo*^)*iNMr=_8 zT&zpcyCAs>axpxLE{0^WK3xIH3WkmpPe@^h3~{fLjhZx3RpTc7vFsVeU-hfs^qM8}FuHR>e zXdX@(M#q+tOZ9B+gXBI2?${oS+9h=A1B9yxvWlPp$N975sxtfh;ZZGMv=wlc8h^W2 zywOnl7_rrIwQiBrb(=QyT3b9v>?4pk!VKV0-0Jhg0oE@N3_rG?F7*_>h_y(!nFGbb zH5CUhPO{O4WO)ji)CaHwL=2^3sf0KS$URG~N5!$?^e7EWqerDusb*MDmEE)c(;F?X z5KxtkN>?6#(fO*D%GAGDsKH5vUK=S%r5;rV$uh{pDbjwgkmdSxCp7G2R$0>e_$Y1O zl9OVR*JxiHwEx~cPWS~tS~ap;l6#euvz_d09USfDz)>dzx(_h`Y#FXS^Q!wy2OuV4 hUA(qX78Vkc%i{=5j15_0N?^(s8S%}gm>XDv{{hf|k0<~D literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/types.h.9C15A82D28EB699F.idx b/.cache/clangd/index/types.h.9C15A82D28EB699F.idx new file mode 100644 index 0000000000000000000000000000000000000000..4c17da91adffeb23be2cc69c559abe16a9bb9454 GIT binary patch literal 620 zcmWIYbaP8#VqkDi@vO*AElFfyU|dGS9CKPP-|OmiuDsnYZEoA$$(H*K~bvlo05)beKOq2{6`4S(W7tk|!+ zwJltCE^UQf(d`A&US?lz%vc~c-RLm;V+WNYhT_WHq#r( z(~6G)JqYtZBNxQqU|%Er4HO1>8Y;>F^Dj^s>m6DQIQ;|ES2_>y*MwCia9=Yf>N^iF- zA&+iEPYqhP+e7la9ye-TvXDo0g*@&*ti=p;}t;`4YGH^SLd?Sv|)A zN4WVfiT&l_kp@u9!tpY72N318*%pQ`4^Yrk0gws1%K^z^0f zWew)nRvQKK>Cxh4L`qsumyc5G&Sc68aSto){XogpdgaoAVs|gyf0SjZ)G`|mvi3UT$7#AC^_FheW!4E9laWw zIF;0AU6%VO+GdnrD4PGBd&wpC2d&OBQ&%lwSA{DLNF@ zsYvpB@4B+UL!6g=Y3Odp!JN#>9`mJwImcx&5$hxn00VDpV}+j%odaf&6R-LR8=j5c zs0qMn;~CvdQ3rtoM=}x#A~}Y+kedtj0aF9&IT?Uvng7~a?gk$Yup$8#R15CNg3fO} zS6FsFe?=G$9LVr0u!>=L1agl+9o6}%E#ca?FuExQK?c4XKAI4}&eAvb%pz9o4B5G4tf?a)xOt-&0}GEM|i136<{ z5i+WbgP7l9_q^$7*b7sL6FHEQ16inB1c0m&T~IU68p{(BwLe&qcyG*`g?gJz^Ei0` zI=GVCB8rHKY9aYFSmR{F2{9)Ap`k2@XF)!yj1H5PRf?j@NJ?^hR7Vs*0@7LIgd-co zy>(E7I3Z*U`6xBnC0}H!_CndAKg4Pvy9V-6J)Ee6>^il-Q1?@tLSP$*;e;iyq#^Nf z!U|Z?kd)4G6;X_~eTgJUhzZB|z=;}&)j%f7eO{#N)Y8bsoXrYWSW!`G#<*i6mIljt-a QXMz@EA{W;d@F`Qk|GC8J2mk;8 literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/virtio.h.7AE2FDAEE3C87964.idx b/.cache/clangd/index/virtio.h.7AE2FDAEE3C87964.idx new file mode 100644 index 0000000000000000000000000000000000000000..324596fc6c1a9511113de34a04ba4c07f19921fa GIT binary patch literal 2640 zcmYL~c~BHr5XK)fvioKkhF#8u1#~%74iBOWs}L>~79*k{c!9WHkzq6hYQ@4 zt@@VM-QK3hf4@E46}4jaZ?C)ByFTi@WOKHEk_N`aFifXHzg8jULy$l(TygXea)!mVny3e!X6tmm?uGX8o2Rdf#56|fv6+WhZ@XG7E?p3_VJR4V0ms369Q2YlR}GM>BxPnzY&N7 z^gNwQx0eFGU1})dpB}A0B@iCcGq@QJQo!`=Z7(z1HeUE%Aqs|#R7N^VK`d?$#S5Zs zTXQn&&nk!;q{k`8X`~>g#b;q_mFAP2K|d;p2GY}&(_N$>rUgiwU%pzdePX?V-SifE}r$9#?PJ-%z>b+cr1AX*5lX7{?#5IQ!TgyPS1v6mfNWzycM#aJ7>| zzr`j`qYq#|>L>r@oKBtkjc%rh?Ww)I8npvh6b`ml)9J!&p1MB(u#W2FA|d^=buAse zfq*qsBNsUsklrulPVNxE!8BN2y-88$@Rf7v2Y|h)w;yg0^$1uLBQ_Rw2v`&$j%WF= z(axQz1rdM;(LsH&2+9($s7Wk>as(`D5%CRm<=8o8`f-56X}AX#xm0j|>zHxnDS+Ln zyAR@EL&nB>rdh-;)TJNdkjc99ql>F2u_`u%hS(wI*%%=P=Jfr;vq|1b@`Y|PTy5#s z@o5@V8b}Aq!?Ipg8+7Q3V>aMG8VC}2|FmA+xg^qRwg4VL2gn#b1h8lz*qGF3YePD> zUtb8=m-@}z|Oc+JU z@T`$BQrr*EMln$ots88SiKcih&=e+y;%)G3EE7xd-g!2WNu;P!FePR@MXws|@#g1k z0U;|Ho;5HAireGa8O#idp7VH*Qc-AmRAdWI&4f}M9G*2XCW-?MUdSX+v`C&!XVNKp z8qa1h85CuOYoG_BhoS_oZRmMDIQvi;U}x$q4_^O2C*D@3KimLVPxW#m@c@8Dr^U9% z3Y+pS*v4-G>`6Uk3HX;BeeK#5^abDm8X(tZ_Qd2pu=#QaUb&?g0!T~IrHx|KT0TxXg zF%|wQ)#L^&xdr)I|5bhmjG+2Ru*I4;J3%xI^H${4x&LiEE3XK z70tg{cLOj_c^M0(LzAcezWgR&SL!M^wqah?v$CcWcL2LlH(3;Tr;O_Tm*T(TAXY9( zi;BUCgm=Y{2A*}_q_M>dvj2Dv*pAxCcZHe&EPg}qj;wQY&0_U@>+F2VBG`$-lImOf I>=r`)1@N}Q@Bjb+ literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/virtio_disk.c.8DF9309BB95BE078.idx b/.cache/clangd/index/virtio_disk.c.8DF9309BB95BE078.idx new file mode 100644 index 0000000000000000000000000000000000000000..a4100451ab862d0bb3fe3abb11707c3e48baf1e1 GIT binary patch literal 7156 zcmZ9Q30PD|w#V-|z1&_dO#|J4fXE^!h*uzp%cv1i(QG=RsENiUE>8_caYK|Wbt5@(D|Po24Vno*psu^BN@i@B zel9Ud^f&2lPAwi@^369MBWHKL{%-ewKTZDSI;KepveJ*tG)#*2s1sTU$f}&codcFVis$<#5 zS|?=wr|rc*Zf7p79XP0MX{{+JFrjVqkF(YUFA#Pl#JxMXaOCpD+RKM#@3`KtDRfrS z$hd@lrp^uiQ+-=LU7(z}Z`n?L>F6&$y7c3Ky;tqyh9BIU(D(6A+i&-cyU?YoY#1E8 zv1;nM?rB}(bcxeKs~?Td2pq91Dr(-$nYZ?>b>x;Vj;z`=dC;gYeRqF#q5A%SaTjk+ zpLk&R?u;3C8@=UU?seJQbf)N1S;f9jr@zShGV6@DVFHbEEqjwhkCMMLCB}yzE>V~yWZ_jc?!5|wNa z0z(Bk+8FK8{-JVW((D<>I;qD>LNuwt0fGZ`fBd0YyboCVT#Xw&%}odnV!C8LYBt}+NgMD{oPcWVDodH8ofhJ@bxQ-LJ> ziBw*WLOB}49AI=nkf23$4)U@?pRcc4R3r&x$I0hGI1l?^?RSAoM1K zjM2upw|}Uda)0VyhmOGA>h=+s4Q5Z-`JwW>FY14)OP>9mB=jc@3={?$!>Ykp-O+=7 zqz4Dp|IqUPY)liw2A1EGgaA^$6ogVThaG=tmahj@fACq4 zl!pePGpQliJJ`SdL*>3F-~G0-Q|VKK(2K|sVuZf^LuDat=B!0^-hxoJ_MkOHnx;@l z@<}k9gf29PB)^1!m(Y`OE_TjEnR1uW!-`jbKSu;fwt~tEK~$g?Eb7`Vm(G+VuSRh- z>RmP{TQJgsGUGxN3wgZ^#WJ3cqjVgNuH}_$u~RK}ru@#}1?TtG+q7gLYf!ZYwXEW; zsNah2j8CF?67{s;=Sy~3zsN~9kb&fbDxVER8Fl~cwgp>_L|Ev#um>Gq;hy@E^*3Yx8Ru4ZDOzI!58Qz&T>*XG_bVNYk5R~L;(zI?gS(0ZNXSq5(qtV~^yZ_V> zQg)bTn5*oP*avkx<~|H1Wsd?L1&wR_%coFz3U##YIcJ-neLJORS5n@Au?~!*f=8nn z|1xn;1QBeYvOy4SKPG&x|2KD=BZ)9qHP??O-#>LAE64j~Pm-K~2|Bt__C-tzO1}MZ zFOodjJefF-j-MP*={L-}sTb+rbqKl+VN{UhHt=g>*1Ar8#=YE>A4|#?fU1Bk%HBP@ zl)t`;?yHpK3UIFgPd374Fg1e@T_k6XrZ%3fXtJV9FZynb2(`F3TUo?2la*{i>}rBt%({zMp%r7 zV)UdnUNe@wHDgWiJEZ9x49r2-@{l#h02}iO_D5gYO_E14*@NkZbQ4`%NnY;0+{`G$ zkm1tkVM6wX^CV&OSBR!UG}A6fav7S+c&^2eS`4LTcy7t54a43kN+x}`fXc!QBdYi0 zwP*37Q`n5E&FC_HItygsI?gCM(UQC!aXU)1>6r2Ur-rWDHdZIe5mJOZ%NDDRl^Deb z#B;uLv3{|EX?YNs$4pX^*MfO1_%eMPn78q~A9VY{jp@Z0R*c;lJFusNt-`wASHB6m zo0UR_IKez2oMwAtN<(_lzwSΞ;<$8aDk|n8i^xX1j=<%L%&I&SSDwr353ZARW`y zjF#hajxsQVqZR5Et}QOfD@-eVS-BOVE4net)MmOd%FjluWfY;Z7aviv)gcu%(WuSMR$nthjZwDRYgP=MHTDt2b z`7q#NP&2Lotl+s4u#)F0z$%`P03PA_DCmxYfz?+7?ls^=%~z67fZ+sqGQJ7=o4}oR z4WMs$o&6dhkXpASKZfAP5XQI(unE+Rn*p17ehK)J=N7;go?8K1d2R!2$94zr-k@sj8S(aP&KL>td`L_5!gh=n{CBNo5T zUd8NKaC%?d!0V-GC}qCW>A0|r*LR|RCm)UMLH!enqNVZ&i?KgO_(DRw)lv z59Mf>dKgE;)x$Y@Tk*D%l^dlP#Zj^%nWGeQiZ{#oq2fbMo35D7(M)Nk>u^)ba}{$r zEmfWBYMop{a3ME_g~o**tc5&KRNvmF$6p7TMG&vOAN3V1F8 zMG?;%L9vnN&8XOnO1i>IxdIgxsH6+yo-HU^c($Tw<=KX!jb}TGcE)rC$#tdUrG+}s9|~Wz$a4>@ zA)7Q+lgdTLMW8AI@~YAC3xD$G8{(t~g=FR5liqV(Ug?#D1m_*EGc>;>-v#k5xUMGS zN6&rO{PKA*DPN6UtFasH&=AAAg>|Z=^+d3P%Fd#1`mjST9L`rAW>Txsw3>H97VKle zfox)rqxm@c)B3}#6)oNudi<5tKhZqVbsfYV2@CJT?kyxa#U~|}c6*Tbf9<^Q^`ev{ z`)mEZs9DG7jyaUNW$|{B+*jMzgL+rmCo-x0qf$<4*ZlsU=j|s``V4f>z`**}2)ahb z*XkyP&U$d9(i!>tWV&uVlAPt66-c`z$=N>HF0JJ0v!o>htkt9^W27-5G*f{kT?= zlaxtXw*6)+XLB@PIiI6N%0(P4Q7++VrE(=l2S9m%kHHUt@(|B8sIFl#(UQTc@8?Z9 zdxG>aTpR91-{Ka0U+VG6yq;f^X^Yp!`_P-cGeXur<{t){p?fpL)7j5amMb=vJgXzM zT?g}Z2%y5Rkpo_=>T|E22#w&;2tjmK5BOi)5~=(3oLZ9KR=w>*lO=hSY7|Gws$`C) ztEO`_(=gLjog{Ar)kbis3+1-TTX);elXgEaf8e?{(m5wq<$RE&t;U=$9W4EByGC*k z)eI%?p&dU%e)O1$|C8|(Nv^=K3QV9v{jAc*Yc3qU-7csq&}C3`8cA&6e9xptEXf&S z2Jfr8ui(O!Y(qBZtMefypZCoL5L*E8wByb#9$1YbbPGBoKu-sHQ>Irk;xt}=DwX6* z;C2aos8^vzsnxYVnX;ZP7ne({wH2LK1TxApWO*^NL5z*>nH^&7(1+>8C>FCP1m}Z_ zZ!sV7Y(Q}X)9GU^nL6i7E$h%a(5?elc;LK?N@ZZA10^pNpx+Mej1PkDAb(dp0^$+= zusRCvNBLN`0gMe`q6Yi<*tb^ApWE=1EN!AD(dDzt>r8vEboO~h{LW6qo$Rg38JJ-m zi?^gB0X095c)v-MXwfR?e_U2C2oX;1__^Lj1i|I81;KTj5d_zJsUWzX8U?|1 zED1s+tx6DFFXIBpg^~R}sjN>=*F{Byb???AGQ4X~;iJ?UA9o_zeSQ2?I=$B2%TrXF R+ze)ohf(r=!$;Xk_&>Tx*|h)w literal 0 HcmV?d00001 diff --git a/.cache/clangd/index/vm.c.70D05D5C0213F437.idx b/.cache/clangd/index/vm.c.70D05D5C0213F437.idx new file mode 100644 index 0000000000000000000000000000000000000000..400b82975ee0bdf13a5f6a043d3afb3aa6620d89 GIT binary patch literal 6386 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 = RUNNABLE , the program can't print, at first I don't know why. + * and after I look through the code, it turns out not only yiled will call schedule, but main and other stuff will call, + * and only the yield will call it after set the state to RUNNABLE, others might set the state as FREE, and If I set the + * state into RUNNABLE, of coure the program will fail. I think one possible thing is: the main will just exit. and the code won't work any more. + * */ /* Possible states of a thread: */ #define FREE 0x0 #define RUNNING 0x1 @@ -10,11 +32,31 @@ #define STACK_SIZE 8192 #define MAX_THREAD 4 +struct context { + uint64 ra; + uint64 sp; + + // callee-saved + uint64 s0; + uint64 s1; + uint64 s2; + uint64 s3; + uint64 s4; + uint64 s5; + uint64 s6; + uint64 s7; + uint64 s8; + uint64 s9; + uint64 s10; + uint64 s11; +}; struct thread { char stack[STACK_SIZE]; /* the thread's stack */ int state; /* FREE, RUNNING, RUNNABLE */ + struct context *context; }; + struct thread all_thread[MAX_THREAD]; struct thread *current_thread; extern void thread_switch(uint64, uint64); @@ -27,6 +69,7 @@ thread_init(void) // save thread 0's state. current_thread = &all_thread[0]; current_thread->state = RUNNING; + current_thread->context = malloc(sizeof(struct context)); } void @@ -60,6 +103,8 @@ thread_schedule(void) * Invoke thread_switch to switch from t to next_thread: * thread_switch(??, ??); */ + //t->state = RUNNABLE; + thread_switch((uint64)t->context, (uint64)current_thread->context); } else next_thread = 0; } @@ -74,6 +119,9 @@ thread_create(void (*func)()) } t->state = RUNNABLE; // YOUR CODE HERE + t->context = malloc(sizeof(struct context)); + t->context->ra = (uint64)func; + t->context->sp = (uint64)((char*)t->stack+STACK_SIZE); } void diff --git a/user/uthread_switch.S b/user/uthread_switch.S index 5defb12..ee79de2 100644 --- a/user/uthread_switch.S +++ b/user/uthread_switch.S @@ -8,4 +8,36 @@ .globl thread_switch thread_switch: /* YOUR CODE HERE */ + + /* I just move the same code from kernel/swtch.S to here */ + sd ra, 0(a0) + sd sp, 8(a0) + sd s0, 16(a0) + sd s1, 24(a0) + sd s2, 32(a0) + sd s3, 40(a0) + sd s4, 48(a0) + sd s5, 56(a0) + sd s6, 64(a0) + sd s7, 72(a0) + sd s8, 80(a0) + sd s9, 88(a0) + sd s10, 96(a0) + sd s11, 104(a0) + + ld ra, 0(a1) + ld sp, 8(a1) + ld s0, 16(a1) + ld s1, 24(a1) + ld s2, 32(a1) + ld s3, 40(a1) + ld s4, 48(a1) + ld s5, 56(a1) + ld s6, 64(a1) + ld s7, 72(a1) + ld s8, 80(a1) + ld s9, 88(a1) + ld s10, 96(a1) + ld s11, 104(a1) + ret /* return to ra */ From dec7bd9b0425d2d7d1101b0f3c1dba0ee623e6a5 Mon Sep 17 00:00:00 2001 From: novice <619671969@qq.com> Date: Sat, 31 Aug 2024 14:27:10 +0800 Subject: [PATCH 11/12] finished the second part of multithreading lab: using threads. this is a easy one which only includes basic locking operations :) --- answers-thread.txt | 2 ++ notxv6/ph.c | 11 +++++++++++ 2 files changed, 13 insertions(+) create mode 100644 answers-thread.txt diff --git a/answers-thread.txt b/answers-thread.txt new file mode 100644 index 0000000..b16fb5b --- /dev/null +++ b/answers-thread.txt @@ -0,0 +1,2 @@ +I think the reason is :with parallel programming,two threads may try to operate on one object without using lock,and +the result is the latter thread will overwrite the former thread's operation. diff --git a/notxv6/ph.c b/notxv6/ph.c index 82afe76..2c7b518 100644 --- a/notxv6/ph.c +++ b/notxv6/ph.c @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -8,6 +9,8 @@ #define NBUCKET 5 #define NKEYS 100000 +pthread_mutex_t lock[NBUCKET]; + struct entry { int key; int value; @@ -40,6 +43,7 @@ static void put(int key, int value) { int i = key % NBUCKET; + pthread_mutex_lock(&lock[i]); // is the key already present? struct entry *e = 0; @@ -54,6 +58,7 @@ void put(int key, int value) // the new is new. insert(key, value, &table[i], table[i]); } + pthread_mutex_unlock(&lock[i]); } @@ -61,12 +66,14 @@ static struct entry* get(int key) { int i = key % NBUCKET; + pthread_mutex_lock(&lock[i]); struct entry *e = 0; for (e = table[i]; e != 0; e = e->next) { if (e->key == key) break; } + pthread_mutex_unlock(&lock[i]); return e; } @@ -105,6 +112,10 @@ main(int argc, char *argv[]) void *value; double t1, t0; + for (int i =0 ; i Date: Sat, 31 Aug 2024 18:26:12 +0800 Subject: [PATCH 12/12] stuck at the part 3 of multitreading lab,just don't know how to make them not go out of round --- notxv6/barrier.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/notxv6/barrier.c b/notxv6/barrier.c index 12793e8..9de3aa2 100644 --- a/notxv6/barrier.c +++ b/notxv6/barrier.c @@ -6,6 +6,10 @@ static int nthread = 1; static int round = 0; +static int goingout = 0; +static int count =0; +pthread_mutex_t lock; +pthread_mutex_t golock; struct barrier { pthread_mutex_t barrier_mutex; @@ -30,9 +34,25 @@ barrier() // Block until all threads have called barrier() and // then increment bstate.round. // - + pthread_mutex_lock(&bstate.barrier_mutex); + bstate.nthread++; + if(bstate.nthread == nthread){ + // now the thread all come and it's time to start a new round. + bstate.nthread = 0; + bstate.round ++; + pthread_mutex_unlock(&bstate.barrier_mutex); + //printf("round %d\n",bstate.round); + pthread_cond_broadcast(&bstate.barrier_cond); + }else { + while (bstate.nthread !=0) { + pthread_cond_wait(&bstate.barrier_cond, &bstate.barrier_mutex); + } + pthread_mutex_unlock(&bstate.barrier_mutex); + } } + + static void * thread(void *xa) {