MODELO PASO DE MENSAJES

proPar Curso 14/15
1 Computadores Paralelos
2 Programación basada en paso de mensajes
3 Técnicas básicas de programación paralela
Compulsiva, Divide y Vencerás, Pipeline,
Síncrona, Equilibrado de carga y Terminación
4 Programación basada en memoria común
5 Algoritmos y aplicaciones
Ordenación, …
4
4
2, 3, 2
2, 2
5
4

Procesamiento Paralelo Temario pasoMsj-2
2 PROGRAMACIÓN BASADA EN PASO DE MENSAJES
1 Recordar concurrencia pthreads: contar y ordenar
2 Un modelo de paso de mensajes
• Opciones de programación
• Creación de procesos
• Rutinas genéricas de paso de mensajes
3 MPI
• Introducción
• Procesos
• Envío y recepción de mensajes
• Comunicación colectiva
4 Evaluación de programas paralelos
5 Herramientas de depuración y monitorización

proPar Recordar concurrencia pthreads pasoMsj-3
• contarPar.c: Número de apariciones de un número en un vector
6 2 0 7 4 9 3 4 9 8 0 6 7 9 6 0 6 7 9 8 6 2 5 2 6 4 7 9 3 5 2 1 7 3 2 6 6 4 4 0
const
N = 40;
objetivo = 6;
numCPUs = 4;
var
vector array[1..N] of integer;
¿ Algoritmo paralelo ?
T1 T2 T3 T4
1 3 2 2
+
8

int longRodaja, numVecesLocal[MAX_ESCLAVOS], *vector;
void *esclavo (void *parametro) { ..... }
int main (int argc, char *argv[]) {
int i, numVeces, cardinalidad = atoi (argv[1]);
int numEsclavos = atoi (argv[2]);
pthread_t pids[MAX_ESCLAVOS];
// Pedir memoria e inicializar vector
// Crear esclavos y esperar a que terminen su trabajo
for (i = 0; i < numEsclavos; i++)
pthread_create (&pids[i], NULL, esclavo, (void *) i);
pthread_join (pids[i], NULL);
// Sumar los valores de todos e informar del resultado
numVeces = numVecesLocal[0];
numVeces = numVeces + numVecesLocal[i];
printf (“Veces que aparece = %dn”, numVeces);
}
%cuentaPar 1000000 4

// Variables globales
int longRodaja, numVecesLocal[MAX_ESCLAVOS], *vector;
void *esclavo (void *parametro) {
int yo, inicio, fin, i, j, numVeces;
yo = (int) parametro;
inicio = yo * longRodaja;
fin = inicio + longRodaja;
// Buscar en mi parte del vector
numVeces = 0;
for (i = inicio, i < fin; i++)
if (vector[i] == NUM_BUSCADO) numVeces++;
numVecesLocal[yo] = numVeces;
pthread_exit (NULL);
}

5 1,286 4,26 0,85
6 1,127 4,86 0,81
7 1,113 4,92 0,70
8 0,998 5,49 0,69
Esclavos Tiempo Aceleración Eficiencia
1 5,480
2 2,721 2,01 1,01
4 1,408 3,89 0,97
cuentaPar 400.000.000 1..8 // Recorriéndolo diez veces
2 Xeon E5520 Quad
2,26GHz • 8ML3 • 12GB • 500GB

• sortPar.c: Ordenar un vector en memoria
3 8 15 2 4 1 7 10 6 14 13 5 11 9 12 16
T1 T2 T3 T4
2 3 8 15 1 4 7 10 5 6 13 14 9 11 12 16
ordenar
1 2 3 4 7 8 10 15 5 6 9 11 12 13 14 16
T1 T3mezclar
T1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
mezclar

• sortPar.c: Ordenar un vector en memoria [Refinamiento]
A B C D
E F
G
1 2 3 4
1 3
1
esclavo (yo: integer);
ordenarRodaja(yo);
case yo of
1: mezclar(A,B,E); mezclar(E,F,G);
2: ;
3: mezclar(C,D,F);
4: ;
end;
?
1. La mezcla es destructiva => vector auxiliar
Va
Va
Vb
Va
2 Mezclar requiere haber ordenado … => semáforos

