Code to calculate the execution time in seconds and nanoseconds

[survuvi]

I've refined the code to calculate the execution time in both seconds and nanoseconds:

For mojo:

from Time import now

start_time = now()

"start the mojo code you want to test:"




"stop the mojo code you want to test"

end_time = now()

let execution_time_nanoseconds : F64 = end_time - start_time

let execution_time_seconds :  F64 = execution_time_nanoseconds / 1000000000

print("Execution time: ", execution_time_seconds, "seconds or ", execution_time_nanoseconds, "nanoseconds")

For python:

%%python

import time

start_time = time.time()

"start the python code you want to test:"





"stop the python code you want to test"    
    
end_time = time.time()

execution_time_seconds = end_time - start_time

execution_time_nanoseconds = execution_time_seconds * 1000000000

print("Execution time: ", execution_time_seconds, "seconds or ", execution_time_nanoseconds, "nanoseconds")

So can we more easily to compare the speed of native mojo code to the speed of python code

[brenoyano]

Thank you! That really helped!

I couldn't turn that into a decorator so, at least if someone wants to "wrap" a function in the time being:

  from Time import now
  
  fn multiply_by_thousand(n: Int) -> Int:
     return  n*1000
  
  def timeit(func: object) -> object:
      
      start_time = now()        
  
      result = func
  
      end_time = now()
      let execution_time_nanoseconds : F64 = end_time - start_time
      let execution_time_seconds :  F64 = execution_time_nanoseconds / 1000000000
      print("Execution time: ", execution_time_seconds, "seconds or ", execution_time_nanoseconds, "nanoseconds")
  
      return result
  
  print(timeit(multiply_by_thousand(2)))

[sa-]

I wrote an Instant struct, you can copy it from here until it is merged into the std lib
#156

[DayDun]

Note there is already a Benchmark module in the standard library.

[DayDun]

from Benchmark import Benchmark

fn main():
    var x = 0
    @parameter
    fn multiplication_table():
        for i in range(300000):
            x += i
            x ^= i

    print(Benchmark().run[multiplication_table]())
    print(x)

main()

prints the number of milliseconds it takes to run the function. Be careful when benchmarking though because the compiler will optimize away a lot of code if it doesn't have any side effects.

[survuvi]

Thank you, and I can to use it for the python code too?

[DayDun]

No. You can use the timeit module in python: https://docs.python.org/3/library/timeit.html

[abduld]

The way to use benchmark is via

    @parameter
    fn time_me():
        sleep(0.002)
        return
    print(Benchmark().run[time_me]())

[strangemonad]

@DayDun for what it's worth, I found the built in Benchmark quite tedious to use for what it gives you

• must be usable in a static context
• doesn't return distributions / histogram of runs
• number of runs, warmup runs, runs until stability is hard to control.

[neatkent]

Am I wrong to think that a fair test would use the same function to test the time of both? Or am I silly to think that there would be a function that could work the same in both?