Leonardo Rey Emiliano Riccialdelli Federico Mobrici Lenguaje Linda Leonardo Rey Emiliano Riccialdelli Federico Mobrici

Introducción Fue desarrollado en 1983 en la Tesis Doctoral de D. Gelernter (Univ. New York) Es un lenguaje de programación paralela basado en C (C-Linda) y Fortran (Fortran-Linda) Crea programas paralelos Está basado en un modelo de memoria virtual compartida, llamado Tuple Space (TS) Este provee seis funciones para la coordinación de procesos concurrentes

Introducción La única forma de comunicación es a través del espacio de tuplas compartidas Solo se necesita aprender las primitivas Linda para agregar concurrencia al lenguaje con el que se está programando

Definiciones Básicas Tuple Space (TS): Es el nombre que le da Linda para su espacio de datos compartidos Tuplas: Es la estructura fundamental de datos del Tuple Space Representación de una tupla: ("tag", value1, ..., value-n) Ejemplos: ("arraydata", dim1, 13, 2) ("array sections", a[0], a[8])

Definiciones Básicas Existen dos tipos de tuplas: Las tuplas Activas: Contienen al menos un valor que todavía no a sido evaluado. Ejemplo: (“factorial”, 7, fac(7)) (“factorial”, 7, 5040) Las tuplas Pasivas: Todos los valores ya han sido evaluados. (“factorial”, 7, 5040);

Operaciones Básicas Tiene 4 operaciones básicas: Generación de tuplas out : Genera una tupla (tupla pasiva) de datos Ejemplo: out(“array data”, dim1, dim2) eval : Genera una tupla proceso (tupla activa) En C : eval("test", i, f(i)) En Fortran : eval('test', i, f(i))

Operaciones Básicas

Operaciones Básicas Extracción de Tuplas: Ejemplo: In : Usa un template para devolver tuplas desde el TS. Ejemplo: in("arraydata", ?dim1, ?dim2); rd: Usa un template para copiar información sin removerla del TS rd("arraydata", ?dim1, ?dim2);

Operaciones Básicas

Otras Operaciones Hay variantes no bloqueantes de in y rd Las operaciones inp y rdp son predicados que retornan true si hay una tupla matching en TS, y false en otro caso

Templates Especifica la tupla a recibir Consiste de una secuencia de campos tipados Existen dos tipos de campos: Actuales: Variables, constantes o expresiones que se resuelven a constantes Formales: Holders para recibir información Están precedidos por el signo “?”

Templates Ejemplos: in("arraydata", ?dim1, ?dim2, ?dim3); in("arraydata", 4, ?dim2, ?dim3); Ambos ejemplos machearan con la siguiente tupla: out("arraydata", 4, 6, 8);

Reglas de macheo del template Tienen que tener el mismo numero de campos Los campos actuales deben tener el mismo tipo, longitud y valores Los campos formales en el template deben machear el tipo y longitud de los campos correspondientes de la tupla Si varias tuplas machean el template es imposible predecir cual será la elegida El orden de evaluación de los campos entre una tupla o template esta indefinido.

Reglas de macheo del template Por lo tanto, los siguientes constructores deben ser evitados: out(“string”, i++, i); No se puede predecir si “i” sera incrementada antes o después de que el tercer campo sea evaluado in(“string2”, ?j, ?a[j]): No se puede predecir si “j” (en el tercer campo) tendra el valor seteado por “?j” (en el segundo campo) o el valor que tenia antes de que la operación se ejecute. out(“string”, x , f(x)): En este ejemplo de Fortran, la funcion f() modifica el valor x, no podemos predecir si el segundo campo tendra el valor original o el modificado de x.

Reglas de macheo del template Ejemplos: out('testdata', i, 3, 4+6) Sera macheada por: in('testdata', ?cnt, ?var, ?sum) in('testdata', ?cnt, ?var, 10) in(?string, ?cnt, ?var, ?sum)

Modelo Master/Slave usando memoria virtual compartida La creación de un programa Linda contiene un proceso Master y muchos procesos Slaves El Maestro y los Esclavos son independientes unos de otros El Maestro divide el trabajo en tareas discretas y las ponen en el espacio global Los esclavos reciben repetidamente tareas y ponen los resultados de vuelta en el espacio global

Modelo Master/Slave usando memoria virtual compartida

Ejemplo “Hola Mundo” real_main(argc,argv) int argc; char *argv[]; { int nworker, j, hello(); nworker=atoi (argv[1]); for (j=0; j < nworker; j++) eval ("worker", hello(j)); for(j=0; j < nworker; j++) in("done"); printf(“Hola Mundo is finished.\n"); } int hello (i) int i; { printf(“Hola Mundo from number %d.\n",i); out("done"); return(0); }