#define MAX_ENTERO 10000
#define MAX_ESCLAVOS 4 // Solo funciona con 4 esclavos
//-------------- VARIABLES GLOBALES -------------------------------
int cardinalidad, longRodaja;
int *vector, *vectorBis;
sem_t S2a1, S4a3, S3a1;
void imprimir (int *vector) {
int i;
printf ("Contenido del vectorn");
printf ("====================n");
for (i=0; i<cardinalidad; i++) {
printf ("%6d ", vector[i]);
if ((i%10) == 0) printf ("n");
}
printf ("n");
}
void mezclar (int i, int longRodaja, int *vOrg, int *vDst) {
int iDst, iTope, j, jTope;
iTope = i + longRodaja;
j = iTope;
jTope = j + longRodaja;
for (iDst = i; iDst < jTope; iDst++) {
if (i == iTope ) vDst[iDst] = vOrg[j++];
else if (j == jTope ) vDst[iDst] = vOrg[i++];
else if (vOrg[i] < vOrg[j]) vDst[iDst] = vOrg[i++];
else vDst[iDst] = vOrg[j++];
}
}

void *esclavo(void *parametro) {
int yo, inicio, fin, i, j, imenor, menor;
int unCuarto, unMedio;
yo = (int) parametro;
inicio = yo * longRodaja;
fin = inicio + longRodaja;
unMedio = cardinalidad / 2;
unCuarto = cardinalidad / 4;
// Ordenar por insercion directa
for (i = inicio; i < fin; i++) {
imenor = i; menor = vector[i];
for (j = i; j < fin; j++)
if (vector[j] < menor) {
imenor = j; menor = vector[j];
}
vector[imenor] = vector[i];
vector[i] = menor;
}
// Fase de mezclas. Solo valida para 4 esclavos
switch (yo) {
case 0: sem_wait (&S2a1); mezclar(0, unCuarto, vector, vectorBis);
sem_wait (&S3a1); mezclar(0, unMedio, vectorBis, vector);
break;
case 1: sem_post (&S2a1); break;
case 2: sem_wait (&S4a3); mezclar(unMedio, unCuarto, vector, vectorBis);
sem_post (&S3a1); break;
case 3: sem_post (&S4a3); break;
default: printf ("Errorn"); break;
}
pthread_exit(NULL);
}

int main( int argc, char *argv[] ) {
int i, numEsclavos;
pthread_t pids[MAX_ESCLAVOS];
cardinalidad = atoi(argv[1]);
numEsclavos = MAX_ESCLAVOS;
longRodaja = cardinalidad / numEsclavos;
// Pedir memoria e inicializar el vector
vector = malloc(cardinalidad * sizeof(int));
vectorBis = malloc(cardinalidad * sizeof(int));
for (i=0; i<cardinalidad; i++)
vector[i] = random() % MAX_ENTERO;
imprimir(vector);
// Inicializar semaforos para sincronizar
sem_init (&S2a1, 0, 0);
sem_init (&S4a3, 0, 0);
sem_init (&S3a1, 0, 0);
// Crear esclavos y esperar a que terminen su trabajo
for (i=0; i<numEsclavos; i++)
pthread_create (&pids[i], NULL, esclavo, (void *) i);
for (i=0; i<numEsclavos; i++)
pthread_join (pids[i], NULL);
imprimir(vector);
return (0);
}
sort 200000 => 8:350
sortPar 200000 => 2:100

proPar Opciones de programación pasoMsj-12
Entornos de programación paralela en los 90 “Tim Mattson - Intel”

1 A Pattern Language for Parallel Programming
2 Background and Jargon of Parallel Computing
3 The Finding Concurrency Design Space
4 The Algorithm Structure Design Space
5 The Supporting Structures Design Space
6 The Implementation Mechanisms Design Space
7 A Brief Introduction to OpenMP
8 A Brief Introduction to MPI
9 A Brief Introduction to Concurrent Programming in
Java
2005

