Benchmarking LabVIEW Code

Updated Nov 18, 2022

Reported In


  • LabVIEW

Issue Details

  • I want to measure the time it takes for a section of my code to run. What functions should I use?
  • I have a program in LabVIEW that uses a while loop, and I want to know how long it takes for my while loop to iterate. How can I benchmark my while loop?
  • I am acquiring data that is continuously changing, but there is a delay between when the data changes and when I see this update in my program. How can I tell if my while loop is causing this delay?


Benchmarking sections of code

To measure elapsed time in a piece of code, the best way is to use a Flat Sequence Structure in conjunction with a time count function or VI. Because the Flat Sequence Structure forces the code to run sequentially, you can use measure the time before and after your code runs. Subtract the time measurement before from the time measurement after to get elapsed time (delta t). 

The time count function or VI you should use depends on your use case.

Tick Count (ms)

For simple code measurements, use the Tick Count (ms) function. 
  • This is a good timing structure if your code runs on the order of milliseconds even up to days
  • The code being measured in the snippet below is a Wait (ms) function. Replace the Wait (ms) function with your own code to benchmark it
  • The snippet below will run once and give you a single timing comparison. If you would like to run code multiple times to get an average runtime, you can use the Measure Code Execution Time in LabVIEW example code which iterates code and outputs the average execution time.


Get Date/Time in Seconds

If your code needs to run on the order of months, use the Get Date/Time in Seconds function. Again, the code being measured in the snippet below is a Wait (ms) function. Replace the Wait (ms) function with your own code to benchmark it.


Tick Count Express VI (Real-Time)

If you are benchmarking code on a Real-Time target, you can use the Tick Count Express VI and configure it to show the elapsed time in ticks so you will have a more precise result.
  • Note that you can use this function on a Windows or other non-deterministic OS, but it will only have precision up to the millisecond.
  • Again, the code being measured in the snippet below is a Wait (ms) function. Replace the Wait (ms) function with your own code to benchmark it


Benchmarking Loops

You can benchmark how long it takes to iterate through a while loop (or a for loop) by using the Tick Count (ms) to take the current time in milliseconds and subtract it from the time during the previous iteration, which is saved in the shift register. 

Benchmarking Loops.png

You can code an alternate version that uses a Feedback Note instead of Shift Registers. You just need to drop the following code inside your while loop and get the Iteration time (ms) without any modification to your original code.

Note: The images above are LabVIEW code snippets, which include LabVIEW code that you can reuse in your project. To use a snippet, right-click the image, save it to your computer, and drag the file onto your LabVIEW diagram. 

Additional Information

  • The Tick Count (ms) VI returns a 32-bit number (0 to 4 billion), which means, when using the above method to measure elapsed time, the Tick Count (ms) VI can run continuously for roughly 2 months before it rolls over. The tick count is reset back to zero when you restart your computer, so restarting the computer occasionally can prevent the Tick Count (ms) VI from rolling over.
  • The Get Date/Time In Seconds VI returns the number of seconds that have elapsed since 1904. This VI will not roll over until about 2050.
  • If your while loop is taking a significant amount of time to execute each iteration, you may want to consider using multiple while loops. Implementing a producer/consumer architecture can help reduce the time it takes to iterate through each while loop and prevent data loss.