[SOLUCIONADO] (C++11) Duda sobre los threads

[amchacon]

Llevo un buen rato viendo la referencia pero no consigo ver lo que quiero:
http://en.cppreference.com/w/cpp/thread

Quiero resolver un sudoku por fuerza bruta, asi que tengo un array que simboliza el tablero:

short Tablero[MAX][MAX];

El algoritmo lo tengo pero quería hacerlo multihilo la idea es hacer 9 tableros y pasarlo a 9 hilos (cada uno con una casilla prerellenada con distinto valor). Después esperar y cuando un hilo acabe coger el valor y pasarlo por pantalla (y por supuesto, suspender el resto de hilos).

Creo que me va a estallar la cabeza. ¿Que objeto tengo que usar? Creo que un future no me vale porque retorna el valor (y Tablero lo paso por referencia), promise también hace lo mismo creo.

[L3m0n]

Yo lo implementaria sin los hilos y ver que rendimiento tiene, ya que aunque no se que algoritmo es no creo que sea algo que necesite de 9 hilos, sería bastante extraño.

[razpeitia]

Yo no te recomendaría hacerlo por threads aun.

¿Por que?

Bueno, porque sudoku tiene, varias reglas. Una de ellas, es que cada tablero de 3x3 no debe de tener números repetidos todos del 1 al 9. Pero esta también aplica para cada una de las filas y las columnas de todo el tablero 9x9.

Una vez que hagas la solución sin threads vas a poder comprender que partes las puedes hacer en paralelo y que partes no.

[amchacon]

El algoritmo ya lo tengo

Tengo el algoritmo, aunque lo pruebo en sudokus 2x2 (más que nada para que no me tarde):

Código C++:

bool Resolver(short Tablero[MAX][MAX])
{
    vector<pair<int,int> > Casillas;
    for (short j = 0; j < MAX;j++)
        for (short i = 0; i < MAX;i++)
            if (Tablero[i][j] == 0)
                Casillas.push_back(make_pair(i,j));
 
    register short Inicio = Casillas.size()-1;
 
    short Actual;
    short i;
 
    for (i = 0; i < Casillas.size();i++)
    {
            Tablero[Casillas[i].first][Casillas[i].second] = 1;
    }
 
 
    while(true)
    {
        for (i = 1; i < MAX;i++)
        {
 
            Tablero[Casillas[Inicio].first][Casillas[Inicio].second] = i;
 
            if (Resuelto(Tablero))
                return true;
        }
 
        Tablero[Casillas[Inicio].first][Casillas[Inicio].second] = 1;
 
        if (Inicio == 0)
                Inicio++;
        else
        {
            Actual = Inicio-1;
 
            Tablero[Casillas[Actual].first][Casillas[Actual].second] ++;
 
            while (Tablero[Casillas[Actual].first][Casillas[Actual].second] > (MAX))
            {
               Tablero[Casillas[Actual].first][Casillas[Actual].second] = 1;
 
                Actual--;
                
                if (Actual == -1)
                {
                    return false;
                }
                Tablero[Casillas[Actual].first][Casillas[Actual].second]++;
 
            }
 
        }
 
    }
 
}
 

Ahora quiero hacerlo mutihilo, tengo la idea como hacerlo (una casilla prerellenada que tiene su valor entre 9 hilos). Lo que me falta es la parte de implementación.

¿Como saber cuando un hilo ha finalizado? ¿Como paro el resto de hilos sin tener que esperar a que acabe?

[amchacon]

Hecho, había que jugar con los future:

Código C++:

future<void> t1[MAX];
 
    for (short i = 0; i < MAX; i++)
    {
        tablero[i][Inicio.first][Inicio.second] = i+1;
        t1[i] = (async(launch::async,Resolver,tablero[i],ref(preparado),ref(Casillas)));
    }
 
    short Contador;
    future_status estado;
 
    while (true)
    {
 
        for (short i = 0; i < MAX; i++)
        {
            estado =t1[i].wait_for(chrono::milliseconds(1));
 
            if (estado == future_status::ready)
            {
                Contador = i;
                cout<<"Ganador: "<<Contador<<endl<<endl<<endl;
 
                goto fin;
            }
        }
 
    }
fin: