¿Cómo sincronizar una función en Ir y devolver su tiempo de ejecución en milisegundos?

Question

¿Cómo sincronizar una función en Ir y devolver su tiempo de ejecución en milisegundos?

Answer 1

Utilice el paquete Go testing para comparar la función. Por ejemplo,

package main 

import (
    "fmt" 
    "testing" 
) 

// the function to be benchmarked 
func Function(n int) int64 { 
    n64 := int64(n) 
    return n64 * n64 
} 

func BenchmarkFunction(b *testing.B) { 
    n := 42 
    for i := 0; i < b.N; i++ { 
     _ = Function(n) 
    } 
} 

func main() { 
    br := testing.Benchmark(BenchmarkFunction) 
    fmt.Println(br) 
} 

Salida:

500000000   4.22 ns/op 

También puede utilizar el comando Ir gotest para ejecutar los puntos de referencia.

Answer 2

Existen varias opciones para la marca de tiempo y los temporizadores en el paquete de tiempo. Consulte la documentación aquí: http://golang.org/pkg/time/

Answer 3

Go defer hace esto trivial.

En Ir 1.x, definir las siguientes funciones:

func trace(s string) (string, time.Time) { 
    log.Println("START:", s) 
    return s, time.Now() 
} 

func un(s string, startTime time.Time) { 
    endTime := time.Now() 
    log.Println(" END:", s, "ElapsedTime in seconds:", endTime.Sub(startTime)) 
} 

Después de eso, se obtiene absolutamente limpio de tiempo transcurrido una línea de mensajes de registro:

func someFunction() { 
    defer un(trace("SOME_ARBITRARY_STRING_SO_YOU_CAN_KEEP_TRACK")) 

    //do a bunch of stuff here... 
} 

La magia inteligente es que la traza() se llama al principio de la función, pero el un() se difiere hasta el final. No es un reloj atómico preciso, debido a las declaraciones de registro, pero si necesita más precisión, este tipo de patrón es uno de los buenos puntos fuertes de mal gusto de Go.

EDIT:

Esta respuesta utilizada originalmente API anterior paquete de tiempo. Reproducida aquí por valor histórico solamente:

Para uso w/Ir versiones anteriores a 12-01-2011 semanal:

func trace(s string) (string, int64) { 
    log.Println("START:", s) 
    return s, time.Nanoseconds() 
} 

func un(s string, startTime int64) { 
    endTime := time.Nanoseconds() 
    log.Println(" END:", s, "ElapsedTime in seconds:", float32(endTime-startTime)/1E9) 
} 

Answer 4

Tal vez también se puede utilizar una duración (transcurrido) para este ... se ve una un poco mejor.

func trace(s string) (string, time.Time) { 
    log.Printf("trace start: %s\n", s) 
    return s, time.Now() 
} 

func un(s string, startTime time.Time) { 
    elapsed := time.Since(startTime) 
    log.Printf("trace end: %s, elapsed %f secs\n", s, elapsed.Seconds()) 
} 

Answer 5

Otra manera fácil puede ser:

import (
    "fmt" 
    "time" 
) 

start := time.Now() 
// some computation 
elapsed := time.Since(start) 
fmt.Println(elapsed) 

que será algo salida como 359.684612ms