benchmarks/interrupt-latency/interrupt_bench.cc

#include "../timing.h"
#include <compartment.h>
#include <debug.hh>
#include <event.h>
#include <locks.hh>
#include <simulator.h>
#include <thread.h>
#include <timeout.h>
#if DEBUG_INTERRUPT_BENCH
#	include <fail-simulator-on-error.h>
#endif

using Debug = ConditionalDebug<DEBUG_INTERRUPT_BENCH, "Interrupt benchmark">;

namespace
{
	std::atomic<uint32_t> event;
	int                   start;
} // namespace

/**
 * N threads of equal priority will enter here with different stack sizes. They
 * will all wait on a ticket lock so that only one of them runs at a time. They
 * will then wait on a futex that will be set by the low-priority thread.
 *
 * All of these threads will be waiting for the futex.
 */
void __cheri_compartment("interrupt_bench") entry_high_priority()
{
	Timeout                 t = {0, UnlimitedTimeout};
	static TicketLock       lock;
	static bool             headerWritten;
	static _Atomic(uint8_t) threadCounter = 0;
	threadCounter++;

	uint16_t threadID = thread_id_get();
	{
		Debug::log("Thread {} entering ticket lock", threadID);
		LockGuard g{lock};
		Debug::log("Thread {} got ticket lock", threadID);

		if (!headerWritten)
		{
			Debug::log("Thread {} creating event", threadID);
			printf("#board\tstack size\ttotal\n");
			headerWritten = true;
		}

		int    end       = CHERI::with_interrupts_disabled([&]() {
            uint32_t bits = 0;
            Debug::log("Thread {} releasing ticket lock", threadID);
            g.unlock();
            Debug::log("Thread {} waiting on event", threadID);
            event.wait(0);
            int time = rdcycle();
            Debug::Invariant(event == 1, "Futex woke spuriously");
            return time;
		         });
		size_t stackSize = get_stack_size();
		printf(__XSTRING(BOARD) "\t%d\t%d\n", stackSize, end - start);
	}

	// Last one out turns off the lights. This relies on all threads
	// incrementing the counter before any thread reaches here. We can be sure
	// of this because for any thread to reach here the low priority thread has
	// to run which can only happen when all high priority threads are waiting
	// and the first blocking event (LockGuard constructor) is after the counter
	// increment.
	if (--threadCounter == 0)
	{
		Debug::log("Thread {} exiting simulator", threadID);
		simulation_exit(0);
	}
	else
	{
		// Other threads sleep forever. we could exit (return) instead but this
		// seems to trigger a bug sometimes where the low priority thread
		// doesn't wake up.
		thread_sleep(&t);
	}
}

/**
 * This lower priority thread will run once all the higher priority threads are
 * waiting (either on the ticket lock or the event). It sets the event without
 * yielding, puts the starting cycle counter in a global then yields(), which
 * does an 'ecall' simulating an interrupt waking the waiting thread, which
 * reads the cycle counter again to calculate the interrupt latency. We repeat
 * this until all the higher priority threads have run, with the last one
 * calling exiting.
 */
void __cheri_compartment("interrupt_bench") entry_low_priority()
{
	while (true)
	{
		CHERI::with_interrupts_disabled([]() {
			uint32_t bits = 0;
			Debug::log("Low thread setting event");
			event = 1;
			start = rdcycle();
			event.notify_all();
		});
	}
}