1. Diseño específico de un lenguaje: Occam  Transputer
2. Extensión de lenguaje existente: Fortran M, CC++, Cilk++
www.netlib.org/fortran-m
www-unix.mcs.anl.gov/dbpp/text/node51.html
www.cilk.com
3. Biblioteca de paso de mensajes sobre C, Fortran, C++
PVM: www.csm.ornl.gov/pvm
MPI: www-unix.mcs.anl.gov/mpi
HPC++: www.extreme.indiana.edu/hpc++/index.html
Paralelización automática: El compilador extrae
paralelismo del código secuencial
¿ Sistema
Operativo ?
OpenMP

1979 Proyecto Europeo: Inmos SGS-Thomson ICL ... †
Objetivo: µP de altas prestaciones, como elemento básico para
construir máquinas paralelas (multicomputadores)
1992: habían vendido 500.000 unidades (µP+1MB => 180.000pts)
Característica relevante: 4 enlaces de comunicación (canales)
T8000
1
2
3
Ejecución eficiente de n procesos que
envían/reciben mensajes por canales
P1
P2
P3
proPar Opciones … (TRANSPUTER) pasoMsj-15
cP3 !
dato
cP2 ? dato

proPar Creación de procesos pasoMsj-16
• ¿Cómo podría ser contarPar.c si no hay memoria común?
1 3 2 2
6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …
+
8
esclavo1 esclavo2 esclavo3 esclavo4
maestro
6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …
• El vector lo tiene un proceso “maestro”
• El maestro: reparte “envía” trabajo a los “esclavos” y
recoge “recibe” resultados
6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …
1
3 2 2
2 tipos distintos
de procesos

• ¿Cómo podría ejecutarse la aplicación?
maestro
esclavo1 esclavo2 esclavoN
Un proceso x núcleo
M E E E
• Dos ejecutables: maestro.exe y esclavo.exe
maestro.c esclavo.c
maestro.exe esclavo.exe
Multiple Program
Multiple Data
MPMD
maestro.exe esclavo.exe
• Creación de procesos: estática vs dinámica
¿Arquitecturas distintas?

proPar Creación de procesos (creación dinámica) pasoMsj-18
• MPMD: Multiple Program Multiple Data
---------------------------
spawn (“esclavo”, 4, ...)
---------------------------
maestro.c
---------------------------
contarEnTrozo (......)
---------------------------
esclavo.c
maestro esclavo
%pvm
pvm>add PC2 .....
pvm>spawn maestro
M E E

proPar Creación de procesos (creación estática) pasoMsj-19
• SPMD: Single Program Multiple Data
programa
fuente
*.exe *.exe *.exe
M E
%mpirun –np 9 sort
%mpirun –p4pg
fiConf sort
---------------------------
if (miIdProceso == 0)
maestro()
else
esclavo()
---------------------------
sort.c
0 1 8

• A veces, viene bien que el maestro también trabaje
esclavo1 esclavo2 esclavo3
maestro0
6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …
0 6 7 … 6 2 5 … 2 1 7 …
1
3 2 2
• Modelo SPMD y creación de procesos estática

proPar Rutinas genéricas de paso de mensajes pasoMsj-21
• Pi.enviar(Pj, &msj, ...)  Pj.recibir(Pi, &msj, ...)
---------------------------
enviar (esclavo,
&rodaja[k], ...)
---------------------------
sortM
---------------------------
recibir (maestro,
&miRodaja, ...)
---------------------------
sortE
• Máquina
• PID_Local
Varias semánticas:
• Bloqueante (Síncrona | Rendezvous)
• No bloqueante (Asíncrona: Capacidad de almacenar)
• Temporizada (Tiempo máximo de bloqueo)
enviar( Pi, &msj, temporización, )
∞
0
t

• Bloqueante vs NoBloqueante
----------
----------
enviar...
----------
----------
----------
----------
recibir...
----------
----------
El primero se bloquea
Transferencia sin
buffers adicionales
Se sabe que se ha recibido
----------
----------
enviar...
----------
----------
----------
----------
recibir...
----------
----------
Buffer
Se desacopla env | rec
Gestión de buffers
¿ Dónde ?
¿Se ha recibido? => msjACK
enviar( Pi, &msj, temporización, ...)

• recibirDeCualquiera (&msj) | recibir ( -1, &msj)
sortE1 sortEn
sortM
---------------------------
quien = recibir (-1,
&rodaja[k], ...)
---------------------------
sortM
• Mensajes etiquetados
PPPPPPPH
enviar (S, &msj, tipoP)
enviar (S, &msj, tipoH)
recibir (-1, &msj, tipoH)
recibir (-1, &msj, -1 )
Cliente Servidor
Cliente
Cliente

proPar Paso de mensajes entre “grupos” pasoMsj-24
• Broadcast (a todos) Multicast (a unos concretos)
---------------------------
Para todo esclavo
enviar (esclavo,
&palabra, ...)
---------------------------
cuentaM
Problema: Número de ocurrencias de (un dato)* en array grande
cuentaM
cuentaE1 cuentaEncuentaE2
“Ala”
“Ala”
“Ala”
---------------------------
bcast (esclavos,
&palabra, ...)
---------------------------
cuentaM¿Más eficiente?

sortM
sortE1 sortEn
V
sortM
sortE1 sortEn
V
• scatter ( esparcir ) y gather ( recoger ) Ej: Ordenación
scatter (V, rodaja, grupo, emisor, )
sortM y sortE
gather (V, rodaja, grupo, receptor, )
sortM y sortE

cuentaM
cuentaE1
2
3
cuentaE2
5
cuentaEn
1
• reduce (recibir de unos concretos y operar) Ej: Ocurrencias
Total = veces;
Para todo esclavo
recibir (esclavo,
&veces, ...)
Total += veces;
cuentaM
reduce (+, &veces, grupo, receptor, ...)
cuentaM y cuentaE
+
máximo, mínimo, *, .....

proPar MPI (Introducción) pasoMsj-27
MPI: Message Passing Interface – 1994 MPI Forum [Nov/92]
“Ejecución de aplicaciones paralelas
distribuidas en ordenadores heterogéneos”
maestro
esclavo1 esclavo3esclavo2 esclavo4
Cada uno con su dirIP
• Biblioteca “mpi.h”
MPI_Send,
MPI_Recv,
-------------
M E1 E2 E3 E4
• Implementación
MPICH
LAM/MPI
IBM, …
MPI-2
MPI-3

>= 0 => MPI_SUCCESS, significado concreto
< 0 => un error ( ... MPI_ERR_ARG ...)
proPar MPI (Procesos) pasoMsj-28
int MPI_Comm_size(…, int *numProcesos);
int MPI_Comm_rank(…, int *yo);
int MPI_Finalize();
int MPI_Init( ....... ); /* Inicia MPI */
• Creación estática de procesos (según implementación “mpirun”)
0
1
3
2
4
MPI_COMM_WORLD
2
5
2

proPar MPI (Procesos) pasoMsj-29
• helloWorld paralelo
#include “mpi.h”
int main (int argc,
char *argv[]) {
int yo, numProcesos;
MPI_Init (&argc, &argv);
MPI_Comm_size (MPI_COMM_WORLD, &numProcesos);
MPI_Comm_rank (MPI_COMM_WORLD, &yo);
if (yo == 0) printf (“Creados %d procesosn”, numProcesos);
printf (“Hola, soy el proceso %dn”, yo);
MPI_Finalize();
}
% mpirun –np 3 helloWorld
% mpirun –p4pg helloWorld.txt helloWorld
pc1 2 /usuarios/alumnosPropar/propar01/p1/helloWorld
pc2 2 /usuarios/alumnosPropar/propar01/p1/helloWorld
pc3 1 /usuarios/alumnosPropar/propar01/p1/holaMundo

proPar MPI (Envío y Recepción Simple) pasoMsj-30
• Enviar y recibir arrays de datos simples (int, byte, ...) Bloqueante
int vector[N];
----------
MPI_Send (vector, …
P2, ...)
----------
P1
int tabla[M];
----------
MPI_Recv (tabla, …
P1, ...)
----------
P2
int MPI_Send(void *buffer, int cuantos, MPI_Datatype tipo,
int destino, int etiqueta, MPI_Comm grupo)
MPI_INT,
MPI_FLOAT, …
MPI_COMM_WORLD
0..MPI_TAG_UB

• Enviar y recibir arrays de datos simples (int, byte, ...) Bloqueante
int MPI_Recv(void *buffer, int cuantos, MPI_Datatype tipo,
int remitente,int etiqueta,MPI_Comm grupo,
MPI_Status *estado)
estado.MPI_SOURCE
estado.MPI_TAG
MPI_ANY_SOURCE
MPI_ANY_TAG
int MPI_Get_count( MPI_Status *estado, MPI_Datatype tipo,
int *cuantos)

