haiku.git

/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

#include <SupportDefs.h>

#include <syscalls.h>
#include <spinlock_contention.h>


#define panic printf


struct dummy_spinlock {
	vint32	lock;
	vint32	count_low;
	vint32	count_high;
};


struct dummy_smp_msg {
	dummy_smp_msg*	next;
};


static int				sNumCPUs = 2;
static bool				sICIEnabled = true;
static dummy_spinlock	cpu_msg_spinlock[SMP_MAX_CPUS];
static dummy_smp_msg*	smp_msgs[SMP_MAX_CPUS];
static dummy_spinlock	broadcast_msg_spinlock;
static dummy_smp_msg*	smp_broadcast_msgs;


bool
dummy_are_interrupts_enabled()
{
	return false;
}


void
dummy_acquire_spinlock_nocheck(dummy_spinlock* lock)
{
	if (sNumCPUs > 1) {
		if (dummy_are_interrupts_enabled())
			panic("acquire_spinlock_nocheck: attempt to acquire lock %p with interrupts enabled\n", lock);

		while (atomic_add(&lock->lock, 1) != 0) {
		}
	} else {
		if (dummy_are_interrupts_enabled())
			panic("acquire_spinlock_nocheck: attempt to acquire lock %p with interrupts enabled\n", lock);
		if (atomic_set((int32 *)lock, 1) != 0)
			panic("acquire_spinlock_nocheck: attempt to acquire lock %p twice on non-SMP system\n", lock);
	}
}


void
dummy_release_spinlock(dummy_spinlock* lock)
{
	if (sNumCPUs > 1) {
		if (dummy_are_interrupts_enabled())
			panic("release_spinlock: attempt to release lock %p with interrupts enabled\n", lock);

		{
			int32 count = atomic_set(&lock->lock, 0) - 1;
			if (count < 0) {
				panic("release_spinlock: lock %p was already released\n", lock);
			} else {
				// add to the total count -- deal with carry manually
				if ((uint32)atomic_add(&lock->count_low, count) + count
						< (uint32)count) {
					atomic_add(&lock->count_high, 1);
				}
			}
		}
	} else {
		if (dummy_are_interrupts_enabled())
			panic("release_spinlock: attempt to release lock %p with interrupts enabled\n", lock);
		if (atomic_set((int32 *)lock, 0) != 1)
			panic("release_spinlock: lock %p was already released\n", lock);
	}
}


struct dummy_smp_msg *
dummy_check_for_message(int currentCPU, int *source_mailbox)
{
	struct dummy_smp_msg *msg;

	if (!sICIEnabled)
		return NULL;

	dummy_acquire_spinlock_nocheck(&cpu_msg_spinlock[currentCPU]);
	msg = smp_msgs[currentCPU];
	if (msg != NULL) {
		printf("yeah\n");
		dummy_release_spinlock(&cpu_msg_spinlock[currentCPU]);
		*source_mailbox = 1;
	} else {
		// try getting one from the broadcast mailbox

		dummy_release_spinlock(&cpu_msg_spinlock[currentCPU]);
		dummy_acquire_spinlock_nocheck(&broadcast_msg_spinlock);

		msg = smp_broadcast_msgs;
		while (msg != NULL) {
			printf("yeah\n");
			msg = msg->next;
		}
		dummy_release_spinlock(&broadcast_msg_spinlock);
	}
	return msg;
}


int32
dummy_process_pending_ici(int32 currentCPU)
{
	int retval = 42;
	int sourceMailbox = 0;

	dummy_smp_msg* msg = dummy_check_for_message(currentCPU, &sourceMailbox);
	if (msg == NULL)
		return retval;

	switch ((addr_t)msg) {
		case 0:
			printf("foo\n");
			break;
		case 1:
			printf("foo\n");
			break;
		case 2:
			printf("foo\n");
			break;
	}

	return 9;
}


static void
test_spinlock(dummy_spinlock* lock)
{
	while (atomic_add(&lock->lock, -1) != 0)
		dummy_process_pending_ici(0);
}


static double
estimate_spinlock_tick_time()
{
	// time the spinlock
	int32 count = (INT_MAX >> 16) + 1;
	while (true) {
		bigtime_t startTime = system_time();

		dummy_spinlock lock;
		lock.lock = count;
		test_spinlock(&lock);

		bigtime_t totalTime = system_time() - startTime;
		double tickTime = (double)totalTime / count;

		if (totalTime > 1000000 || INT_MAX >> 2 < count)
			return tickTime;

		count <<= 1;
	}
}


static const char*
time_string(double timeInUsecs, char* buffer)
{
	static const char* const kUnits[] = { "us", "ms", "s ", NULL };

	double time = timeInUsecs;

	int32 i = 0;
	while (time > 1000 && kUnits[i + 1] != NULL) {
		time /= 1000;
		i++;
	}

	sprintf(buffer, "%.3f %s", time, kUnits[i]);

	return buffer;
}


int
main(int argc, char** argv)
{
	// get the initial contention info
	spinlock_contention_info startInfo;
	status_t error = _kern_generic_syscall(SPINLOCK_CONTENTION,
		GET_SPINLOCK_CONTENTION_INFO, &startInfo, sizeof(startInfo));
	if (error != B_OK) {
		fprintf(stderr, "Error: Failed to get spinlock contention info: %s\n",
			strerror(error));
		exit(1);
	}
	bigtime_t startTime = system_time();

	pid_t child = fork();
	if (child < 0) {
		fprintf(stderr, "Error: fork() failed: %s\n", strerror(errno));
		exit(1);
	}

	if (child == 0) {
		execvp(argv[1], argv + 1);
		fprintf(stderr, "Error: exec() failed: %s\n", strerror(errno));
		exit(1);
	} else {
		int status;
		wait(&status);
	}

	// get the final contention info
	spinlock_contention_info endInfo;
	error = _kern_generic_syscall(SPINLOCK_CONTENTION,
		GET_SPINLOCK_CONTENTION_INFO, &endInfo, sizeof(endInfo));
	if (error != B_OK) {
		fprintf(stderr, "Error: Failed to get spinlock contention info: %s\n",
			strerror(error));
		exit(1);
	}
	bigtime_t totalTime = system_time() - startTime;

	char buffer[128];
	printf("\ntotal run time: %s\n", time_string(totalTime, buffer));

	// estimate spinlock tick time
	printf("estimating time per spinlock tick...\n");
	double tickTime = estimate_spinlock_tick_time();
	printf("time per spinlock tick: %s\n",
		time_string(tickTime, buffer));

	// print results
	static const char* const kLockNames[] = { "thread creation", NULL };
	bigtime_t lockCounts[] = {
		endInfo.thread_creation_spinlock - startInfo.thread_creation_spinlock,
	};

	printf("\nlock             counter            time   wasted %% CPU\n");
	printf("-------------------------------------------------------\n");
	for (int32 i = 0; kLockNames[i] != NULL; i++) {
		double wastedUsecs = lockCounts[i] * tickTime;
		printf("%-10s  %12llu  %14s   %12.4f\n", kLockNames[i], lockCounts[i],
			time_string(wastedUsecs, buffer), wastedUsecs / totalTime * 100);
	}

	return 0;
}