uw-tests.c

/*
 * UW - Synchronization test code.
 * Tim Brecht July, 2013
 * UW - uwvmstats tests code.
 * Tim Brecht January, 2014
 */

#include <types.h>
#include <synch.h>
#include <thread.h>
#include <test.h>
#include <uw-vmstats.h>

#define NAME_LEN (30)

static struct lock *testlock = NULL;
static struct semaphore *donesem = NULL;

#define NTESTLOOPS    (5000)  /* Needs to be evenly divisible by 8 */
#define NTESTTHREADS  (8)
#define START_VALUE   (0)
static volatile int test_value = START_VALUE;
static int use_locks = 1;

static
void
cleanitems(void)
{
        kprintf("cleanitems: Destroying sems and locks\n");
        lock_destroy(testlock);
  testlock = NULL;
        sem_destroy(donesem);
  donesem = NULL;
  test_value = START_VALUE;
}

static
void
inititems(void)
{
        if (testlock==NULL) {
                testlock = lock_create("testlock");
                if (testlock == NULL) {
                        panic("synchtest: lock_create failed\n");
                }
        }

        if (donesem==NULL) {
                donesem = sem_create("donesem", 0);
                if (donesem == NULL) {
                        panic("synchtest: sem_create failed\n");
                }
        }
}

/* This thread adds values to a global variable. */
static
void
add_thread(void *junk, unsigned long num)
{
        int i;
        (void) num;
        (void) junk;

        for (i=0; i<NTESTLOOPS; i++) {
                if (use_locks) {
                        lock_acquire(testlock);
                }

      /* This loop is unrolled to possibly avoid optimizations
       * and to provide more instructions that could be interrupted.
       * This may or may not be necessary.
       */
                  test_value = test_value + 1;
                  test_value = test_value + 1;
                  test_value = test_value + 1;
                  test_value = test_value + 1;
                  test_value = test_value + 1;

                if (use_locks) {
                        lock_release(testlock);
                }

        }
        V(donesem);
        thread_exit();
}

/* This thread substract values from a global variable. */
static
void
sub_thread(void *junk, unsigned long num)
{
        int i;
        (void)num;
        (void)junk;

        for (i=0; i<NTESTLOOPS; i++) {
                if (use_locks) {
                        lock_acquire(testlock);
                }

      /* This loop is unrolled to avoid optimizations
       * and to provide more instructions that could be interrupted.
       * This may or may not be necessary.
       */
                  test_value = test_value - 1;
                  test_value = test_value - 1;
                  test_value = test_value - 1;
                  test_value = test_value - 1;
                  test_value = test_value - 1;

                if (use_locks) {
                        lock_release(testlock);
                }

        }
        V(donesem);
        thread_exit();
}

int
uwlocktest1(int nargs, char **args)
{
        int i, result;
  char name[NAME_LEN];

        (void)nargs;
        (void)args;

        inititems();
        kprintf("Starting uwlocktest1...\n");

        for (i=0; i<NTESTTHREADS; i++) {
    snprintf(name, NAME_LEN, "add_thread %d", i);
                result = thread_fork(name, NULL, add_thread, NULL, i);
                if (result) {
                        panic("uwlocktest1: thread_fork failed: %s\n",
                              strerror(result));
                }
        }

        for (i=0; i<NTESTTHREADS; i++) {
    snprintf(name, NAME_LEN, "sub_thread %d", i);
                result = thread_fork(name, NULL, sub_thread, NULL, i);
                if (result) {
                        panic("uwlocktest1: thread_fork failed: %s\n",
                              strerror(result));
                }
        }

        for (i=0; i<NTESTTHREADS*2; i++) {
                P(donesem);
        }

        kprintf("value of test_value = %d should be %d\n", test_value, START_VALUE);
        if (test_value == START_VALUE) {
        kprintf("TEST SUCCEEDED\n");
  } else {
        kprintf("TEST FAILED\n");
  }
        KASSERT(test_value == START_VALUE);

        cleanitems();
        kprintf("uwlocktest1 done.\n");

        return 0;
}

/*-----------------------------------------------------------------------*/

/* Each thread makes some calls to vmstats functions */
static
void
vmstats_thread(void *junk, unsigned long num)
{
        int i;
        int j;
        (void)num;
        (void)junk;

        for (i=0; i<NTESTLOOPS; i++) {
    for (j=0; j<VMSTAT_COUNT; j++) {
        /* NOTE: The number of calls to vmstats_inc below have been manipulated
         * so the checks during printing add up properly and pass the various tests
         */
        switch(j) { 
          /* Need twice as many TLB faults */
          case VMSTAT_TLB_FAULT:
            vmstats_inc(j);
            vmstats_inc(j);
            break;

          case VMSTAT_TLB_FAULT_FREE:
            vmstats_inc(j);
            break;

          case VMSTAT_TLB_FAULT_REPLACE:
            vmstats_inc(j);
            break;

          /* Just reduce these to compare (not necessary) */
          case VMSTAT_TLB_INVALIDATE:
            if (i % 2 == 0) {
               vmstats_inc(j);
            }
            break;

          case VMSTAT_TLB_RELOAD:
            vmstats_inc(j);
            break;

          /* VMSTAT_TLB_FAULT = VMSTAT_TLB_RELOAD + VMSTAT_PAGE_FAULT_DISK + VMSTAT_SWAP_FILE_ZERO */
          case VMSTAT_PAGE_FAULT_ZERO:
            if (i % 2 == 0) {
               vmstats_inc(j);
            }
            break;

          /* VMSTAT_PAGE_FAULT_DISK = VMSTAT_ELF_FILE_READ + VMSTAT_SWAP_FILE_READ */
          case VMSTAT_PAGE_FAULT_DISK:
            if (i % 2 == 0) {
               vmstats_inc(j);
            }
            break;

          case VMSTAT_ELF_FILE_READ:
            if (i % 4 == 0) {
               vmstats_inc(j);
            }
            break;

          case VMSTAT_SWAP_FILE_READ:
            if (i % 4 == 0) {
               vmstats_inc(j);
            }
            break;

          case VMSTAT_SWAP_FILE_WRITE:
            if (i % 8 == 0) {
               vmstats_inc(j);
            }
            break;

          default:
            kprintf("Unknown stat %d\n", j);
            break;
      }
    }
        }

        V(donesem);
        thread_exit();
}

int
uwvmstatstest(int nargs, char **args)
{
        int i, result;
  char name[NAME_LEN];

        (void)nargs;
        (void)args;

        inititems();
        kprintf("Starting uwvmstatstest...\n");

  kprintf("Initializing vmstats\n");
  vmstats_init();

        for (i=0; i<NTESTTHREADS; i++) {
    snprintf(name, NAME_LEN, "vmstatsthread %d", i);
                result = thread_fork(name, NULL, vmstats_thread, NULL, i);
                if (result) {
                        panic("uwvmstatstest: thread_fork failed: %s\n",
                              strerror(result));
                }
        }

        for (i=0; i<NTESTTHREADS; i++) {
                P(donesem);
        }

  vmstats_print();

        cleanitems();
        kprintf("uwvmstatstest done.\n");

        return 0;
}