taucmdr 1.7.0__tar.gz

taucmdr-1.7.0/.dockerignore

@@ -0,0 +1,12 @@
+**/*.pyo
+**/*.pyc
+build/
+system/
+VERSION
+**/*.egg-info
+**/*.egg
+venv/
+.idea/
+.tox/
+dist/
+plans/

taucmdr-1.7.0/.testfiles/blockmatrix-coarray.f90

@@ -0,0 +1,83 @@
+program blockmatrix
+    implicit none
+    integer, dimension(:,:), codimension[:,:], allocatable :: a, b, c
+    integer, dimension(:,:), allocatable :: bigmat
+    integer :: numimgs
+    integer :: nrows, ncols
+    integer :: blockrows=5, blockcols=5
+    integer :: myrow, mycol
+    integer :: startrow, startcol
+    integer :: i,j,k
+
+    ! calculate block decomposition
+    numimgs = num_images()
+    call nearsquare(numimgs, nrows, ncols)
+    if (nrows /= ncols) then
+        print *,'Sorry, only works for square numbers of images right now.'
+        stop
+    endif
+    allocate(a(blockrows,blockcols)[nrows,*])
+    allocate(b(blockcols,blockrows)[nrows,*])
+    allocate(c(blockrows,blockrows)[nrows,*])
+
+    ! where is this image in the decomposition?
+    mycol = ceiling(this_image()*1./nrows)
+    myrow = modulo(this_image(),nrows)
+    if (myrow == 0) myrow=nrows
+
+    ! initialize data
+    startrow = (myrow-1)*blockrows+1
+    startcol = (mycol-1)*blockcols+1
+    do i=1,blockrows
+        a(i,:) = startrow+i-1
+    enddo
+    do j=1,blockcols
+        b(:,j) = startcol+j-1
+    enddo
+
+    ! do the multiplication
+    sync all
+    c = 0.
+    do k=1,ncols
+        c = c + matmul(a(:,:)[myrow,k],b(:,:)[k,mycol])
+    enddo
+    sync all
+
+    if (this_image() == 1) then
+        allocate(bigmat(nrows*blockrows,ncols*blockcols))
+        bigmat = reshape( [((i,i=1,nrows*blockrows),j=1,ncols*blockcols)], &
+                          [nrows*blockrows, ncols*blockcols])
+        print *, 'Expected answer: '
+        bigmat = matmul(bigmat,transpose(bigmat))
+        do i=1,blockrows*nrows
+             print '(50(I5,1X))',(bigmat(i,j),j=1,blockcols*ncols)
+        enddo
+        deallocate(bigmat)
+    endif
+
+    do k=1,num_images()
+        if (this_image() == k) then
+            print *, 'Image ', k, ' = ', myrow, ', ', mycol
+            do i=1,blockrows
+                 print '(50(I5,1X))',(c(i,j),j=1,blockcols)
+            enddo
+        endif
+        sync all
+    enddo
+    deallocate(a)
+    deallocate(b)
+    deallocate(c)
+
+contains
+    subroutine nearsquare(n, a, b)
+        implicit none
+        integer, intent(in) :: n
+        integer, intent(out) :: a, b
+
+        do a=ceiling(sqrt(n*1.0)),1,-1
+            b = n/a
+            if (a*b == n) exit
+        enddo
+    end subroutine nearsquare
+
+end program blockmatrix

taucmdr-1.7.0/.testfiles/firstprime.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+# Program written by Devin Shende on August 5th 2018
+
+def first_prime_after(x):
+    import math
+    current = x + 1
+    sqrtno = math.sqrt(current)
+    while True:
+        # search for primes starting at x until it finds one
+        # break once found a prime
+        for potential_factor in range(2, current):
+            # start at 2 because 1 will always be a factor
+            # go all the way up to the sqrt of current looking for a factor
+            if current % potential_factor == 0:
+                # Found factor. not prime
+                break  # move on to next number
+            elif potential_factor >= sqrtno:
+                print("The first prime number after {} is {}".format(x, current))
+                return current
+        current += 1
+
+
+first_prime_after(10000000)

