c# - test - Tiempo transcurrido entre dos funciones

test dome c#

Question

Necesito encontrar el tiempo transcurrido entre dos funciones que realizan la misma operación pero escritas en algoritmos diferentes. Necesito encontrar el más rápido entre los dos

Aquí está mi fragmento de código

Stopwatch sw = new Stopwatch();
sw.Start();
Console.WriteLine(sample.palindrome()); // algorithm 1
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);//tried sw.elapsed and sw.elapsedticks
sw.Reset(); //tried with and without reset
sw.Start();
Console.WriteLine(sample.isPalindrome()); //algorithm 2
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);

Técnicamente esto debería dar el tiempo necesario para dos algoritmos. Esto da que el algoritmo 2 es más rápido. Pero da un tiempo diferente si intercambio la llamada de dos funciones. Como si llamo algoritmo primero y algoritmo1 segundo dice que algoritmo1 es más rápido.

No sé lo que estoy haciendo mal.

Answer 1

A menos que proporcione el código de palindrome y la función Palindrome junto con la clase de muestra, no puedo hacer mucho excepto especular.

La razón más probable que supongo para esto es que ambas funciones usan las mismas variables de clase y otros datos. Por lo tanto, cuando llama a la función por primera vez, tiene que asignar memoria a las variables, mientras que la próxima vez que llama a alguna otra función, esos gastos únicos ya se han producido. Si no son variables, podría tratarse de otra cosa, pero en la misma línea.

Sugiero que llame a ambas funciones dos veces, y tenga en cuenta la duración solo la segunda vez que se llama a una función, de modo que los recursos que necesitan utilizar puedan haber sido asignados una vez, y hay menos probabilidad de que algo entre bambalinas entre en juego con el resultado.

Hazme saber si esto funciona. Esto es mera especulación de mi parte, y puedo estar equivocado.

Answer 2

Lo que debes hacer es ejecutar ambos métodos antes de las pruebas calculadas para que el código compilado sea JIT''d . Luego prueba con múltiples intentos. Aquí hay una maqueta de código.

El código compilado en formato CIL se JIT en la primera ejecución, se traducirá en código máquina. Entonces, probarlo al principio es preciso. Así que deje que el código esté JIT antes de realmente probarlo.

sample.palindrome();
sample.isPalindrome();
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < 1000; i++)
{
    sample.palindrome();
    Console.WriteLine("palindrome test #{0} result: {1}", i, sw.ElapsedMilliseconds);
}
sw.Stop();
Console.WriteLine("palindrome test Final result: {0}", sw.ElapsedMilliseconds);
sw.Restart();
for (int i = 0; i < 1000; i++)
{
    sample.isPalindrome();
    Console.WriteLine("isPalindrome test #{0} result: {1}", i, sw.ElapsedMilliseconds);
}
sw.Stop();
Console.WriteLine("isPalindrome test Final result: {0}", sw.ElapsedMilliseconds);

Leer más sobre CIL y JIT

Answer 3

Supongo que tus métodos de palíndromo se ejecutan extremadamente rápido en este ejemplo y, por lo tanto, para obtener un resultado real necesitarás ejecutarlos un par de veces y luego decidir cuál es más rápido.
Algo como esto:

int numberOfIterations = 1000; // you decide on a reasonable threshold.
sample.palindrome(); // Call this the first time and avoid measuring the JIT compile time
Stopwatch sw = new Stopwatch();
sw.Start();
for(int i = 0 ; i < numberOfIterations ; i++)
{
   sample.palindrome(); // why console write?
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds); // or sw.ElapsedMilliseconds/numberOfIterations 

Ahora haz lo mismo con el segundo método y obtendrás resultados más realistas .