Implementación del Modelo Linda La implementacion se divide en cinco modulos: Librería Linda Manejador de Tuplas Remote Procedure Call Preprocesador Interfaz del Compilador

Implementaciones de Linda C-Linda, Fortran-Linda Piranha Algunas versiones en RedHat Linux PVM Linda C++-Linda

Network Linda Correr programas paralelos en redes es complicado por aspectos tales como el schedulling de procesos localización del ejecutable, heterogeneidad, etc. Ntsnet es una poderosa y flexible herramienta para ejecutar programas Linda en una red; diseñado para ayudar a manejar esta complejidad. Normalmente las redes Linda corren el proceso real_main() en el sistema local, y los procesos worker que ejecutan los eval corren sobre hosts remotos.

Piranha Linda Es una alternativa de C-Linda Opera sobre Workstations conectadas por red El numero de procesadores participantes en un programa Piranha puede variar Usa las operaciones in, out y rd pero NO la operación eval Define tres rutinas: Feeder Piranha Retreat

Piranha Linda Terminación de un Programa Piranha Un programa Piranha pude terminar de dos maneras: Cuando la rutina feeder retorna Cuando cualquier proceso ejecuta lhalt o flhalt En ambos casos todos los procesos Piranha que están ejecutándose terminaran automáticamente.

Arreglos en C-Linda Existen dos tipos de arreglos: Arreglos de longitud fija: Tienen una longitud predeterminada y no modificable conocida en tiempo de ejecución. Ejemplos: int a [20], b[20]; Luego: out ("fixed array", a); in ("fixed array", ?b);

Arreglos en C-Linda Arreglos de Longitud variable: Utiliza información adicional provista en tiempo de ejecución para especificar su longitud El atributo variable es aplicado a un arreglo colocando el carácter “:” luego de su nombre La información acerca de su longitud precede al carácter “:” Ejemplos: Para especificar los primeros 10 elementos de a (a es un arreglo) a:10 Para especificar el arreglo entero como un arreglo variante a:

Arreglos en C-Linda Cuando el arreglo se usa como campo formal, una variable entera se usara para setear el numero de elementos devueltos in(“array”, ?a:lenght);

Arreglos en C-Linda Ejemplos: int a[20], b[20], len; out("varying array", a:); out("varying array", a:20); Para crear una tupla que contenga los primeros 10 elementos out(“ten elements”, a:10); out(“ten elements”, b:10); La tupla “ten elements” debera ser devuelta en alguna de las siguientes operaciones in(“ten elements”, ?a:len); in(“ten elements”, ?b:len);

Templates Matching y Arrays Los arreglos machean con otros arreglos cuando sus elementos son del mismo tipo Los arreglos fijos solo machean con otros arreglos fijos si tienen la misma longitud Los arreglos fijos NUNCA machean con los arreglos variables

Limitaciones de Linda Sobrecarga alta del sistema. Diseñado primeramente como un modelo de computación paralela para redes LAN. Carencia de un modelo de seguridad. Carencia de semánticas transaccionales. Implementación especifica del lenguaje. Llamadas bloqueantes, pero sin mecanismos de notificación.

Ejemplo Nros Primos (Main) Real_main(INT argc, CHAR *argv[ ] ) { INT primes[ limit] = {2,3}; /*tabla de primos*/ INT limit, numworkers, i, isprime; INT numprimes=2, value=5; limit = atoi (argv[ 1]) ; /*se lee cuantos generar */ numworkers= atoi (argv[ 2] ); /* Crear los workers y poner el primer primo en TS */ FOR (i=1; i <= numworkers; i++ ) EVAL (“worker”, worker() ); OUT(“candidate”, value); /* Obtener los resultados de los workers en orden creciente */ WHILE (numprimes < limit) { IN (“result”, value, ?isprime); IF (isprime) { /*poner el valor en la tabla y en TS*/ primes[numprimes] = value; OUT (“prime”, numprimes, value); numprimes++; } value=value + 2; OUT (“stop”); /* avisa a los workers que terminen */ IMPRIMIR;

Ejemplo Nros Primos(Worker) Void worker ( ) { INT primes[ limit] = {2,3}; /*tabla de primos*/ INT numprimes=1, i, candidate, isprime; /* Obtener repetidamente un candidato a primo y chequearlo */ WHILE (true) { IF ( RDP (“stop”) ) RETURN; IN (“candidate”, ?candidate); /*obtiene un candidato */ OUT (“candidate”, candidate +2); /* pone el siguiente candidato */ i=0; isprime=1; WHILE (primes[i] * primes[i] <= candidate { IF (candidate % primes[i] == 0) { /*NO es primo */ isprime=0; break; } i++; IF (i > numprimes ) { /* necesito otro primo */ numprimes++; RD ( “prime” , numprimes, ?primes[numprimes]); OUT (“result”, candidate, isprime); /*se envia el resultado al manager */