[SOLUCIONADO] Uso 100% CPU para un programa hecho en c++

[dmorill]

Hola amigos, les traigo un problema muy interesante.

Me dí cuenta que el algoritmo que estoy desarrollando tardaba mucho, así que tuve la idea de probar que tan eficiente era c++, para ello construí un programa aparte, muy simple que lo muestro a continuación:

Código C++:

#include <ctime>    //reloj
#include <iostream>
#include <math.h>
 
using namespace std;
 
void mostrarTiempo(clock_t tiempo);
 
int main(){
    clock_t tiempo = clock();    //iniciar el reloj
    long long i = 0;
    double sum = 0;
    for (i = 1; i < 10000000000; i++){
        sum = sum + log(double(i));
    }
 
    mostrarTiempo(tiempo);
 
    cout << "Pulse para salir...";
    cin.sync();
    cin.get();
    return 0;
}
 
 
void mostrarTiempo(clock_t tiempo){
    tiempo = clock() - tiempo;
    cout << endl << "Tiempo de ejecución es " << double(tiempo) / CLOCKS_PER_SEC << " seg." << endl;
}
 

Como pueden ver sólo es un for muy largo, para mi sorpresa que el tiempo era de 340 segundos (que en otros equipos es de 140 por ejemplo) y mirando mi administrador de tareas, en la pestaña rendimiento, sólo se le da un 17% de uso de cpu en promedio a mi proceso (el programa compilado en c++), el uso total mientras lo hacia era de 45% en promedio, con windows y otras cosas.

Mi pregunta es como hacer para que windows le dedique todo lo que pueda al programa .exe que generé. Es decir que corriendo mi programa este casi al 100% del uso del cpu.

Muchas gracias.

[Malenko]

Que use más CPU no quiere decir que tenga mayor rendimiento. Un algoritmo o programa tiene mayor rendimiento cuando hace una tarea en menos tiempo y con menos recursos.

[Profesor_Falken]

Buenas,

Eso es porque tu programa se ejecuta en un solo nucleo de tu procesador.

Si quieres utilizar varios nucleos, tienes que desarrollar pensando en ello. Deberas cambiar tu algoritmo para que divida la tarea y la ejecute en diversos threads, ya sea directamente o con ayuda de alguna libreria como openmp.

Te dejo un link muy interesante para lograr paralelismo:
http://gribblelab.org/CBootcamp/A2_Parallel_Programming_in_C.html


Un saludo

[Malenko]

El paralelismo no siempre se puede usar. Aquí estás siempre dependiendo del valor anterior para calcular el siguiente. Es decir, estarias trabajando con varios threads usando una variable compartida y a la que han de acceder de forma exclusiva. Si, va a subir el consumo de CPU pero porque son operaciones que son costosas, no porque aumente el rendimiento.

[Pantaláimon]

Iniciado por Malenko

El paralelismo no siempre se puede usar. Aquí estás siempre dependiendo del valor anterior para calcular el siguiente. Es decir, estarias trabajando con varios threads usando una variable compartida y a la que han de acceder de forma exclusiva. Si, va a subir el consumo de CPU pero porque son operaciones que son costosas, no porque aumente el rendimiento.

No tengo mucha experiencia en programación concurrente pero que el programa, tal como este construido, dependa del valor anterior, no quiere decir que se pueda contruir otro que haga lo mismo de otra manera. Pues al final, el programa parece que lo que hace es calcular un sumatorio de los logaritmos de 1 a 9999999999. Cada hilo podría encargarse de calcular partes del sumatorio, independientemente uno del otro y al terminar, sumarlo en una variable, accediendo de forma exclusiva.

Un saludo!

[Profesor_Falken]

Buenas,

La verdad es que he considerado que el algoritmo publicado es una prueba y no el real.

De cualquier forma, tal y como apunta Pantalaimon, la operacion se puede fraccionar, calcular concurrentemente y sumar los resultados al final. No existe aqui ningun problema, aunque estoy de acuerdo en que el paralelismo en muchos casos causa mas problemas que los que resuelve si no tenemos cuidado.

En cualquier caso lo unico que queria indicar es que el bajo uso de CPU se debe a la arquitectura multinucleo de los procesadores modernos y que solo se puede mejorar el rendimiento usando paralelismo. Eso no quita que si una operacion es muy costosa en calculo, entonces puede llevar mucho tiempo, no hay milagros. Un buen algoritmo no es aquel que dura poco, sino aquel que escala bien, en proporcion constante, lineal o logaritmica.


