Usa la capilla para manejar la matriz masiva.

Recientemente me he encontrado con Chapel y tengo muchas ganas de probarlo. Tengo un problema doble que espero pueda resolver.

Normalmente trabajo en Python o C ++. Java cuando está en una esquina.

Tengo dos matrices I y V Ambos son dispersos y tienen unas dimensiones de aproximadamente 600K x 600K, con una densidad aproximada del 1%.

Primero, usando SciPy, puedo cargar ambos desde una base de datos SQL en la memoria en este momento. Sin embargo, espero que nuestra próxima iteración sea simplemente demasiado grande para nuestras máquinas. Tal vez 1.5M ^ 2. En un caso como ese, los RDD de Spark pueden funcionar para la carga. No pude conseguir PyTables para hacer que esto suceda. Entiendo que esto se describe como un problema “fuera de núcleo”.

Incluso si se cargan, hacer I'IV va OOM en minutos. (Aquí I' es transposición), así que estoy buscando la distribución de esta multiplicación entre múltiples núcleos (lo que SciPy puede hacer) y múltiples máquinas (que no puede, por lo que sé). Aquí, Spark se cae, pero Chapel parece responder a mis oraciones, por así decirlo.

Una seria limitación es el presupuesto en máquinas. No puedo pagar un Cray, por ejemplo. ¿La comunidad de la capilla tiene un patrón para esto?

Comenzando con algunos puntos de alto nivel:

  • En su esencia, el lenguaje de la Capilla tiene más que ver con matrices (estructuras de datos) que con matrices (objetos matemáticos), aunque obviamente se puede usar una matriz para representar una matriz. Piense que la distinción es el conjunto de operaciones admitidas (por ejemplo, iteración, acceso y operaciones elementales para matrices frente a transposición, productos cruzados y factorización para matrices).
  • La capilla soporta matrices dispersas y asociativas, así como densas.
  • Los arreglos de capillas se pueden almacenar de forma local en una sola memoria o se pueden distribuir en múltiples memorias / nodos de cómputo.
  • En Chapel, debe esperar que las matrices / operaciones de álgebra lineal sean compatibles a través de bibliotecas en lugar del lenguaje. Mientras que Chapel tiene un comienzo en dichas bibliotecas, aún se están expandiendo, específicamente, Chapel no tiene soporte de biblioteca para operaciones de álgebra lineal distribuida a partir de la Capilla 1.15, lo que significa que los usuarios tendrían que escribir dichas operaciones manualmente.

Con más detalle:

El siguiente progtwig crea una matriz densa distribuida en bloque:

 use BlockDist; config const n = 10; const D = {1..n, 1..n} dmapped Block({1..n, 1..n}); // distributed dense index set var A: [D] real; // distributed dense array // assign the array elements in parallel based on the owning locale's (compute node's) ID forall a in A do a = here.id; // print out the array writeln(A); 

Por ejemplo, cuando se ejecuta en 6 nodos ( ./myProgram -nl 6 ), la salida es:

 0.0 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 1.0 0.0 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 1.0 0.0 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 1.0 0.0 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0 2.0 3.0 3.0 3.0 3.0 3.0 2.0 2.0 2.0 2.0 2.0 3.0 3.0 3.0 3.0 3.0 2.0 2.0 2.0 2.0 2.0 3.0 3.0 3.0 3.0 3.0 4.0 4.0 4.0 4.0 4.0 5.0 5.0 5.0 5.0 5.0 4.0 4.0 4.0 4.0 4.0 5.0 5.0 5.0 5.0 5.0 4.0 4.0 4.0 4.0 4.0 5.0 5.0 5.0 5.0 5.0 

Tenga en cuenta que ejecutar un progtwig de Chapel en varios nodos requiere configurarlo para usar múltiples configuraciones regionales . Dichos progtwigs pueden ejecutarse en clústeres o estaciones de trabajo en red, además de Crays.

Aquí hay un progtwig que declara una matriz dispersa distribuida:

 use BlockDist; config const n = 10; const D = {1..n, 1..n} dmapped Block({1..n, 1..n}); // distributed dense index set var SD: sparse subdomain(D); // distributed sparse subset var A: [SD] real; // distributed sparse array // populate the sparse index set SD += (1,1); SD += (n/2, n/4); SD += (3*n/4, 3*n/4); SD += (n, n); // assign the sparse array elements in parallel forall a in A do a = here.id + 1; // print a dense view of the array for i in 1..n { for j in 1..n do write(A[i,j], " "); writeln(); } 

Ejecutando en seis locales da:

 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 3.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 4.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 6.0 

En los dos ejemplos anteriores, los bucles forall se calcularán en los arrays / índices distribuidos utilizando múltiples nodos en una forma de cómputo del propietario, y utilizando los múltiples núcleos por nodo para hacer el trabajo local.

Ahora para algunas advertencias:

  • El soporte de matriz dispersa distribuida aún está en su infancia a partir de la Capilla 1.15.0, ya que la mayor parte del enfoque del proyecto en la memoria distribuida hasta la fecha se ha centrado en el paralelismo de tareas y las matrices densas distribuidas. Una charla de Berkeley en el taller anual de la Capilla de este año, “Hacia una biblioteca de GraphBLAS en la Capilla”, destacó varios problemas de rendimiento y escalabilidad, algunos de los cuales se han solucionado en la twig maestra, otros de los cuales aún requieren atención. La retroalimentación y el interés de los usuarios en tales características es la mejor manera de acelerar las mejoras en estas áreas.

  • Como se mencionó al principio, las bibliotecas de álgebra lineal son un trabajo en progreso para Chapel. Las versiones anteriores han añadido módulos de capilla para BLAS y LAPACK . La capilla 1.15 incluyó el inicio de una biblioteca LinearAlgebra de nivel superior . Pero ninguno de estos apoyos distribuye arrays en la actualidad (BLAS y LAPACK por diseño, LinearAlgebra porque todavía son los primeros días).

  • Chapel no tiene una interfaz SQL (todavía), aunque algunos miembros de la comunidad han hecho rumores acerca de agregar dicho soporte. También puede ser posible usar las funciones de E / S de Chapel para leer los datos en algún formato textual o binario. O, podría potencialmente usar las funciones de interoperabilidad de Chapel para interactuar con una biblioteca de C que podría leer el SQL.