• Ejemplo de uso: psendrec.c
#include <stdio.h>
#include <unistd.h>
#include “mpi.h"
#define N 3
#define VECES 5
void esclavo(void) {...}
void maestro(void) {...}
int yo;
if (yo == 0) maestro();
else esclavo();
MPI_Finalize();
return 0;
}

void maestro (void) {
int i, j, vector[N];
for (i=0; i<VECES; i++) {
printf ("M: envia => ");
for (j=0; j<N; j++) {
vector[j] = i*N+j;
printf("%d ", vector[j]);
}
printf ("n");
MPI_Send (vector, N, MPI_INT, 1, 1, MPI_COMM_WORLD);
}
}
esclavo

void esclavo(void) {
int i, j,tabla[N], n;
MPI_Status estado;
sleep(2);
for (i=0; i<VECES; i++) {
MPI_Recv (tabla, N, MPI_INT, 0, 1,
MPI_COMM_WORLD, &estado);
MPI_Get_count (&estado, MPI_INT, &n);
printf ("E: recibe => ");
for (j=0; j<N; j++) printf("%d ", tabla[j]);
printf (" de tid = %d eti = %d longi = %dn",
estado.MPI_SOURCE, estado.MPI_TAG, n);
}
}
maestro

proPar MPI (Envío y Recepción No Tan Simple) pasoMsj-35
int MPI_Iprobe(int origen, int etiqueta, MPI_Comm grupo,
int *hayMsj, MPI_Status *estado)
• Enviar y recibir arrays de datos simples No Bloqueante
• Enviar y recibir datos no homogéneos
Crear tipos => Algo tedioso
Hacer otras cosas
NO
int MPI_Recv(void *buffer,… MPI_Status *estado)
SI

