Benchmarking Results

In this post, we will be recording the results of our sample scaling using the 3 approaches, Naive Algorithm, Lookup-based Algorithm, and Fixed-point Algorithm. We will also analyze the results on which algorithm had the best performance using CPU time as the measurement.


Naive AlgorithmLookup-based AlgorithmFixed-point Algorithm
Wall Clock4000Wall Clock22000Wall Clock3000
CPU Clock4076.95CPU Clock22375.35CPU Clock2475.85
Wall Clock4000Wall Clock22000Wall Clock2000
CPU Clock4145.72CPU Clock22135.35CPU Clock2475.36
Wall Clock4000Wall Clock22000Wall Clock3000
CPU Clock4077.11CPU Clock22108.9CPU Clock2476.09
Wall Clock4000Wall Clock22000Wall Clock3000
CPU Clock4078.33CPU Clock22167.79CPU Clock2475.88
Wall Clock4000Wall Clock23000Wall Clock2000
CPU Clock4170.97CPU Clock22178.86CPU Clock2475.34

Analysis – Lookup-based Algorithm

Based on the results of the tests ran, Lookup-based Algorithm had the slowest average run time at 22193.25 seconds. It was 81.48% slower then the Naive Algorithm ((lookupAverage-naiveAverage)/lookupAverage). Also, it was slower then the Fixed-point Algorithm by 88.84% ((lookupAverage-fixedpointAverage)/lookupAverage). This algorithm was the slowest out of the three discussed above.

Analysis – Fixed-point Algorithm

In the results gathered, Fixed-point Algorithm had the fastest average run time at 2475.704 seconds. We already know that Fixed-point Algorithm was faster then Lookup-based Algorithm by 88.84%, but it was also faster then the Naive Algorithm. The difference in run time was 39.76%. Fixed-point Algorithm was the fastest run time out of the three.

Analysis – Naive Algorithm

The Naive Algorithm was not the best, nor was it the worst. It may have not been as fast as Fixed-point Algorithm in terms of Average time to complete the task, but it did relatively good. Naive and Fixed-point had an Average run time of 4.109816 seconds and 2.475704 seconds, respectively. This is only a 1.634112 seconds difference between the two algorithms. Naive Algorithm had a decent run time when compared to the other three algorithms discussed.


In conclusion, Fixed-point Algorithm had the fastest run time, due to its avoidance of converting an int to a double, multiplying the two doubles together, then converting it back to an int. This saves the time by not using the decimal mode embedded in the Aarch64. Naive Algorithm had a decent run time with it almost similar to fixed-point, but it converted the values from int to double then back to int. Both algorithms had to do an multiplying operation for each sample. The Lookup-based Algorithm surprised me the most. Maybe it could be the fact that it had to switch to decimal mode with each operation, but it had the slowest run time. Possibly, if we removed the switching to decimal mode, then creating a table, Lookup-based Algorithm may be faster then the other 2 algorithms.

Published by Danny Nguyen

I am a curious person. I find interest in all aspects of software development cycle, software stacks, and how the same software is used in different industries in different ways

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Create your website with
Get started
%d bloggers like this: