1 Diego Darío Guerrero Almudena Bocinos Riobóo Almudena Bocinos Riobóo. Diego Darío Guerrero Fernández

1Diego Darío Guerrero Almudena Bocinos Riobóo

Almudena Bocinos Riobóo.

Diego Darío Guerrero Fernández.


• INTRODUCCIÓN.

• FUNDAMENTOS.

• TIPOS DE CONSULTAS.

• TIPOS DE BÚSQUEDAS.

• CONCURRENCIA.

• BASES DE DATOS.

• PRIMITIVAS.

• EJEMPLOS en PARLOGW…

INDICE


Parlog es un lenguaje de programación lógica pensado para la resolución de problemas en máquinas con varios procesadores de forma concurrente. Su sintaxis es similar a PROLOG.

Fue el resultado de las investigaciones realizadas en el Imperial College of Science and Technology de Londres por Steve Gregory en los años 1986 y 1987.

INTRODUCCIÓN


ParlogW dispone de compilación perezosa e incremental:Perezosa porque un método se compila justo

antes de ser llamado. Incremental porque se compilan sólo los

métodos que se hayan modificado.En ParlogW puede forzarse la compilación

impaciente (eager) con “compile.”

INTRODUCCIÓN


Los programas Parlog se almacenan en ficheros, es recomendable dividir los programas en varios ficheros para aprovechar las características de compilación de Parlog.

Para facilitar el manejo de programas con muchos ficheros, en parlogW se incorporan comandos para guardar y cargar “grupos de programas”.

INTRODUCCIÓN


Cada relación o predicado que tengamos debe tener una declaración “modo”, que determinará qué uso de una variable se va a hacer.

mode cláusula( [nombre_var] modo ).cláusulas(argumentos).

FUNDAMENTOS

El nombre de variable es opcional.

El modo: ? Representa Entrada^ Representa Salida


Preferible esta forma:

mode cláusula( [nombre_var] modo ).cláusula(argumentos).

Ejemplo de Declaración

Ejemplos

Sin nombre de variable:

mode español(?).

español(pepe).

español(juan).

Con nombre de variable:

mode español(persona?).

español(pepe).

español(juan).


Las consultas en parlogW se realizan de forma similar a prolog, especificando unos objetivos a alcanzar, parlog dará SI o NO dependiendo de si es alcanzado o no.

Ej.:

<- amigos(pepe,X). Pretende obtener en X los amigos de pepe, pero parlog sólo dirá SI o NO. Para obtener resultados de variables, podemos usar las primitivas siguientes:

CONSULTAS


Vista normal: Con X,Y: obj1. mostramos los resultados de las variables X e

Y tras ejecutar obj1.

Vista Incremental: Con X,Y :: obj1. los resultados se mostrarán a medida que se

van generando.

Vista película: Con X,Y::: obj1. Vemos los resultados cuando se van

generando, incluyendo variables sin ligar ( sin valores).

La lista de variables a visualizar puede sustituirse por all si queremos que se vean todas las variables.

MOSTRAR RESULTADOS


<-amigo(‘Pepe’,’Rosa’).

<-amigo(‘Pepe’,’Mari’).

<-amigo(‘Pepe’,X).

mode amigo(?,?).

amigo(‘Pepe’,’Juan’).

amigo(‘Pepe’,’Mari’).

amigo(‘Pepe’,’Luis’).

NO

ÉXITO

ESPERA INFINITA

BÚSQUEDA OR-PARALELA

Ejemplos de consultas:

Consultas Parlog:


<-amigo(‘Pepe’,’Rosa’).

<-amigo(‘Pepe’,’Mari’).

<-X:amigo(‘Pepe’,X).

mode amigo(?, ↑).




fallo

éxito

Éxito, X=Juan

Si definimos la segunda variable como salida:

Ejemplos de Consultas

¿Por qué no devuelve también Mari y Luis?

Porque es un Lenguaje

Incompleto


amigo(‘Pepe’,

[’Juan’,’Mari’,’Luis’]).

amigo(‘Rosa',

[‘Lara’,’Pili’,’Toni’]).

<-Y:amigo(‘Pepe’,Y).

Y=[‘Juan’,’Mari’,’Luis’]succeeded

SOLUCIÓN A INCOMPLETITUD

mode amigo(?,^).




Esta es una posible solución para obtener todos los amigos de Pepe.


ESTRATEGIA TEST-COMMIT-OUTPUT La resolución se realiza en tres fases: Test: Se comprueba cada cláusula que

puede emparejar con argumento de entrada.

Commit: Elegirá sólo una cláusula de las anteriores.

OutPut: Se unificarán las variables de salida con el término encontrado en la cláusula elegida.

MOTIVO DE LA INCOMPLETITUD


OR-PARALELA:

- mode amigo(?,?).

amigo(‘Pepe’,’Juan’).amigo(‘Pepe’,’Mari’).amigo(‘Pepe’,’Luis’).

TIPOS DE BÚSQUEDAS

SECUENCIAL:

- mode amigo(?,?).

amigo(‘Pepe’,’Juan’);amigo(‘Pepe’,’Mari’);amigo(‘Pepe’,’Luis’).

En este caso se obliga a parlog a realizar una búsqueda secuencial.


TIPOS DE CONSULTAS

mode enteros(desdeN?,hastaN?,resultado^) .

mode cuadrados(listaNumeros?,resultado^).

X,Y : enteros(1,1000,X) , cuadrados(X,Y).

X,Y : enteros(1,1000,X) & cuadrados(X,Y).

Proceso enteros

Proceso cuadrados

X

1

1.000

Y

AND-PARALELA

SECUENCIAL

Variable Compartida


Podemos comparar el comportamiento de la consulta and-paralela con la evaluación perezosa de Haskell.

El mecanismo de consulta secuencial podría asemejarse a la evaluación impaciente.

El esquema de procesos usados por Parlog recuerda a las redes de proceso que utiliza Haskell.

COMPARATIVA CON HASKELL


Haskell utiliza reducción de expresiones, mientras que Parlog utiliza resolución y unificación.

Haskell está fuertemente tipificado, se definen los tipos de los parámetros, en Parlog no.

Parlog permite usar los parámetros de entrada y salida en cualquier posición del predicado. En Haskell el tipo de parámetro de entrada y salida está determinado por su posición en la lista de parámetros. En haskell: funcion :: int int. El de salida es el ultimo entero. En parlog: funcion(int1^,int2?). Podemos poner primero el de

salida y luego el de entrada.

COMPARATIVA CON HASKELL


EN HASKELL: primos=map head lprimos where lprimos = [2..] : map

criba lprimos Criba(p:xs) = [x | x xs, p ‘noDivideA’ x] where m

‘noDivideA’ n = mod n m =/= 0.

PRIMOS (Haskell)

map head map criba:

[2..]

primos


EN Parlog:mode primos(primos^).

primos(Primos) <-

enteros_desde(2,ListaEnteros),

cribar(ListaEnteros,Primos).

PRIMOS (Parlog)

Proceso Enteros_desde

Proceso cribar

2Primos

ListaEnteros


mode dueño(matrícula↑,dnipersona?).dueño(’BBT4567’,’48029184T’).dueño(‘CAB2005’,’21259337E’).dueño(‘CEY9200’,’55621832M’).

mode multa(matrícula?,importe↑).multa(’BBT4567’,’180€’).multa(‘CAB2005’,’500€’).multa(‘CEY9200’,’300€’).

Ejemplo de Variable Compartida

<-Y:dueño(matricula,’48029184T’),

multa(matricula, Y). Y=180€

succeeded

Variable Compartida


Con los operadores , y & podemos expresar cualquier situación de concurrencia.