proPar MPI (Comunicación colectiva) pasoMsj-36
int MPI_Bcast(void *buffer, int cuantos,
MPI_Datatype tipo, int emisor,
MPI_Comm grupo)
cuenta.0
cuenta.1 cuenta.Ncuenta.2
“Ala”
“Ala”
“Ala”
void maestro () { void esclavo () {
char palabra[4]; char texto[4];
---------- ----------
MPI_Bcast ( MPI_Bcast (
palabra, 4, MPI_CHAR, texto, 4, MPI_CHAR,
0, MPI_COMM_WORLD); 0, MPI_COMM_WORLD);
---------- ----------
?
tag
Send+Recv

int MPI_Scatter(
void *vOrg, int nOrg, MPI_Datatype tOrg,
void *vDst, int nDst, MPI_Datatype tDst,
int emisor, MPI_Comm grupo);
grupoE.1 grupoE.9
grupoM.0
int MPI_Reduce(void *vOrg, void *vDst, int nOrg,
MPI_Datatype tDatoOrg, int operacion,
int receptor, MPI_Comm grupo);
+
MPI_SUM, MPI_PROD,
MPI_MIN, MPI_MAX, ....
sendCount

proPar MPI (Comunicación colectiva: Ejemplo) pasoMsj-38
• Ejemplo de uso completo: cuentaPar2.c (modelo SPMD)
#include <stdio.h>
#include “mpi.h"
#define CARDINALIDAD 2000000
#define MAX_ENTERO 1000
#define NUM_BUSCADO 5
int i, numVeces, numVecesTotal, yo;
int longRodaja, numProcesos;
int *vector;
---------------------------
MPI_Finalize();
}

proPar MPI (Comunicación colectiva: Ejemplo) pasoMsj-39
• Ejemplo de uso completo: cuentaPar2.c
// Pedir memoria vector e inicializarlo si maestro
longRodaja = CARDINALIDAD / numProcesos;
if (yo == 0) {
vector = malloc (CARDINALIDAD * 4);
for (i=0; i<CARDINALIDAD; i++)
vector[i] = random() % MAX_ENTERO;
} else
vector = malloc (longRodaja * 4);
MPI_Scatter (vector, longRodaja, MPI_INT,
vector, longRodaja, MPI_INT, 0, MPI_COMM_WORLD);
// Todos buscan en su trozo
numVeces = 0;
for (i=0; i<longRodaja; i++)
if (vector[i] == NUM_BUSCADO) numVeces++;
MPI_Reduce (&numVeces, &numVecesTotal, 1, MPI_INT,
MPI_SUM, 0 , MPI_COMM_WORLD);
if (yo == 0)
printf (“Numero de veces => %dn”, numVecesTotal);

• Otras llamadas interesantes:
int MPI_Gather(void *vOrg, int nOrg, MPI_Datatype tOrg,
void *vDst, int nDst, MPI_Datatype tDst,
int receptor, MPI_Comm grupo);
int MPI_Barrier(MPI_Comm grupo);
----------
----------
// Computar todos paso 1
MPI_Barrier (MPI_COMM_WORLD);
// Computar todos paso 2
6

proPar Evaluación de programas paralelos pasoMsj-41
• ¿Cuánto tardará mi programa paralelo TP
?
• Medición experimental
• Estudio analítico
Codificar, Depurar, Probar, ...
Modelo imperfecto, aproximado
m
e0 e9
cuentaVeces:
• V[1.000.000]
• 10 esclavos
TP
= TCPU + TRED
a. Enviar rodajas TRED
c. Recibir veces TRED
b. Contar veces TCPU
veces = 0;
for (i=0; i<N’; i++)
if (rodaja[i] == D)
veces++;
N’
N
N’ * (#i * Tinst) O (N) | O (N2
) | O (NlogN) | O(logN)

#m * (TL + #d * TD)
#d
t
TL
TP
= TCPU + TRED
N’ * (#i * Tinst)
Ejemplos
T3D+PVM
IBM PS2+MPI
iacluster+MPI 40µs
35µs
3µs
TL
64ns
230ns
63ns
TD[8B]
0,6ns
4,2ns
11ns
Tinst
66666
8333
273
TL
107
55
6
TD
1
1
1
Tinst
Normalizar
TP
= TCPU + TRED
Solapar tiempos | ocultar latencias
Comunicación asíncrona
#msj,
tamaño(#d),
topología red,
tecnología, ...

• Ejemplo: cuentaVeces, V[1.000.000], 10 esclavos
T1
= 1.000.000 * (#i * Tinst)
T10
= TRED(10Rodajas) + TCPU(100.000) + TRED(10Resultados)
T3D: TL(273) y TD(6)
T10
= 10*(273+100.000*6) + 100.000*#i*1 + 10*(273+6)
= 6.005.520 + 100.000#i
S10
= 1.000.000*#i / (6.005.520+100.000#i)
iacluster: TL(66.666) y TD(64)
T10
= ... 66.666 ... 64 + ...*1 + ... 66.666+64
= 65.333.960 + 100.000#i
S10
= 1.000.000*#i / (65.333.960 +100.000#i)
#i S10
50 0,71
100 1,33
500 4,34
#i S10
5 0,8
10 1,4
500 8,9

proPar Herramientas de depuración y monitorización pasoMsj-44
• Medición de tiempos de ejecución
• Depuración
• Monitorización
#include <sys/time.h>
struct timeval t0, tf, tiempo;
/* Inicialización */
gettimeofday (&t0, NULL);
/* ejecucion del programa paralelo */
gettimeofday (&tf, NULL);
timersub (&tf, &t0, &tiempo);
printf (“Tiempo => %ld:%ld seg:micron”,
tiempo.tv_sec, tiempo.tv_usec);
Evitar E/S
¿Efecto del
optimizador
de código?
gcc –O3

%mpirun –dbg=ddd –np 2 psendrec
Depurar más
de un proceso,
algo más
complejo
printf
fflush(stdout)
setbuf(stdout,
NULL)
depurar (ddd)

• Monitorización (XPVM) para PVM

• Monitorización (totalview) para MPI, openMP, …
www.etnus.com
www.roguewave.com

• Monitorización VAMPIR www.vampir.eu
FIN

MODELO PASO DE MENSAJES

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (15)

Similaire à MODELO PASO DE MENSAJES

Similaire à MODELO PASO DE MENSAJES (20)

Dernier

Dernier (20)

MODELO PASO DE MENSAJES