user/applications/thread-test/main.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include <errno.h>
#include <list>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
 
#include <pedigree/log.h>
#include <sys/time.h>
 
#define LOOPS 1024  // 10000000
 
// Modified from http://www.alexonlinux.com/do-you-need-mutex-to-protect-int
// Uses mutexes or spinlocks
 
using namespace std;
 
list<int> the_list;
 
// #define USE_SPINLOCK
 
#ifdef USE_SPINLOCK
pthread_spinlock_t spinlock;
#else
pthread_mutex_t mutex;
#endif
 
void* consumer(void* ptr) {
  int i;
 
  printf("Consumer TID %lu\n", (unsigned long)ptr);
 
  while (1) {
#ifdef USE_SPINLOCK
    pthread_spin_lock(&spinlock);
#else
    pthread_mutex_lock(&mutex);
#endif
 
    if (the_list.empty()) {
#ifdef USE_SPINLOCK
      pthread_spin_unlock(&spinlock);
#else
      pthread_mutex_unlock(&mutex);
#endif
      break;
    }
 
    i = the_list.front();
    the_list.pop_front();
 
#ifdef USE_SPINLOCK
    pthread_spin_unlock(&spinlock);
#else
    pthread_mutex_unlock(&mutex);
#endif
  }
 
  return NULL;
}
 
int main() {
  int i;
  pthread_t thr1, thr2;
  struct timeval tv1, tv2;
 
#ifdef USE_SPINLOCK
  pthread_spin_init(&spinlock, 0);
#else
  pthread_mutex_init(&mutex, NULL);
#endif
 
  // syslog used to split up debug logs.
  pedigree_log(LOG_INFO, "TEST 0");
 
  printf("Locking without any contention...\n");
  pthread_mutex_t contention_mutex;
  pthread_mutex_init(&contention_mutex, 0);
  pthread_mutex_lock(&contention_mutex);
  printf("Acquired\n");
  pthread_mutex_unlock(&contention_mutex);
  printf("Released!\n");
 
  pedigree_log(LOG_INFO, "TEST 1");
 
  printf("Creating a recursive lock!\n");
  pthread_mutex_t recursive;
  pthread_mutexattr_t attr;
  pthread_mutexattr_init(&attr);
  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
  pthread_mutex_init(&recursive, &attr);
  printf("Testing recursion...\n");
  pthread_mutex_lock(&recursive);
  pthread_mutex_lock(&recursive);
  pthread_mutex_lock(&recursive);
  printf("Locked OK, testing unlock...\n");
  pthread_mutex_unlock(&recursive);
  pthread_mutex_unlock(&recursive);
  pthread_mutex_unlock(&recursive);
  printf("Testing re-acquire...\n");
  pthread_mutex_lock(&recursive);
  printf("OK!\n");
 
  pedigree_log(LOG_INFO, "TEST 2");
  printf("Locking with deadlock\n");
  pthread_mutex_t deadlock_mutex;
  pthread_mutexattr_t deadlock_attr;
  pthread_mutexattr_init(&deadlock_attr);
  pthread_mutexattr_settype(&deadlock_attr, PTHREAD_MUTEX_ERRORCHECK);
  pthread_mutex_init(&deadlock_mutex, &deadlock_attr);
  pthread_mutexattr_destroy(&deadlock_attr);
  i = pthread_mutex_lock(&deadlock_mutex);
  printf("First lock: %d (%s)\n", i, strerror(i));
  i = pthread_mutex_lock(&deadlock_mutex);
  if (i != EDEADLK)
    printf("Didn't get EDEADLK!\n");
  printf("Second lock: %d (%s)\n", i, strerror(i));
  pthread_mutex_unlock(&deadlock_mutex);
  pthread_mutex_destroy(&deadlock_mutex);
 
  // Creating the list content...
  for (i = 0; i < LOOPS; i++)
    the_list.push_back(i);
 
  // Measuring time before starting the threads...
  gettimeofday(&tv1, NULL);
 
  pedigree_log(LOG_INFO, "TEST 3");
  pthread_create(&thr1, NULL, consumer, (void*)1);
  pthread_create(&thr2, NULL, consumer, (void*)2);
 
  pthread_join(thr1, NULL);
  pthread_join(thr2, NULL);
  pedigree_log(LOG_INFO, "TEST 4");
 
  // Measuring time after threads finished...
  gettimeofday(&tv2, NULL);
 
  if (tv1.tv_usec > tv2.tv_usec) {
    tv2.tv_sec--;
    tv2.tv_usec += 1000000;
  }
 
  printf("Result - %ld.%ld\n", tv2.tv_sec - tv1.tv_sec, tv2.tv_usec - tv1.tv_usec);
 
#ifdef USE_SPINLOCK
  pthread_spin_destroy(&spinlock);
#else
  pthread_mutex_destroy(&mutex);
#endif
 
  return 0;
}