Un saludo

[dmorill]

Hola, muchas gracias por sus respuestas. En resumen se supone que el bajo consumo es debido a que se usa un sólo núcleo de los que tiene, por cierto tengo un i7, la verdad supuse eso y estuve monitorizando el uso de los núcleos con el programa everest, y realmente ningún núcleo estaba a tope. Como interpretar eso?, lo más obvio es que no es cuestión de que uso sólo un núcleo pero no estoy seguro.

Con el motivo de tener más información de esto me gustaría que ustedes prueben el código que les dí para comparar los resultados. El formato de reportar podría ser este:

CPU: intel core i7-2670QM @ 2.20 GHz
ram: 16gb
windows 8.1 64x
Tiempo del algoritmo: 286.656seg

Gracias.

[Profesor_Falken]

Pues la verdad es que no se como lo has medido...

En mi caso, en Ubuntu 14.04, ejecutando el programa en un i5 con 4 CPU: la CPU1, CPU3 y CPU4 están al 3-4%, mientras que la CPU2 está a 100% todo el rato.


Un saludo

[dmorill]

Iniciado por Profesor_Falken

Pues la verdad es que no se como lo has medido...

En mi caso, en Ubuntu 14.04, ejecutando el programa en un i5 con 4 CPU: la CPU1, CPU3 y CPU4 están al 3-4%, mientras que la CPU2 está a 100% todo el rato.


Un saludo

Gracias, usaste el código de c++ que dí?, cuanto tiempo de ejecución obtuvo?.

[dmorill]

Hola, gracias por todas respuestas. Luego de indagar y buscar la respuesta si era la ya expuesta en este foro, la cantidad de nucleos que trabajan simultáneamente, es decir los threads o hilos de procesamiento. Programando con 8 threads el cpu va a 100%.

A quién le interese voy a adjuntar el código del for inicial, pero para que se realice con threads, el número de threads se define en la variable: "nucleos". Además uso una barrera para que haya problemas mientras los threads trabajan simultáneamente.

Código C++:

#include <ctime>    //reloj
#include <iostream>
#include <math.h>
#include <thread>
#include <vector>
#include <mutex>
using namespace std;
static mutex barrier;
 
void mostrarTiempo(clock_t tiempo);
vector<long long> bounds(long long parts, long long mem);
void contar(double& sum, long long i, long long j);
 
int main(){
    clock_t tiempo = clock();    //iniciar el reloj
    int nucleos = 8, i = 0;
    long long numerote = 0;
    //numerote = 1000000;
    numerote = 10000000000;
    double sum = 0, sum1 = 0;
    vector<thread> vNucleos;
    vector<long long> limits = bounds(nucleos, numerote);
    if (limits[0] == 0) limits[0] = 1;
    for (i = 0; i < nucleos; i++){
        vNucleos.push_back(thread(contar, ref(sum), limits[i], limits[i + 1]));
    }
    for (auto &t : vNucleos){
        t.join();
    }
    
    cout << endl << " " << sum << endl;
    mostrarTiempo(tiempo);
    
    for (i = 1; i < numerote; i++){
        sum1 = sum1 + log(double(i));
    }
    cout << endl << " " << sum1 << endl;
    
 
    cout << "Pulse para salir...";
    cin.sync();
    cin.get();
    return 0;
}
 
 
void mostrarTiempo(clock_t tiempo){
    tiempo = clock() - tiempo;
    cout << endl << "Tiempo de ejecución es " << double(tiempo) / CLOCKS_PER_SEC << " seg." << endl;
}
void contar(double& sum, long long i, long long j){
    long long k; double sumar = 0;
    for (k = i; k < j; k++){
        sumar = sumar + log(double(k));
    }
    lock_guard<mutex> block_trheads_until_Finish_this_job(barrier);
    sum = sum + sumar;
}
vector<long long> bounds(long long parts, long long mem){
    vector<long long>bnd;
    long long delta = mem / parts;
    long long reminder = mem % parts;
    long long N1 = 0, N2 = 0;
    bnd.push_back(N1);
    for (long long i = 0; i < parts; ++i) {
        N2 = N1 + delta;
        if (i == parts - 1)
            N2 += reminder;
        bnd.push_back(N2);
        N1 = N2;
    }
    return bnd;
}