Timing Utilities

This is a small compiled library for C timing functions with higher precision than time.h

(Return)

---

Summary

This is primarily used for generating "clock threads." That can help add interrupts with arbitrary precision for example while running some timed state within a larger state machine multi-threaded or networked application.

Example Use

Consider the following basic application, which just creates a thread and then sleeps a bit, stops the thread, and then prints out the number of tick cycles and total time elapsed based on the system time differences:

// timing_example.c
#include "timing.h"
#include "stdio.h"
#include "stdlib.h"
#include <pthread_t.h>
 
typedef struct {
  uint16_t counter = 0; /*< Number of ticks >*/
  double ts = 0; /*< Number of seconds elapsed from start >*/
} Data;
int running;
pthread_mutex_t mutex;
 
int main() {
  pthread_t thread;
  running = 1;
  Data* myData = malloc(sizeof(Data));
  mutex = PTHREAD_MUTEX_INITIALIZER;
  pthread_create(&thread, myData, run, NULL); // Create and start running the thread
 
  Sleep(500); // Let thread run for 500 ms
  running = 0; // Stop the thread
  pthread_join(thread, NULL); // Wait for thread to cleanup
  pthread_mutex_destroy(&mutex);
  printf("%hu ticks | %.3fs elapsed\n", myData->counter, myData->ts);
  free(Data);
  return 0;
}
 
void* run(void* arg) {
  Data* args = (Data*)arg; // Cast to defined structure
  LARGE_INTEGER main_start, tick_start, tick_end;
  double elapsed_time;
  QueryPerformanceCounter(&main_start);
  tick_start = main_start;
  while (running) {
    pthread_mutex_lock(&mutex);
    QueryPerformanceCounter(&tick_end);
    elapsed_time = getElapsedTime(tick_start.QuadPart, tick_end.QuadPart);
    if (elapsed_time >= 0.001) { // Does this part every millisecond then resets.
      args->counter++;
      tick_start = tick_end;
    }
    pthread_mutex_unlock(&mutex);
  }
  pthread_mutex_lock(&mutex);
  args->ts = getElapsedTime(main_start.QuadPart, tick_end.QuadPart);
  pthread_mutex_unlock(&mutex);
}

Note how the data is shared in this thread. We can access the shared data structure safely using pthread_mutex_lock(&mutex); to ensure synchronization in case we want to share this data structure with other threads.

---

Contents

• Compiling
  • Library
  • In Other Projects
• Using `gcc` on Windows

Compiling

Library

To re-compile the static link library (.lib), use the following command:

cd %NML_NHP_C_PROJECTS%/TimingUtilities && gcc -c src/timing.c -o lib/timing.o && ar rcs lib/Timing.lib lib/timing.o && cp src/timing.h ../StateServer/include/timing.h && cp lib/Timing.lib ../StateServer/lib/Timing.lib && cp lib/Timing.lib ../TaskController/lib/Timing.lib && cp src/timing.h ../TaskController/include/timing.h && doxygen

For External Use

Assume we have the following project folder structure:

my_project
|--src
|  |--my_code.c
|  |--my_code.h
|
|--include
|  |--timing.h
|
|--lib
|  |--Timing.lib

To compile, you would use the following command:

 (bash)
gcc -o bin/my_executable.exe src/my_code.c -Llib -Iinclude -lTiming

Note about gcc

Note that to use gcc on a Windows 64-bit architecture, the simplest way is to download msys2, which will allow you to use pacman from an msys2 terminal. You can first check to see if you already have gcc installed:

 (bash)
pacman -Q | grep mingw-w64-x86_64-gcc

If you see anything in the terminal following this command, it means you already have gcc. Otherwise, you need to install it (and probably the rest of the toolchain, such as a linker etc.):

 (bash)
pacman -S mingw-w64-x86_64-toolchain

This will give several options for what you can install. If you are unsure what to do, just install all of them.
Finally, you may also want a toolchain for compiling 32-bit applications from your 64-bit Windows operating system. In that case, you can try:

 (bash)
pacman -S mingw-w64-i686-toolchain

The last step is to make sure the folder with the correct binaries are on your PATH environment variable. Probably the best strategy here, on a Windows device, is as follows:

1. Open the Start menu and type Environment, this should bring up a Control Panel shortcut to "Edit the System Environment Variables." Click that.
   
2. Click "Environment Variables..." at the bottom right.
   
3. Under System Variables, click "New..." and define a new environment variable: MINGW_PATH. If you installed msys2 in the default location, then go to C:/mingw64. You will be looking for the sub-folder containing binaries. In my install, that is located at C:\msys64\mingw64\bin – so that is my MINGW_PATH environment variable.
   
4. Under User Variables, find Path. Click Edit... with Path selected.
   
5. In the new popup, click New to add a new Path value. Enter MINGW_PATH (note that in Windows, you need a % sign on either side of the environment variable while in other OS you typically use $ leading the environment variable). Now, you can add or remove MINGW_PATH from the user Path variable depending on what compiler needs you have. Click on the newly added value, and click Move Up until it is at the top of the list. This ensures we don't accidentally find gcc somewhere else and use a different unintended version. Note that if you want to switch between i.e. C:\msys64\mingw32\bin and C:\msys64\mingw64\bin it might just be easiest to change the value of MINGW_PATH environment variable.