<- obj1 , obj2. indica que las dos se ejecuten concurrentemente.

<- obj1 & obj2. indica 1º obj1 y 2º obj2.<- (obj1 , obj2) & (obj3 , obj4). Indica que obj1 y

obj2 sean concurrentes entres sí, pero que deben finalizar antes de comenzar la ejecución concurrente de obj3 y obj4.

EXPRESAR CONCURRENCIA


BASES DE DATOS. Solución a Incompletitud

database pred/Aridad.

pred(uno1, dos1,… A).

pred(uno2, dos2,… A).

…

Otra solución más elaborada consiste en utilizar las capacidades de Bases de Datos que proporciona Parlog.

Sobre esta definición, (que puede almacenarse en ficheros), podemos realizar consultas con set/3 y subset/3.


BASES DE DATOS

database amig/2.

amig(pepe,miguel).

amig(javier,jesus).

amig(pepe,antonio).

amig(paco,maria).

set/3 , subset/3: set(resultado^, term?, pred?).

La diferencia entre set y subset es que este último se ejecuta de forma perezosa ( sólo devuelve los valores que se le piden) mientras que set busca todas las soluciones antes de terminar.

<- R: set(R,X,amig(pepe,X)). resultado:

R=[miguel,antonio].


Aritméticas: =:=/2, =\=/2, </2,>/2, =</2, >=/2.

Unificación: =/2 , unifica variables. ==/2, comprueba si unifican. <=/2, unifica enlazando variables a la izq.

Ej.: f(X) <= f(Y), éxito, con X=Y, pero no con Y=X.

Evaluación: is/2 , evalúa expresiones. <- X is 3*4.

PRIMITIVAS DE PARLOG

Parlog proporciona un gran surtido de primitivas, entre las que podemos encontrar:


PRIMITIVAS

Chequeo de tipos (en ejecución):atom/1, integer/1, float/1, number/1,

atomic/1. Escritura: ya vimos :, ::, ::: y ::::

write/1, writeq/1: escriben un dato en la pantalla.

display/1: muestra datos con la representación interna que tenga.

nl/0: nueva línea.tab/1: tab(N?): escribe N espacios.


read/1,char/1: lee un dato de la entrada del usuario. la primitiva read está implementada a muy

alto nivel, con el inconveniente de que su ejecución bloquea todos los procesos parlog que se estén ejecutando.

Key/1 : se bloquea el proceso que lo llama hasta que se pulsa una tecla o el ratón. No bloquea todos los procesos porque esta

implementada a muy bajo nivel.

PRIMITIVAS DE LECTURA


Una mezcla de las dos nos proporciona un “read” que es capaz de no bloquear todos los procesos:

PRIMITIVAS DE LECTURA

mode achars(caracteres^).

achars([Char|Chars]) <-key(Char) &achars(Chars).

mode schars(caracteres^).

schars([Char|Chars]) <-getkey(Char) &schars(Chars).

Síncrona (bloquea) Asíncrona (no bloquea)


Ahora veremos algunos ejemplos completos en el entorno ParlogW:

Representación y búsqueda en árboles.

Ordenación QuickSort de listas.

EJEMPLOS EN PARLOGW


Programming in PARLOG. TOM CONLON – 1984 Razonando con Haskell para la comparativa con

Parlog. HANDS ON PARLOG FOR WINDOWS 1.0 - 1995 PARLOG: paralelismo en programación lógica de

Pilar Bruis Gómez PARLOGW: intérprete de parlog. 1995

Si quieres más sobre P.L. Concurrentes: Animación Automática de Especificaciones OASIS utilizando

Programación Lógica Concurrente. Tésis de Patricio Orlando Letelier Torres. U. Valencia.

BIBLIOGRAFIA y MATERIAL

Documents

1 Diego Darío Guerrero Almudena Bocinos Riobóo Almudena Bocinos Riobóo. Diego Darío Guerrero Fernández