taucmdr-1.7.0/.testfiles/foo_launcher

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+echo "FOO LAUNCHER"
+
+args=()
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+  -np | -G | foo_file) ;;
+
+  *)
+    args+=("$1")
+    ;;
+  esac
+  shift
+done
+
+${args[*]}

taucmdr-1.7.0/.testfiles/hello.c

@@ -0,0 +1,7 @@
+#include<stdio.h>
+
+int main(int argc, char *argv[])
+{
+    printf("Hello World\n");
+    return 0;
+}

taucmdr-1.7.0/.testfiles/io.c

@@ -0,0 +1,23 @@
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+
+/* Makes a known number of POSIX I/O calls: 10 open, 5 write, 5 read, 10 close. */
+int main(int argc, char *argv[])
+{
+    char buf[16] = "hello io\n";
+    for (int i = 0; i < 5; ++i) {
+        int fd = open("io-test.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
+        if (fd < 0 || write(fd, buf, 9) != 9 || close(fd) != 0) {
+            perror("write io-test.txt");
+            return 1;
+        }
+        fd = open("io-test.txt", O_RDONLY);
+        if (fd < 0 || read(fd, buf, sizeof buf) != 9 || close(fd) != 0) {
+            perror("read io-test.txt");
+            return 1;
+        }
+    }
+    printf("Done\n");
+    return 0;
+}

taucmdr-1.7.0/.testfiles/jacobi.c

@@ -0,0 +1,85 @@
+/*
+ *  Copyright 2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <math.h>
+#include <string.h>
+#include <openacc.h>
+#include <stdio.h>
+#include "timer.h"
+
+#define NN 1024
+#define NM 1024
+
+double A[NN][NM];
+double Anew[NN][NM];
+
+int main(int argc, char** argv)
+{
+    const int n = NN;
+    const int m = NM;
+    const int iter_max = 1000;
+    
+    const double tol = 1.0e-6;
+    double error     = 1.0;
+    
+    memset(A, 0, n * m * sizeof(double));
+    memset(Anew, 0, n * m * sizeof(double));
+        
+    for (int j = 0; j < n; j++)
+    {
+        A[j][0]    = 1.0;
+        Anew[j][0] = 1.0;
+    }
+    
+    printf("Jacobi relaxation Calculation: %d x %d mesh\n", n, m);
+    
+    StartTimer();
+    int iter = 0;
+   
+#pragma acc data copyin(Anew), copy(A) 
+    while ( error > tol && iter < iter_max )
+    {
+        error = 0.0;
+
+#pragma acc kernels
+        for( int j = 1; j < n-1; j++)
+        {
+            for( int i = 1; i < m-1; i++ )
+            {
+                Anew[j][i] = 0.25 * ( A[j][i+1] + A[j][i-1]
+                                    + A[j-1][i] + A[j+1][i]);
+                error = fmax( error, fabs(Anew[j][i] - A[j][i]));
+            }
+        }
+        
+#pragma acc kernels
+        for( int j = 1; j < n-1; j++)
+        {
+            for( int i = 1; i < m-1; i++ )
+            {
+                A[j][i] = Anew[j][i];    
+            }
+        }
+
+        if(iter % 100 == 0) printf("%5d, %0.6f\n", iter, error);
+        
+        iter++;
+    }
+
+    double runtime = GetTimer();
+ 
+    printf(" total: %f s\n", runtime / 1000);
+}

taucmdr-1.7.0/.testfiles/matmult.c

@@ -0,0 +1,313 @@
+/******************************************************************************
+ *   OpenMp Example - Matrix Multiply - C Version
+ *   Demonstrates a matrix multiply using OpenMP.
+ *
+ *   Modified from here:
+ *   https://computing.llnl.gov/tutorials/openMP/samples/C/omp_mm.c
+ *
+ *   For  PAPI_FP_INS, the exclusive count for the event:
+ *   for (null) [OpenMP location: file:matmult.c ]
+ *   should be  2E+06 / Number of Threads
+******************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef TAU_MPI
+int provided;
+#include <mpi.h>
+/* NOTE: MPI is just used to spawn multiple copies of the kernel to different ranks.
+   This is not a parallel implementation */
+#endif /* TAU_MPI */
+
+#ifdef PTHREADS
+#include <pthread.h>
+#include <unistd.h>
+#include <errno.h>
+/*** NOTE THE ATTR INITIALIZER HERE! ***/
+pthread_mutex_t mutexsum;
+#endif /* PTHREADS */
+
+#define APP_USE_INLINE_MULTIPLY 1
+
+#ifndef MATRIX_SIZE
+#define MATRIX_SIZE 512
+#endif
+
+#define NRA MATRIX_SIZE                 /* number of rows in matrix A */
+#define NCA MATRIX_SIZE                 /* number of columns in matrix A */
+#define NCB MATRIX_SIZE                 /* number of columns in matrix B */
+
+
+void initialize(double **matrix, int rows, int cols) {
+  int i,j;
+#pragma omp parallel private(i,j) shared(matrix)
+  {
+    //set_num_threads();
+    /*** Initialize matrices ***/
+#pragma omp for nowait
+    for (i=0; i<rows; i++) {
+      for (j=0; j<cols; j++) {
+        matrix[i][j]= i+j;
+      }
+    }
+  }
+}
+
+double** allocateMatrix(int rows, int cols) {
+  int i;
+  double **matrix = (double**)malloc((sizeof(double*)) * rows);
+  for (i=0; i<rows; i++) {
+    matrix[i] = (double*)malloc((sizeof(double)) * cols);
+  }
+  return matrix;
+}
+
+void freeMatrix(double** matrix, int rows, int cols) {
+  int i;
+  for (i=0; i<rows; i++) {
+    free(matrix[i]);
+  }
+  free(matrix);
+}
+
+double multiply(double a, double b) {
+  return a * b;
+}
+
+#ifdef TAU_OPENMP
+// cols_a and rows_b are the same value
+void compute_nested(double **a, double **b, double **c, int rows_a, int cols_a, int cols_b) {
+  int i,j,k;
+  double tmp = 0.0;
+  /*** Do matrix multiply sharing iterations on outer loop ***/
+  /*** Display who does which iterations for demonstration purposes ***/
+#pragma omp parallel for private(i,j,k) shared(a,b,c)
+  for (i=0; i<rows_a; i++) {
+    {
+      for (k=0; k<cols_a; k++) {
+        for(j=0; j<cols_b; j++) {
+#ifdef APP_USE_INLINE_MULTIPLY
+          c[i][j] += multiply(a[i][k], b[k][j]);
+#else
+          tmp = a[i][k];
+          tmp = tmp * b[k][j];
+          c[i][j] += tmp;
+#endif
+        }
+      }
+    }
+  }
+}
+#endif
+
+// cols_a and rows_b are the same value
+void compute(double **a, double **b, double **c, int rows_a, int cols_a, int cols_b) {
+  int i,j,k;
+#pragma omp parallel private(i,j,k) shared(a,b,c)
+  {
+    /*** Do matrix multiply sharing iterations on outer loop ***/
+    /*** Display who does which iterations for demonstration purposes ***/
+#pragma omp for nowait
+    for (i=0; i<rows_a; i++) {
+      for(j=0; j<cols_b; j++) {
+        for (k=0; k<cols_a; k++) {
+#ifdef APP_USE_INLINE_MULTIPLY
+          c[i][j] += multiply(a[i][k], b[k][j]);
+#else /* APP_USE_INLINE_MULTIPLY */
+          c[i][j] += a[i][k] * b[k][j];
+#endif /* APP_USE_INLINE_MULTIPLY */
+        }
+      }
+    }
+  }   /*** End of parallel region ***/
+}
+
+void compute_interchange(double **a, double **b, double **c, int rows_a, int cols_a, int cols_b) {
+  int i,j,k;
+#pragma omp parallel private(i,j,k) shared(a,b,c)
+  {
+    /*** Do matrix multiply sharing iterations on outer loop ***/
+    /*** Display who does which iterations for demonstration purposes ***/
+#pragma omp for nowait
+    for (i=0; i<rows_a; i++) {
+      for (k=0; k<cols_a; k++) {
+        for(j=0; j<cols_b; j++) {
+#ifdef APP_USE_INLINE_MULTIPLY
+          c[i][j] += multiply(a[i][k], b[k][j]);
+#else /* APP_USE_INLINE_MULTIPLY */
+          c[i][j] += a[i][k] * b[k][j];
+#endif /* APP_USE_INLINE_MULTIPLY */
+        }
+      }
+    }
+  }   /*** End of parallel region ***/
+}
+
+double do_work(void) {
+  double **a,           /* matrix A to be multiplied */
+         **b,           /* matrix B to be multiplied */
+         **c;           /* result matrix C */
+  a = allocateMatrix(NRA, NCA);
+  b = allocateMatrix(NCA, NCB);
+  c = allocateMatrix(NRA, NCB);
+
+  /*** Spawn a parallel region explicitly scoping all variables ***/
+
+  initialize(a, NRA, NCA);
+  initialize(b, NCA, NCB);
+  initialize(c, NRA, NCB);
+
+  compute(a, b, c, NRA, NCA, NCB);
+#if defined(TAU_OPENMP)
+  //if (omp_get_nested()) {
+  compute_nested(a, b, c, NRA, NCA, NCB);
+  //}
+#endif
+#ifdef TAU_MPI
+  if (provided == MPI_THREAD_MULTIPLE) {
+    printf("provided is MPI_THREAD_MULTIPLE\n");
+  } else if (provided == MPI_THREAD_FUNNELED) {
+    printf("provided is MPI_THREAD_FUNNELED\n");
+  }
+#endif /* TAU_MPI */
+  compute_interchange(a, b, c, NRA, NCA, NCB);
+
+  double result = c[0][1];
+
+  freeMatrix(a, NRA, NCA);
+  freeMatrix(b, NCA, NCB);
+  freeMatrix(c, NCA, NCB);
+
+  return result;
+}
+
+#ifdef PTHREADS
+int busy_sleep() {
+  int i, sum = 0;
+  for (i = 0 ; i < 100000000 ; i++) {
+    sum = sum+i;
+  }
+  return sum;
+}
+
+void * threaded_func(void *data)
+{
+  int rc;
+  int sum = 0;
+  // compute
+  do_work();
+
+#ifdef APP_DO_LOCK_TEST
+  // test locking - sampling should catch this
+  if ((rc = pthread_mutex_lock(&mutexsum)) != 0)
+  {
+    errno = rc;
+    perror("thread lock error");
+    exit(1);
+  }
+  fprintf(stderr,"Thread 'sleeping'...\n"); fflush(stderr);
+  sum += busy_sleep();
+  fprintf(stderr,"Thread 'awake'...\n"); fflush(stderr);
+  if ((rc = pthread_mutex_unlock(&mutexsum)) != 0)
+  {
+    errno = rc;
+    perror("thread unlock error");
+    exit(1);
+  }
+  pthread_exit((void*) 0);
+  //return NULL;
+#endif // APP_DO_LOCK_TEST
+}
+#endif // PTHREADS
+
+int main (int argc, char *argv[])
+{
+
+#ifdef PTHREADS
+  int ret;
+  pthread_attr_t  attr;
+  pthread_t       tid1, tid2, tid3;
+  pthread_mutexattr_t Attr;
+  pthread_mutexattr_init(&Attr);
+  pthread_mutexattr_settype(&Attr, PTHREAD_MUTEX_ERRORCHECK);
+  if (pthread_mutex_init(&mutexsum, &Attr)) {
+    printf("Error while using pthread_mutex_init\n");
+  }
+#endif /* PTHREADS */
+
+#ifdef TAU_MPI
+  int rc = MPI_SUCCESS;
+#if defined(PTHREADS)
+  rc = MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
+  printf("MPI_Init_thread: provided = %d, MPI_THREAD_MULTIPLE=%d\n", provided, MPI_THREAD_MULTIPLE);
+#elif defined(TAU_OPENMP)
+  rc = MPI_Init_thread(&argc, &argv, MPI_THREAD_FUNNELED, &provided);
+  printf("MPI_Init_thread: provided = %d, MPI_THREAD_FUNNELED=%d\n", provided, MPI_THREAD_FUNNELED);
+#else
+  rc = MPI_Init(&argc, &argv);
+#endif /* THREADS */
+  if (rc != MPI_SUCCESS) {
+    char *errorstring;
+    int length = 0;
+    MPI_Error_string(rc, errorstring, &length);
+    printf("Error: MPI_Init failed, rc = %d\n%s\n", rc, errorstring);
+    exit(1);
+  }
+#endif /* TAU_MPI */
+
+#ifdef PTHREADS
+  if (ret = pthread_create(&tid1, NULL, threaded_func, NULL) )
+  {
+    printf("Error: pthread_create (1) fails ret = %d\n", ret);
+    exit(1);
+  }
+
+  if (ret = pthread_create(&tid2, NULL, threaded_func, NULL) )
+  {
+    printf("Error: pthread_create (2) fails ret = %d\n", ret);
+    exit(1);
+  }
+
+  if (ret = pthread_create(&tid3, NULL, threaded_func, NULL) )
+  {
+    printf("Error: pthread_create (3) fails ret = %d\n", ret);
+    exit(1);
+  }
+
+#endif /* PTHREADS */
+
+  /* On thread 0: */
+  int i;
+  //for (i = 0 ; i < 100 ; i++) {
+  do_work();
+  //}
+
+#ifdef PTHREADS
+  if (ret = pthread_join(tid1, NULL) )
+  {
+    printf("Error: pthread_join (1) fails ret = %d\n", ret);
+    exit(1);
+  }
+
+  if (ret = pthread_join(tid2, NULL) )
+  {
+    printf("Error: pthread_join (2) fails ret = %d\n", ret);
+    exit(1);
+  }
+
+  if (ret = pthread_join(tid3, NULL) )
+  {
+    printf("Error: pthread_join (3) fails ret = %d\n", ret);
+    exit(1);
+  }
+
+  pthread_mutex_destroy(&mutexsum);
+#endif /* PTHREADS */
+
+#ifdef TAU_MPI
+  MPI_Finalize();
+#endif /* TAU_MPI */
+  printf ("Done.\n");
+
+  return 0;
+}

taucmdr-1.7.0/.testfiles/mpi_hello.c

@@ -0,0 +1,18 @@
+#include <mpi.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main (int argc, char ** argv)
+{
+  int numtasks, taskid, len;
+  char hostname[MPI_MAX_PROCESSOR_NAME];
+
+  MPI_Init(&argc, &argv);
+  MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
+  MPI_Comm_rank(MPI_COMM_WORLD,&taskid);
+  MPI_Get_processor_name(hostname, &len);
+  printf ("Hello from task %d on %s!\n", taskid, hostname);
+  if (taskid == 0)
+       printf("Number of MPI tasks is: %d\n",numtasks);
+  MPI_Finalize();
+}

taucmdr-1.7.0/.testfiles/storage/v1.6.0/README

@@ -0,0 +1,2 @@
+Project and user databases written by TAU Commander v1.6.0 (Python 3.7), one for tinydb and one for sqlite
+Used to test backwards compatibility of future versions with older projects.

taucmdr-1.7.0/.testfiles/storage/v1.6.0/tinydb/project/.tau/project.json

@@ -0,0 +1 @@
+{"_default": {"1": {"key": "selected_project", "value": 1}}, "Project": {"1": {"name": "oldproj", "targets": [1], "applications": [1], "measurements": [1], "experiments": [], "init_options": "--bare --backend tinydb --project-name oldproj"}}, "Target": {"1": {"projects": [1], "name": "oldtarg", "host_os": "Linux", "host_arch": "x86_64", "Host_CC": 1, "Host_CXX": 2, "Host_FC": 3, "cuda_toolkit": "/usr/local/cuda", "tau_source": "download", "pdt_source": "download", "binutils_source": "download", "unwinder": "libunwind", "libunwind_source": "download", "libdwarf_source": "download", "libelf_source": "download", "papi_source": "download", "scorep_source": "download", "ompt_source": "download", "libotf2_source": "download", "sqlite3_source": "download", "level_zero_source": "download"}}, "Application": {"1": {"projects": [1], "name": "oldapp", "openmp": false, "openacc": false, "pthreads": false, "python": false, "tbb": false, "mpi": false, "caf": false, "cuda": false, "opencl": false, "shmem": false, "mpc": false, "linkage": "dynamic"}}, "Measurement": {"1": {"projects": [1], "name": "oldmeas", "baseline": false, "profile": "tau", "trace": "none", "sample": true, "source_inst": "never", "compiler_inst": "never", "mpi": false, "openmp": "ignore", "openacc": false, "cuda": false, "shmem": false, "opencl": false, "callpath": 100, "unwind_depth": 0, "io": false, "heap_usage": false, "system_load": false, "memory_alloc": false, "metrics": ["TIME"], "keep_inst_files": false, "reuse_inst_files": false, "comm_matrix": false, "throttle": true, "throttle_per_call": 10, "throttle_num_calls": 100000, "sample_resolution": "line", "sampling_period": 5000, "track_memory_footprint": false, "metadata_merge": true, "callsite": false, "update_nightly": false, "ptts": false, "ptts_post": false, "ptts_sample_flags": "", "ptts_restart": false, "ptts_start": "", "ptts_stop": "", "ptts_report_flags": "", "mpit": false, "level_zero": false, "tag": ""}}, "Experiment": {}, "Compiler": {"1": {"uid": "452187dd", "path": "/usr/bin/gcc", "family": "GNU", "role": "Host_CC"}, "2": {"uid": "ca4050bd", "path": "/usr/bin/g++", "family": "GNU", "role": "Host_CXX"}, "3": {"uid": "9edef6ab", "path": "/usr/bin/gfortran", "family": "GNU", "role": "Host_FC"}}}

taucmdr-1.7.0/.testfiles/storage/v1.6.0/tinydb/user/user.json

@@ -0,0 +1 @@
+{"_default": {}, "Project": {}, "Compiler": {"1": {"uid": "452187dd", "path": "/usr/bin/gcc", "family": "GNU", "role": "Host_CC"}, "2": {"uid": "ca4050bd", "path": "/usr/bin/g++", "family": "GNU", "role": "Host_CXX"}, "3": {"uid": "9edef6ab", "path": "/usr/bin/gfortran", "family": "GNU", "role": "Host_FC"}}, "Target": {"1": {"projects": [], "name": "usertarg", "host_os": "Linux", "host_arch": "x86_64", "Host_CC": 1, "Host_CXX": 2, "Host_FC": 3, "cuda_toolkit": "/usr/local/cuda", "tau_source": "download", "pdt_source": "download", "binutils_source": "download", "unwinder": "libunwind", "libunwind_source": "download", "libdwarf_source": "download", "libelf_source": "download", "papi_source": "download", "scorep_source": "download", "ompt_source": "download", "libotf2_source": "download", "sqlite3_source": "download", "level_zero_source": "download"}}, "Application": {}, "Measurement": {}}

taucmdr-1.7.0/.testfiles/timer.h

@@ -0,0 +1,67 @@
+/*
+ *  Copyright 2012 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef TIMER_H
+#define TIMER_H
+
+#include <stdlib.h>
+
+#ifdef WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#else
+#include <sys/time.h>
+#endif
+
+#ifdef WIN32
+double PCFreq = 0.0;
+__int64 timerStart = 0;
+#else
+struct timeval timerStart;
+#endif
+
+void StartTimer()
+{
+#ifdef WIN32
+    LARGE_INTEGER li;
+    if(!QueryPerformanceFrequency(&li))
+        printf("QueryPerformanceFrequency failed!\n");
+
+    PCFreq = (double)li.QuadPart/1000.0;
+
+    QueryPerformanceCounter(&li);
+    timerStart = li.QuadPart;
+#else
+    gettimeofday(&timerStart, NULL);
+#endif
+}
+
+// time elapsed in ms
+double GetTimer()
+{
+#ifdef WIN32
+    LARGE_INTEGER li;
+    QueryPerformanceCounter(&li);
+    return (double)(li.QuadPart-timerStart)/PCFreq;
+#else
+    struct timeval timerStop, timerElapsed;
+    gettimeofday(&timerStop, NULL);
+    timersub(&timerStop, &timerStart, &timerElapsed);
+    return timerElapsed.tv_sec*1000.0+timerElapsed.tv_usec/1000.0;
+#endif
+}
+
+#endif // TIMER_H