Paralelismo con Unity3D en C#
 
Hola buenas,
 
Aquí os traigo un ejemplo de aplicación de multihilos a Unity3D. En este caso, el ejemplo consiste en dada una matriz rellenada con numeros random de 1 a 1000, hacer la suma total de cada fila. Es decir dada la matriz 3x3:
 

1 2 3 -> 6
4 5 6 -> 15
1 2 4 -> 7

 
Este es un ejemplo en el cual podremos  utilizar multithreading (a partir de ahora multihilos) y ahorrar costo com***cional. En el unitypackage que os adjunto se rellenan dos matrices de 10000 x 10000. Así que al darle al Play puede ser que vuestro ordenador se os tire varios segundos sin arrancar la escena debido a que el relleno de las matrices es por un único hilo y con un Random.Range(), algo que es costoso para un ordenador, pero que al ser un ejemplo no nos importa (nos centraremos en el calculo paralelo, os animo a completar el código para el relleno de las matrices por paralelismo  ).
 
En la escena nos aparecerán dos botones. Al darle click a "Hilo" os hará el calculo de la primera matriz con un único hilo. Al darle click a "Multihilo" os lo hará con multihilos. Super intuitivo el ejemplo así que no os podéis quejar.
 
Os comento un poco el codigo del multihilo para que lo entendáis:
 

using System.Collections;
using System.Collections.Generic;
using System.Threading;
using UnityEngine;
using HelperCustom;
public class multiHilo {
private int[,] v;
private int tamX, tamY;
public multiHilo(int tamX, int tamY) {
   this.tamX = tamX;
   this.tamY = tamY;
   v = new int[this.tamX, this.tamY];
   HelperCustom.HelperMatriz.RellenarMatriz2d(ref v, ref tamX, ref tamY);
}
public void sumarVectoresMultiplesHilos() {
   for(int x = ; x < tamX; x++) {
           //1
      System.Threading.ParameterizedThreadStart sum = new System.Threading.ParameterizedThreadStart (sumaElementosY);
      //2   
          System.Threading.Thread sobreUnaLinea = new System.Threading.Thread(sum);
      //3   
          sobreUnaLinea.Start(x);
   }
}
private void sumaElementosY(object y) {
   int j = (int)y;
   int resultado = ;
   for(int p = ; p < tamY; p++) {
      resultado += v [j, p];
   }
   Debug.Log ("Calculado en multihilo");
}
}

 
Iremos por partes:
 
El constructor de la clase es súper sencillo, simplemente le pasa por parámetro las filas y columnas de la matriz, crea una matriz con esas filas y columnas y luego las rellena con un helper hecho por mi (también añadido al unitypackage).
 
Vamos al lío: sumarVectoresMultiplesHilos() es la clase que nos interesa. Como veréis recorremos la columna de la matriz, y por cada columna declaramos qué método queremos ejecutar en diferentes hilos, en este caso, sumaElmentosY (el número 1). Ahora en el 2 crearemos el hilo pasándole las propiedades declaradas en el 1, y finalmente empezaremos la ejecución del hilo, pasándole por parámetro la posición en la que estamos (fila 1, 2, 3...). Muy importante, nos debemos fijar que en lo que pasámos por parametro en realidad es un object, es decir que en sumaElementosY() el parámetro es object. Y luego tenemos que hacerle una conversión a int, en este caso se trata de un downcasting (cosas raras de los ingenieros informáticos).
 
Ahora ya podremos calcular el resultado de la fila como haríamos con un vector, puesto que la posición x la sabíamos anteriormente y la hemos pasado por parámetro.
 
Notas:
 
En el estudio del tiempo que necesitamos he puesto un Debug.Log en cada una de las filas calculadas para que se note más la diferencia de tiempos (Ya que hablamos de una matriz 10kx10k, relativamente pequeña para la tecnología hardware actual).
 
Esto está muy bien pero... ¿Para qué necesito yo saber esto?
 
Las aplicaciones son casi infinitas, y lo mejor, súper óptimas. Se pueden utilizar en suma de vectores donde sabes que el tamaño siempre va a ser enorme, TerrainData que se trabaja con matrices super espesas (que es mi caso), Texturas, Colores, etc.
 
Pues lo pienso hacer todo paralelo a partir de ahora @mgarcia
 
Para el carro, he dicho casi infinitas. Hay operaciones las cuales da igual como las hagas siempre van a ser del mismo costo temporal. Todos aquellos algoritmos donde las variables que se tienen que modificar se compartan y necesites saber  el resultado de la operación x para hacer la de la x+1 no se puede hacer paralelo (la explicación técnica es más compleja pero para que os hagáis una idea de lo que digo).
 
Resultados temporales:
 
Ahora os dejo con el resultado temporal que me ha salido a mi, como veréis, la diferencia de tiempos es enorme:
 

 
Unos 9 segundos y medio de media en un único hilo mientras que en multihilo me ha dado menos de 3. Si aumentásemos el tamaño de la matriz imagináos...
 
Y hasta aquí la pequeña introducción al paralelismo con Unity3D.
 
Un saludo, y ¡hasta otra!
 
//www.unityspain.com/applications/core/interface/file/attachment.php?id=10402" data-fileid="10402" rel="">tutoMultihilo.unitypackage

Gran aporte @mgarcia, Tambien recordar que depende mucho del procesador los hilos que podemos usar, y que unity usa el multithread para cosas como fisicas y la llamada a fixedUpdate (si mal no recuerdo) siempre y cuando este disponible.
 
Gracias!

Cita de: kingtrase date=1491140627Gran aporte @mgarcia, Tambien recordar que depende mucho del procesador los hilos que podemos usar, y que unity usa el multithread para cosas como fisicas y la llamada a fixedUpdate (si mal no recuerdo) siempre y cuando este disponible.
   
   
      Gracias!
   

Gracias @kingtrase! Eso es como en todo. Si petamos a hilos el procesador llegará un momento que la cola de procesos dejará que entren durante muy poco tiempo los procesos más urgentes (los de sistema) y hará que pete tu sistema operativo. Pero vamos, que con la tecnología actual ya tienes que dejar hilos ya xD