es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Cómo medir la velocidad de ejecución de launch::async?

15 Jul, 2023 Programación

Estoy trabajando en mi tarea y tratando de medir la velocidad de ejecución en la política “async”. El tiempo que obtengo sin iterar el vector “raNums” es de aproximadamente 60 segundos, lo cual es bastante alto. Y con su iteración – 9 milisegundos, lo cual es considerablemente menos (entiendo que en este caso, los procesos se ejecutan sin detenerse). Sin embargo, no entiendo realmente cómo debo capturar el tiempo correcto de ejecución de forma asíncrona.

“`cpp
#include <iostream>
#include <future>
#include <random>

using namespace std;
using namespace std::chrono;

class RandomNum {
public:
enum class Task {
SMALL,
BIG
};
Task task;

<pre><code>RandomNum() {
pickNum();
}

int randNum() {
if (task == RandomNum::Task::SMALL) {
for (int i = 0; i < 100; i++) {
rand();
}
}
else if (task == RandomNum::Task::BIG) {
for (int i = 0; i < 10000000; i++) {
rand();
}
}
return 0;
}
</code></pre>

private:

<pre><code>void pickNum() {
int randNum = rand() % 100 + 1;
task = (randNum % 2 == 0) ? RandomNum::Task::SMALL : RandomNum::Task::BIG;
}
</code></pre>

};

int main()
{
srand((unsigned int)time(NULL));

<pre><code>vector<randomnum*> raNums;

for (auto i = 0; i < 100; i++) {
raNums.push_back(new RandomNum());
}

auto start = steady_clock::now();

vector<><int>> res;

for (auto& value : raNums) {
//if (value->task == RandomNum::Task::SMALL) {
// res.push_back(async(launch::deferred, &RandomNum::randNum, value));
//}
//else {
// res.push_back(async(launch::async, &RandomNum::randNum, value));
//}
res.push_back(async(launch::async, &RandomNum::randNum, value));
}

for (auto& i : res) {
i.get();
}

auto stop = steady_clock::now();

cout << "Tiempo = " << duration_cast<milliseconds>(stop – start).count() << "ms.\n";

return 0;
</code></pre>

}
“`</randomnum*>

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para medir la velocidad de ejecución de la política async, el código proporcionado utiliza el encabezado future de C++11, que permite llamadas de función asíncronas con futuros. Para medir la duración de la ejecución, se utiliza la biblioteca chrono de std.

    El código funciona iterando sobre un vector de objetos RandomNum y llamando al método randNum() para cada uno de ellos. Este método realiza un número aleatorio de iteraciones de un bucle, dependiendo de la tarea asociada al objeto. El miembro task puede ser Task::SMALL o Task::BIG, y se genera aleatoriamente para cada objeto RandomNum.

    Para medir la ejecución, el código mide el tiempo antes y después de las llamadas a las funciones utilizando steady_clock::now(). Luego calcula la duración de este intervalo utilizando duration_cast y lo muestra en la consola.

    Para usar la política async con RandomNum::randNum(), el código pasa un puntero a una función miembro a cada llamada async, junto con un puntero al objeto RandomNum correspondiente. También pasa la política de lanzamiento std::launch::async a cada llamada para que las funciones se ejecuten de forma asíncrona.

    Para capturar el tiempo de ejecución de la política async, el código aplica async a cada una de las llamadas a RandomNum::randNum() en el bucle, creando así un vector de futuros. Luego, el bucle for espera los resultados de los futuros llamando a i.get() en cada uno de ellos. Finalmente, el código calcula el tiempo que tardan en completarse estas tareas comparando los tiempos de inicio y parada obtenidos antes y después de las llamadas a las funciones.

    Por lo tanto, el tiempo de ejecución de la política async se mide mediante la medición de la ejecución de los futuros devueltos por las llamadas a la función async.

Comments are closed.