Download Lenguaje Java

Lenguaje Java
Especificación para
Tiempo Real
José Manuel Pérez Lobato
2001/2002
ARCOS- UC3M
1
Especificación Java TR
• El grupo que definió la Especificación para Tiempo
Real en Java (RTSJ) empezó a trabajar a mediados de
1998
• La versión actual es la primera y se publico en Junio de
2000
• Se puede encontrar en http://www.rtj.org/
• API: javax.realtime, extiende las clases estándar de java
para dar características de tiempo real
ARCOS- UC3M
2
Principios básicos de RTSJ
•
•
•
•
Aplicable a entornos java
Compatibilidad con versiones anteriores
Ejecución predecible
Definir lo básico ahora y permitir introducir
características avanzadas para cuando la práctica haya
permitido verificar su necesidad
• No hay extensiones sintácticas (ejem. la sintáxis de la
clausula synchronized permanece invariable aunque su
interpretación difiera)
• Permite variaciones en las decisiones de
implementación
• WORA
ARCOS- UC3M
3
Especificación Java TR
• Define la API (javax.realtime) que deben cumplir las
maquinas virtuales que utilicen Java TR e incluye los
siguientes aspectos:
–
–
–
–
–
–
–
Planificación de tareas (hilos, threads)
Gestión de memoria
Sincronización y utilización compartida de recursos
Utilización de eventos asíncronos
Transferencia asíncrona de control
Terminación asíncrona de tareas
Acceso a la memoria física
• Existen pocas JVM que lo implementen, se puede
encontrar una en:
– http://timesys.com/rtj/
ARCOS- UC3M
4
1.- Planificación
• JVM:
– 10 niveles de prioridad
– No hay garantías de cumplimiento de prioridades
• RTJ
– Al menos 28 niveles de prioridad
– Permite definir algoritmos de planificación
ARCOS- UC3M
5
Planificación
• Se pueden definir varios tipos de scheduler que tendrán como
nombre el tipo de política aplicable seguida de la palabra
Scheduler (ejem. EDFScheduler).
– La clase genérica de planificadores es class Scheduler
• El Scheduler básico es el PriorityScheduler
• Los Scheduler se encargan de:
– Verificar si las tareas que deben planificar son factibles de acuerdo con la
pOlítica utilizada
– Gestionar la ejecución de objetos planificables (interface Schedulable)
ARCOS- UC3M
6
Planificación
• Existen 3 tipos de objetos planificables :
– RealtimeThread: Menor prioridad que el garbage colector (GC)
– NoHeapRealtimeThread. Similar al anterior pero no coloca objetos en el
heap y por tanto puede ejecutar siempre antes que el recolector de basura.
– AsyncEventHandler: Gestor de eventos asíncronos.
• Deben existir al menos 28 niveles de prioridad en el scheduler
básico
• La algoritmo de planificación, por defecto, será preemtivo (con
desalojo) y con prioridades fijas.
• La política que se utiliza para comprobar si es factible una
determinada planificación de tareas será, por defecto, RMA
ARCOS- UC3M
7
RealtimeThread
• Hereda de java.lang.Thread por tanto su forma de utilizarla es similar
(crear una clase que herede de Realtimethread e incluir en ella un
método run() con las instrucciones que se deben ejecutar)
• Constructor:
– RealtimeThread ([SchedulingParameters scheduling,]
[ReleaseParameters release,]
[MemoryParameters memory, MemoryArea area,]
[ProcessingGroupParameters]);
ARCOS- UC3M
8
RealtimeThread
• SchedulingParameters son los parámetros para ser utilizados por el
Scheduler., su subclase más importante es PriorityParameters que sirve
para definir la prioridad que se le asigna al thread.
• ReleaseParameters son los parámetros relativos al comportamiento del
thread, dependiendo del tipo de thread que se use (periodico,
esporádico, etc.) se utiliza una u otra de sus subclases,
• ProcessingGroupParameters: definen un grupo de tareas aperiodicas
que no podrán consumir más de un determinado tiempo en cada
periodo de ejecución indicado
• Parámetros de Memoria (MemoryParameters y MemoryArea) definen
la utilización de la memoria que realizará el thread
ARCOS- UC3M
9
SchedulingParameters
• Constructor
SchedulingParameters();
• Clase utilizada: PriorityParameters
– public class PriorityParameters extends SchedulingParameters();
– Constructor: PriorityParameters(int prioridad): define el nivel de prioridad;
ARCOS- UC3M
10
• Constructor
ReleaseParameters
ReleaseParameters (
RelativeTime coste,
RelativeTime deadline,
AsyncEventHandler overrunHandler, AsyncEventHandler missHandler);
– coste : tiempo de cpu utilizado por el thread
– deadline : plazo de respuesta
– overrunHandler: Gestor del desbordamiento en el coste indicado
– missHandler: Gestor del desbordamiento en el deadline indicado
• Las subclases que permiten añadir otras características son
– PeriodicParameters : para tareas periódicas.
– AperiodicParameters : para tareas aperiódicas (pueden activarse en cualquier
momento)
– SporadicParameters : para tareas esporadicas (existe un tiempo mínimo entre 2
activaciones consecutivas)
ARCOS- UC3M
11
ReleaseParameters (subclases)
• Constructor de PeriodicParameters
PeriodicParameters (
HighResolutionTime start, RelativeTime periodo,
RelativeTime coste,
RelativeTime deadline,
AsyncEventHandler overrunHandler, AsyncEventHandler missHandler);
donde además de los parámetros de la clase ReleaseParameters tenemos el
relativo al tiempo de activación (start) y al periodo
• La clase AperiodicParameters incluye los mismos atributos que
ReleaseParameters
• La clase SporadicParameters añade como primer parámetro (a los de
ReleaseParameters) el RelativeTime intervaloMinimo que refleja el tiempo
mínimo entre 2 activaciones consecutivas.
ARCOS- UC3M
12
RealtimeThread
• Métodos básicos
– public void addToFeasibility() : añade el thread al scheduler por defecto para
que éste analice si es factible
– public void removeFromFeasibility(): elimina el thread al scheduler por
defecto para que éste no analice si es factible
– public static void sleep([Clock clock], HighResolutionTime time)
– public boolean waitForNextPeriod() Deja el thread suspendido hasta que le
toque el siguiente periodo de activación (sólo para threads periódicos)
• Para comenzar la ejecución del thread se debe invocar el método start()
que llamará al método run() redefinido.
ARCOS- UC3M
13
Class Scheduler
• Clase abstracta que gestiona la ejecución de objetos planificables e
implementa algoritmos de factibilidad
• Métodos básicos
– protected abstract void addToFeasibility (Schedulable schedulable) : añade el
objeto schedulable al planificador
– protected abstract void removeToFeasibility (Schedulable schedulable) :
elimina el objeto schedulable del planificador
– public abstract boolean isFeasible (): true si los objs. planificables con los que
cuenta (añadidos con addToFeasibilitiy()) permiten una planificación factible.
– Public abstract java.lang.String getPolicyName(): Devuelve el nombre de la
política de planificación utilizada
– public static void setDefaultScheduler (Scheduler scheduler) : define el
scheduler indicado como el utilizado por defecto
– public static Scheduler getDefaultScheduler (Scheduler scheduler) : devuelve
una referencia al scheduler por defecto, que si no se ha definido lo contrario
será un PriorityScheduler
ARCOS- UC3M
14
Class PriorityScheduler
• Scheduler preemtivo con prioridades fijas
• Métodos básicos:
– public void fireSchedulable (Schedulable schedulable) : Dispara la ejecución
del objeto schedulable
– public int getXXXPriority() Dependiendo de si XXX es Max, Min o Norm
devolverá la máxima, mínima o normal prioridad disponible para un thread
gestionado por este scheduler
– public static int getXXXPriority(java.lang.Thread thread) Si el thread indicado
es planificable por el scheduler y dependiendo de si XXX es Max, Min o
Norm devolverá la máxima, mínima o normal prioridad que puede tener un
thread gestionado por este scheduler, Si el thread no es planificable por este
scheduler se devuelve Thread.YYY_Priority (YYY= MAX, MIN o NORM)
– public static PriorityScheduler instance () : devuelve un puntero a una
instancia de un PriorityScheduler
ARCOS- UC3M
15
Ejemplo 1a
import java.lang.*;
import javax.realtime.*;
public class SensorTemp extends RealtimeThread{
int numero;
SensorTemp (int numero, SchedulingParameters scheduling, ReleaseParameters
release) {
super (scheduling, release);
this.numero=numero;
}
public void run ( ) {
// instrucciones de inicializacion (sólo ejecutan 1 vez)
while(condicion) {
acciones a repetir periodicamente
waitForNextPeriod();
}
// instrucciones de finalización (sólo ejecutan 1 vez)
}
ARCOS- UC3M
}
16
import javax.realtime.*;
import java.lang.reflect.*;
class Gestor{
public static void main (String []arg) throws InterruptedException {
PriorityParameters ppst1 = new PriorityParameters(20);
PriorityParameters ppst2 = new PriorityParameters(22);
PeriodicParameters perpst = new PeriodicParameters(
new RelativeTime(100+0*v,0),new RelativeTime(10*v,0),
new RelativeTime(1*v,100),new RelativeTime(10*v,0),
null,null);
SensorTemp st1= new SensorTemp(1, 30,40,v, ppst1,perpst, ds);
SensorTemp st2= new SensorTemp(2, 20,80,v, ppst2,perpst, ds);
PriorityScheduler ps =getDefaultScheduler();
Ejemplo 1b
System.out.println ("INICIO");
st1.addToFeasibility();
ps.fireSchedulable(st1);
st2.addToFeasibility();
ps.fireSchedulable(st2);
}
}
ARCOS- UC3M
17
2.- Gestión de Memoria
• Permite :
– Definir zonas de memoria
• Fuera del heap,
• Con una duración temporal asociada (lifetime)
• Asociadas a determinada posición física
– Limitar el tamaño máximo de memoria a utilizar por un thread
ARCOS- UC3M
18
MemoryArea
• Es una zona de memoria en la que se pueden almacenar objetos
• Cuando se crea se debe definir su tamaño..
• Tipos:
– HeapMemory: la del heap de Java
– InmortalMemory: para objetos que existan durante toda la vida de la
aplicación, está compartida por todos los threads y sus objetos nunca son
eliminados por el recolector de basura.
– InmortalPhysicalMemory : con las características de la InmortalMemory
pero asociada a una posición de memoria física determinada.
– ScopedMemory :Memoria con ámbito definido, útil para tratar objetos que
tienen su tiempo de vida definido por su ámbito de utilización. Éste está
definido entre la utilización del método enter(Runnnable r) y la
finalización del thread r
ARCOS- UC3M
19
• Métodos básicos:
MemoryArea
– protected MemoryArea (long tamanoEnBytes): constructor que define el
tamaño del área.
– public void enter (java.lang.Runnable logic) Asocia el área de memoria al
thread indicado durante la ejecución de su método run(), que es disparado
por este método. Durante esa ejecución del método run() los objetos que
se creen lo harán en esa zona de memoria
– public static MemoryArea getMemoryArea (java.lang.Object obj) :
devuelve el área de memoria en la que está el objeto.
– public long memoryConsumed(): Nº de bytes utilizados
– public long memoryRemaining(): Nº de bytes disponibles
– public synchronized java.lang.Object newArray (java.lang.Class type, int
num): crea un array de num elementos del tipo indicado
– public synchronized java.lang.Object newinstance(java.lang.Class type,
int num): crea un objeto del tipo indicado
ARCOS- UC3M
20
HeapMemory e InmortalMemory
• Métodos básicos.
Ambas clases aplican el patrón singleton
No se utilizan constructores para obtener un objeto de las mismas, sino
que se deben utilizar los métodos:
– public static HeapMemory instance()
– public static InmortalMemory instance()
que devuelven la instancia correspondiente del tipo de área indicado.
ARCOS- UC3M
21
ScopedMemory
• Es una clase abstracta de la que heredan:VTMemory y LTMemory (no sujetas
al recolector de basura => pueden ser utilizadas por NoHeapRealtimeThread)
y ScopedPhysicalMemory
• Métodos para asociar un área de memoria de ámbito a un thread
– Colocar el área como uno de los parámetros que se pasan al crear el thread
– Ejecutar el método enter()
• Los objetos creados mientras esta asociada un ScopedMemory a un thread se
crearán en dicho área.
• Cuando se termina de utilizar el área se ejecutan los métodos finalize de cada
uno de los objetos del área
• Métodos básicos.
– public ScopedMemory (long tamaño): Constructor
– public void enter (java.lang.Runnable logic): similar al descrito en la clase
MemoryArea
ARCOS- UC3M
22
ScopedMemory (subclases)
• VTMemory: Tiempo de reserva de espacio variable.
– public VTMemory(int inicial, int maximo): constructor que define el
tamaño asociado inicial y el máximo que puede llegar a tener dicho área.
• LTMemory: Garantiza un tiempo lineal (dependiente del tamaño del
objeto) de reserva de espacio para los objetos que se creen en ella. No
se garantiza que esté disponible el tamaño máximo cuando se necesita.
– public LTMemory(long inicial, long maximo): constructor que define el
tamaño asociado inicial y el máximo que puede llegar a tener dicho área.
• ScopedPhysicalMemory: Memoria de ámbito asociada a una
determinada zona de memoria física. Describiremos sus métodos más
adelante.
ARCOS- UC3M
23
Gestión de la Memoria Física
•
Es posible asociar áreas de memoria a zonas físicas de la memoria.
•
Existe un gestor encargado de realizar la asociación y buscar el tipo de memoria
indicado (dma, shared, byteswap) y el lugar: class PhysicalMemoryFactory
•
Métodos:
– protected synchronized java.lang.Object create(java.lang.Object tipoDeMemoria,
java.lang.ClassphysMemType, long base, long size) Crea una zona de memoria
con las características indicadas.
– protected synchronized java.lang.Object getTypedMemoryBase (java.lang.Object
tipoDeMemoria, java.lang.ClassphysMemType, long base, long size): devuelve la
dirección física del trango de memoria del tipo indicado que tiene como mínimo el
tamaño especificado
•
Tipos de áreas de memoria física :
– ImmortalPhysicalMemory
– ScopedPhysicalMemory
– RawMemoryAccess
• RawMemoryFloatAccess
ARCOS- UC3M
24
ImmortalPhysicalMemory
• Immortal: La vida de los objetos es mayor que la de la aplicación
• Physical: Permite asociar objetos a una determinada posición de
memoria física.
• Métodos:
– protected ImmortalPhysicalMemory ([ImmortalPhysicalMemory
memoria,] long base, long tamano): constructor , utilizado por el
MemoryObjectFactory, que define la dirección física (base) y el tamaño
del área que será creada
– public static ImmortalPhysicalMemory create (java.lang.Object tipo,
[long base, ,] long tamano) Crea un área del tipo (dma, shared,..) indicado
en la dirección física (base) y con el tamaño en bytes solicitado.
– public static void setFactory (PhysicalMemoryFactory factory): define
quien será el encragado de generar las instancias de
ImmortalPhysicalMemory
ARCOS- UC3M
25
ScopedPhysicalMemory
• Métodos
– protected ScopedPhysicalMemory(long base, long tamano): constructor ,
utilizado por el MemoryObjectFactory, que define la dirección física
(base) y el tamaño del área que será creada
– public static ScopedPhysicalMemory create (java.lang.Object tipo, long
base, long tamano) Crea un área del tipo (dma, shared,..) indicado en la
dirección física (base) y con el tamaño en bytes solicitado.
– public static void setFactory (PhysicalMemoryFactory factory): define
quien será el encragado de generar las instancias de
ScopedPhysicalMemory
ARCOS- UC3M
26
RawMemoryAccess
• Modela una zona de memoria física como una secuencia de byte
• No sirve para almacenar objetos sino para ser usada como una zona de
memoria de acceso crudo (por ejem. para guardar imágenes de I/O,
drivers, etc.)
• Métodos:
– protected RawMemoryAccess ([ImmortalPhysicalMemory memoria,] long
base, long tamano): constructor , utilizado por el MemoryObjectFactory.
– public static RawMemoryAccess create (java.lang.Object tipo,[long base,]
long tamano) Crea un área del tipo (dma, shared,..) indicado en la
dirección física (base) y con el tamaño en bytes solicitado.
ARCOS- UC3M
27
RawMemoryAccess
• Métodos
– public byte getByte(long offset): devuelve el byte que se encuentra en el
desplazamiento indicado, existen métodos similares para Int, Long, y
Short y para arrays
– public void setByte(long offset, byte valor): coloca el valor en el byte que
se encuentra en el desplazamiento indicado, existen métodos similares
para Int, Long, y Short y para arrays
– public long map([long base,] [long tamano]):Mapea el rango de
direcciones físico del RawMemoryAccess a la zona de memoria virtual
indicada en base con el tamaño indicado. Devuelve la dirección de
memoria virtual a la que ha sido mapeada.
– Public long getMappedAddress(): Devuelve la localización de la memoria
virtual en la que está mapeada el dicho RawAccessMemory
– public void unmap(): Elimina el mapeado realizado sobre la memoria
virtual
ARCOS- UC3M
28
MemoryParameters
• Son utilizados para definir las características de memoria
asociadas a RealtimeThreads y AsyncEventHandler
• Métodos:
– public MemoryParameters (long Tammaximo, long maxImmortal [, long
allocationRate]):Crea un objeto con :
• el límite máximo de tamaño de memoria indicado en tamMaximo
• el límite máximo del tamaño de memoria inmortal indicado en maxImmortal.
Ambos parámetros son en bytes y NO_MAX indica sin límite
• la velocidad de colocación, en bytes/sec. de datos en el heap indicada en
allocationRate. (NO_MAX para no especificar límite y 0 para no permitir
almacenamiento en el heap)
ARCOS- UC3M
29
Memoria Inmortal Ejem 1a
import javax.realtime.*;
/** Uso de memoria "Inmortal" en un proceso periódico. No se usa el heap
para evitar la sobrecarga del recolector de basura */
public class ImmortalMemoryExample {
public static void main(String[] Args) {
NoHeapRealtimeThread t = null;
// Defino el proceso con una periodicidad de 10 msg y 1 msec de cómputo
PeriodicParameters timeParams = new PeriodicParameters();
timeParams.cost = new RelativeTime(1, 0);
Params.period = new RelativeTime(10, 0);
// Defino la immortal memory; el tamaño es dado por el RealtimeSystem
MemoryParameters memParams = new
MemoryParameters(ImmortalMemory.instance());
ARCOS- UC3M
30
Memoria Inmortal Ejem 1b
Runner r = new Runner();
/* Creo un NoHeapRealtimeThread con parámetros periódicos y de
ImmortalMemory. */
try {
t = new NoHeapRealtimeThread(timeParams, memParams, r);
} catch (AdmissionControlException e) {}
// Arranco el proceso
t.start();
}}
/** Realizó el proceso periódico en memoria Inmortal*/
class Runner implements Runnable {
public void run() {
// código de procesamiento
ARCOS- UC3M
}}
31
import javax.realtime.*;
RawMemory Ejem 1a
/** subclass of RawMemoryAccess para acceder al espacio de I/O de un
Intel x86 para direccionar directamente la memoria. Este ejemplo
proporciona un interfaz para el Intel 8253 Programmable Interval
Timer*/
public class IOAccess extends RawMemoryAccess { /* ... */ }
public class I8253Example { /* ... */
private long counter0Offset = 0;
private long counter1Offset = 1;
private long counter2Offset = 2;
private long controlWordOffset = 3;
private byte controlWord0 = 0x00;
private byte controlWord1 = 0x00;
private byte controlWord2 = 0x00;
ARCOS- UC3M
32
RawMemory Ejem 1b
/** Crea una instancia de la clase I8253
* @param baseAddr dirección base*/
IOAccess iox;
public I8253Example(long baseAddr) {
iox = IOAccess.create(baseAddr, (long)8);
}
/* ... */
/** Escribe un valor de 16 bits (el contador 2)
. * @param value valor para el contador 2*/
public void setCounter2(short value) {
setControlWord(controlWord2);
iox.setByte(counter2Offset, (byte)(value & 0xFF));
iox.setByte(counter2Offset, (byte)(value >> 8));
ARCOS- UC3M
}
33
RawMemory Ejem 1c
/** Escribe un byte en el registro de control
* @param value valor para el registro de control*/
public void setControlWord(byte value) {
iox.setByte(controlWordOffset, value);
}
/* ... */
/** Lee un valor de 16 bits del contador2.
* @return valor del contador2*/
public short getCounter2() {
short value; setControlWord(COUNTER2);
value = (short)iox.getByte(counter2Offset);
value |= ((short)iox.getByte(counter2Offset) << 8);
return value;
} }
ARCOS- UC3M
34
3.- Sincronización
• La clausula synchronized, que protege el acceso a recursos
compartidos puede provocar el típico problema de los STR de
inversión de prioridad.
• ¿Cómo subsanarlo? => RTSJ modifica la interpretación de dicha
clausula definiendo MonitorControl como clase base para la política de
elección threads cuando puede darse ese problema de forma que se
evite la inversión de prioridad
• Cuando varios threads acceden a una zona sincronizada se aplica, por
defecto, una política de herencia de prioridad, pero es posible utilizar
también un protocolo de emulación de techo de prioridad
• Los threads que desean usar recursos compartidos (syncronized) se
ordenan por prioridad (dentro de igual prioridad con FIFO)
• Se deben utilizar mecanismos adicionales para evitar el bloqueo con
threads de menor prioridad que el GC
ARCOS- UC3M
35
MonitorControl
• Clase base para los objetos de control de la política de control de
monitores
• Métodos:
– public MonitorControl()
– public static void setMonitorControl(MonitorControl politica); define la
política aplicable cuando se accede a recursos comunes (synchronize)
– public static void setMonitorControl(java.lang.Object monitor,
MonitorControl politica): define la política aplicable cuando se accede a
recursos comunes, sólo para el objeto indicado.
ARCOS- UC3M
36
MonitorControl (subclases)
• PriorityCeilingEmulation
– public PriorityCeilingEmulation(int ceiling): crea un objeto de esta clase
con el techo indicado.
– public int getDefaultCeiling ()
• PriorityInheritance
– public PriorityInheritance():
– public static PriorityInheritance instance (): devuelve un puntero al objeto
único (singleton) PriorityInheritance.
ARCOS- UC3M
37
Comunicación entre Threads
• La modificación de la interpretación de la clausula synchronize no
soluciona el problema cuando alguno de los threads tiene menor
prioridad que el GC => se han creado colas libres de espera para
facilitar el acceso compartido a los objetos:
– WaitFreeWriteQueue
– WaitFreeReadQueue
– WaitFreeDequeue
ARCOS- UC3M
38
WaitFreeWriteQueue
• Para comunicar y sincronizar, RealtimeThreads y java.lang.Threads
sincronizados en lectura
• Métodos básicos:
– public WaitFreeWriteQueue(java.lang.Thread escritor, java.lang.Thread
lector, int max, MemoryArea mem): Crea una cola que tendrá como
maximo max elementos que se almacenarán en mem
– public void bind (java.lang.Thread escritor, java.lang.Thread lector,
MemoryArea mem): añade 2 nuevos threads con acceso a la cola, sino
tienen áreas de memoria comunes sólo podrán almacenar objetos
inmortales en la cola.
– public boolean write(java.lang.Object objeto): Intenta insertar el objeto en
la cola. No se bloquea si la cola está llena, devuelve false. Si 2 threads lo
utilizan a la vez deben asegurarse su sincronización.
– public synchronized java.lang.Object read(): este método se bloquea si la
cola está vacía. Es sincronizado y puede ser llamado por 2 o más threads
ARCOS- UC3M
39
WaitFreeReadQueue
• Para comunicar y sincronizar, RealtimeThreads y java.lang.Threads
sincronizados en escritura
• Métodos básicos:
– public WaitFreeReadQueue(java.lang.Thread escritor, java.lang.Thread
lector, int max, MemoryArea mem [, boolean notify]): Crea una cola que
tendrá como maximo max elementos que se almacenarán en mem. Si se
coloca true en notify se notificará al lector cuando se añaden elementos
– public synchronized boolean write(java.lang.Object objeto): Intenta
insertar el objeto en la cola. Se bloquea si la cola está llena y espera hasta
que haya sitio. Es sincronizado y puede ser llamado por 2 o más threads
– public java.lang.Object read(): Devuelve el siguiente elemento de la cola
o null si está vacia. No se bloquea. Si 2 threads lo utilizan a la vez deben
asegurarse su sincronización.
– Public void waitForData(): espera hasta que se la cola tiene algún
elemento
ARCOS- UC3M
40
WaitFreeDequeue
• Para comunicar y sincronizar, RealtimeThreads y java.lang.Threads
sincronizados o no en escritura y en lectura. Crea una WaitFreeWriteQueue y
una WaitFreeReadQueue
• Métodos básicos:
– public WaitFreeDequeue(java.lang.Thread escritor, java.lang.Thread
lector, int max, MemoryArea mem ): Crea una cola que tendrá como
maximo max elementos que se almacenarán en mem.
– public boolean blockingWrite(java.lang.Object objeto): llamada al write
de WaitFreeReadQueue (sincronizado)
– public java.lang.Object blockingRead(): llamada al read de
WaitFreeWriteQueue (sincronizado)
– public java.lang.Object nonBlockingRead(): llamada al read de
WaitFreeReadQueue (no sincronizado)
– public boolean nonBlockingWrite(java.lang.Object objeto): llamada al
write de WaitFreeWriteQueue (no sincronizado)
ARCOS- UC3M
41
4.- Eventos Asíncronos
• Se pueden definir eventos (AsyncEvent) y manejadores (AsyncEventHandler)
para los mismos que se ejecutarán cuando los primeros se disparen.
• Pueden asociarse varios manejadores a un mismo evento. Estos se ejecutarán
en el orden definido por sus Scheduling y Release parameters
• Se garantiza que por cada vez que se dispara el evento habrá una ejecución de
cada uno de los manejadores asociados
• Si el manejador tiene asociado SporadicParameters, se asegura que no habrá 2
ejecuciones del mismo en menos del tiempo entre ejecuciones consecutivas
indicado.
• Pueden definirse zonas en las que tengan efecto los eventos producidos
(métodos con throws AsynchronouslyInterruptedException) y zonas en las que
no
• Existen eventos POSIX definidos
ARCOS- UC3M
42
class AsyncEvent
• Métodos básicos:
– public AsyncEvent() :Constructor
– public synchronized void addHandler (AsyncEventHandler handler) :
Añade el manejador (handler) como uno (puede haber varios) de los
asociados a este evento. Cuando se produzca el evento se ejecutará el
método run() del dicho manejador
– public void bindTo(java.lang.String eventoExterno) : asocia el
AsyncEvent a un evento externo. Los valores dependen de la
implementación
– public ReleaseParameters createReleaseParameters(): Crea los
parámetros temporales apropiados para el evento AsyncEvent
– public synchronized void removehandler (AsyncEventHandler
handler): Elimina el manejador del conjunto de los asociados al evento
– public synchronized void fire() Dispara el evento => provoca la
ejecución de los métodos run() de los manejadores asociados
ARCOS- UC3M
43
class AsyncEventHandler
• Implementa Schedulable y Runnable
• Similares a los threads pero deben ser de mucho menor coste de ejecución.
• Se ejecutan, por defecto en el thread actual. Si se quiere crear un thread
propio para el manejador hay que usar BoundAsyncEventHandler
(subclase de AsyncEventHandler)
• Métodos básicos:
– public AsyncEventHandler() :Crea un manejador que hereda los
parámetros (SchedulingParams. ReleaseParam., etc) del thread actual.
Existen constructores y métodos en los que se pueden especificar esos
params.
– public void addToFeasibility()/ removeFromFeasibility()
– public abstract void handleAsyncEvent(): Método en el que se debe
definir el comportamiento del manejador cuando se dispare el evento.
ARCOS- UC3M
44
AsynEventHandler: Ejem 1a
import javax.realtime.*;
/* interface para eventos HW como Interrupciones.Una interrupción HW
dispara un AsyncEvent, queprovoca la ejecución del manejador asociado*/
public class HardwareEventExample extends AsyncEvent {
private int interruptNum;
/** Construye un nuevo evento Hardware para un interrupción dada
. * @param num numero de interrupción */
public HardwareEventExample(int num) {
interruptNum = num;
}
/** Asocia el manejador a la interrupción*/
public void setHandler(AsyncEventHandler h) {
super.setHandler(h);
Hardware.bind(interruptNum, h); //bindTo(interruptNum.toString());
}}
ARCOS- UC3M
45
AsynEventHandler: Ejem 1b
class HardwareEventHandler extends AsyncEventHandler {
private int interruptCount = 0;
public void handleAsyncEvent() {
interruptCount++;
// código del driver
}}
….
public static void main (String arg[) {
HardwareEventExample hwe= new HardwareEventExample ();
HardwareEventHandler hwh= new HardwareEventHandler ();
hwe.addHandler(hwh);
…
}
ARCOS- UC3M
46
5.- Medida del Tiempo
• RTSJ permite una mayor precisión en la medida del tiempo y la
definición de tiempos relativos o absolutos:
• HighResolutionTime:
– Clase que permite precisión de nanoseg.(64 bits=msec+offset en nanosec)
– Es abstracta, hay que usar sus subclases:
• AbsoluteTime
• RelativeTime
– Tiene métodos para pasar de tiempos relativos a absolutos (absolute() ),
para comparar tiempos (compareTo(..), equals(..) ) y para obtener el
tiempo actual (set(..) )
– Public abstract AbsoluteTime absolute
ARCOS- UC3M
47
HighResolutionTime(subclases)
• AbsoluteTime: Tiempo absoluto desde 1-1-1970 a las 00:00:00 GMT
– public AbsoluteTime (long millis, int nanos): crea un obj. con ese tiempo
– public AbsoluteTime add(long millis, int nanos) / add (RelativeTime time)
Se crea un nuevo objeto al que se le añade el tiempo indicado.
• RelativeTime: Tiempo relativo desde el instante actual.
– public RelativeTime (long millis, int nanos): crea un obj. con ese tiempo
– public AbsoluteTime add(long millis, int nanos) / add (RelativeTime time)
Se crea un nuevo objeto al que se le añade el tiempo indicado.
• RationalTime: Subclase de RelativeTime que divide un tiempo en
subintervalos de cierta frecuencia. Se utiliza para disparar tareas periódicas.
– public RationalTime (int frecuencia, long millis, int nanos): crea un obj.
con el nº de ocurrencias indicado por frecuencia en el intervalo
millis+nanos . Ejem. Si tengo (3, 100, 50) como RationalTime para un
Temporizador periódico, el temporizador se ejecutara 3 veces cada 100ms
ARCOS- UC3M
48
50 nanoseg.
6.- Temporizadores
• RTSJ permite temporizadores periódicos o puntuales a los
que se les pueden asociar acciones como a cualquier eventos
asíncrono
• Existe un reloj de tiempo real por defecto
(getRealtimeClock()) pero es posible crear instancias propias
de relojes (class Clock) a las que se les puede asignar la
precisión que se desee (setResolution()) para después solicitar
el tiempo actual (getTime()) o utilizarlo para definir
temporizadores.
ARCOS- UC3M
49
Timer
• Es la clase base de los temporizadores, hereda de AsyncEvent
• No se deben definir directamente objetos de la misma(
Constructor: protected Timer (…) )
• Métodos básicos:
– public void disable(): deshabilita el temporizador, si este se dispara
mientras está desabilitado, cuando vuelva a habilitarse se disparará.
– public void enable() : re-habilita el temporizador. No es necesario invocar
a este método para habilitar el temporizador la 1ª vez, se usa start()
– public void start (). Arranca (habilita) el temporizador
– public ReleaseParameters createReleaseParameters(): Crea los parámetros
de temporización apropiados para el evento AsyncEvent
– public AbsoluteTime getFireTime() devuelve cuando se disparará el
temporizador.
ARCOS- UC3M
50
Timer (Subclases)
• OneShotTimer
– public OneShotTimer (HighResolutionTime time, [Clock reloj,]
AsyncEventHandler manejador): Define un temporizador que provocará la
ejecución del manejador cuando se dispare.
• PeriodicTimer
– public PeriodicTimer (HighResolutionTime start, RelativeTime intervalo,
[Clock reloj,] AsyncEventHandler manejador): Define un temporizador
que comenzara a contar el tiempo en start y se disparara cada intervalo
provocando la ejecución del manejador.
ARCOS- UC3M
51
Timer Ejem 1a
public class TimerPrueba {
private static void TimerPrueba (String nombre, Timer t){
SchedulingParameters prioridad=new
PriorityParameters(PriorityScheduler.getMaxPriority() );
System.out.println (“Prueba “+nombre);
ReleaseParameters rp= t.createReleaseParameters();
rp.setCost(new RelativeTime(10,0));
t.addHandler( new AsyncEventHandler(prioridad, rp, null) {
public void handleAsyncEvent(){
System.out.println (“Fin del tiempo “+ System.currentTimeMillis());
} } ); // fin addHandler
tp.start();
try { Thread.sleep(2000);
} catch (InterruptedException ie) {}
}
ARCOS- UC3M
52
Timer Ejem 1b
public class Prueba {
private static void main (String a[]){
OneShotTimer ost=new OneShotTimer(new RelativeTime(500,0), null);
PeriodicTimer pt=new PeriodicTimer(new RelativeTime(500,0),
new RelativeTime(100,0), null);
TimerPrueba tp= new TimerPrueba(“tempor”, ost);
// TimerPrueba tp= new TimerPrueba(“tempor”, pt);
}
}
ARCOS- UC3M
53
7.- Transferencia Asíncrona de Ctrl
(ATC)
• RTSJ permite cambiar el flujo normal de ejecución de forma
asíncrona. Para permitir, por ejem., que un cálculo que
produce un resultado que se refina iterativamente pueda
finalizar pasado un determinado tiempo.
• Se basa en la extensión de java.lang.Thread.interrupt(), en
las clases AsynchronouslyInterruptedException (AIE), Timed
y el interface Interruptible
• La ATC debe cumplir varios principios:
ARCOS- UC3M
54
Principios ATC (I)
• Pr. Metodológicos:
– Un Thread debe indicar explícitamente que puede ser objeto de una
ATC.
– Pueden existir fragmentos de ese Thread protegidos contra ATC
– Una ATC no tiene vuelta al punto en el que se estaba ejecutando
cuando se produjo. Si es necesaria la vuelta hay que usar
AsyncEvendHandler
• Pr. De Expresividad
– Existirá un mecanismo para disparar de forma explícita un ATC, bien
directamente desde otro Thread o indirectamente mediante un
AsyncEventHandler
– Se podrá disparar una ATC basada en cualquier tipo de evento
asíncrono (evento externo, temporizador, disparo desde otra tarea)
– Será posible abortar un Thread mediante una ATC sin los riesgos de
los métodos stop o destroy de java.lang.Thread
ARCOS- UC3M
55
Principios ATC (II)
• Pr. Semánticos
– Si se utiliza el tratamiento de excepciones para una ATC se debe
asegurar que una excepción asíncrona sólo se capturará por un
manejador expecífico de la misma y no por uno de proposito grl.
– Se podrán tener ATCs anidadas
• Pr. Pragmáticos
– Deben existir patrones sencillos para casos comunes (temporizadores)
– La ATC debe implementarse sin incluir sobrecarga para las
aplicaciones que no la usen.
– Si un bloque de código asociado a un temporizador termina antes de
que se dispare el temporizador, éste se parará y sus recursos será
liberados.
ARCOS- UC3M
56
Funcionamiento ATC
• Para que un método pueda ser interrumpido debe incluir la
clausula:
throws AsynchronousInterruptedException
en su declaración
• El mecanismo de ATC entra en funcionamiento si t es una
instancia de RealtimeThread o NoHeapRealtimeThread y :
– Cualquier tarea del sistema ejecuta t.interrupt()
– t ha sido asociado a una AIE (con aie.doInterruptible(t) ) y se
ejecuta aie.fire()
ARCOS- UC3M
57
Funcionamiento ATC(II)
• Cuando se dispara la AIE si el control se encuentra:
– en una sección no interrumpible =>se coloca la AIE como pendiente
hasta que se vuelva a una sección interrumpible o se invoque a un
método interrumpible
– en una sección interrumpible =>el control se transfiere a la cláusula
catch más proxima que trate esa AIE y no este en una sección
interrumpible
– en wait, sleep o join => se despierta al thread y se lanza la AIE.
• Si el control se transfiere de un método no interrumpible a uno
interrumpible mediante la propagación de una excepción y hay una
excepción AIE pendiente en el momento de la transición, entonces
se descarta la excepción lanzada y se remplaza por la AIE
Def: Sección no interrumpible es una sección sincronizada o un método sin
throws AIE
ARCOS- UC3M
58
AsynchronouslyInterruptedException
(AIE)
• Subclase de java.lang.InterruptedException
• Excepcíón especial que se lanza en respuesta al intento de realizar
una transferencia asíncrona de control en un RealtimeThread
• Si un método declara que lanzará (thows) una AIE, ésta se
producirá cuando se invoque a RealtimeThread.interrupt() mientras
ese método esté ejecutando o, si está pendiente, cuando el control
vuelva al mismo
• Cuando se captura una interrupción (AIE) se debe invocar el
método happened() para comprobar que es la pendiente, con lo que
será eliminada del thread, sino se continuará propagando.
ARCOS- UC3M
59
AsynchronouslyInterruptedException
• Métodos
(AIE)
– public AsynchronouslyInterruptedException ()
– public synchronized boolean disable() deshabilita el tratamiento de la
interrupción. Si ésta salta mientras está deshabilitada se pone en
estado de pendiente y se lanzará en cuanto vuelva a ser habilitada.
Sólo debe ser invocado dentro de una llamada a doInterruptible()
– public synchronized boolean enable() habilita el tratamiento de la
excpecion.
– public boolean doInterruptible (Interruptible tarea): invoca al método
run() de la tarea
– public shnchronized boolean fire() Hace que esa excepción sea la
actual si se ha invocado a doInterruptible() y no se ha completado
– public boolean happened (boolean propagar) utilizada con una
instancia de esa excepción para ver si la actualmente disparada es ella.
Propagar indica si ésta se debe
propagar
ARCOSUC3M o no si no es la actual.
60
Timed
• Subclase de AIE.
• Se utiliza para realizar una ATC basada en un temporizador (se
invocará a interrupt() y por tanto se disparará la excepción cuando
cumpla el temporizador)
• Métodos:
– public Timed (HighResolutionTime tiempo) : Crea una instancia de
Timed que invocará a interrup() cuando pase el tiempo indicado
después de invocar a doInterruptible()
– public boolean doInterruptible(Interruptible tarea) ejecuta el método
run de la tarea y arranca el temporizador
ARCOS- UC3M
61
Interface Interruptible
• Se utiliza para los objetos que vayan a ser interrumpidos por medio
de AIE.doInterruptible();
• Métodos
– public void interruptAction (AIE excepcion) : es el método que se
ejecuta si el método run es interrumpido. La excepcion indica el AIE
generado y sirve para invocar métodos de la misma.
– Public void run (AIE excepcion) :método que se ejecuta cuando se
invoca a doInterruptible(). El parámetro sirve para lo mismo que en el
método anterior.
ARCOS- UC3M
62
ATC ejem 1a
public class ATCPrueba implements Interruptible{
public void noInterrumpible(){ /* codigo no interrumpible*/ }
public void interrumpible() throws AsynchronouslyInterruptedExcepcion {
/* codigo interrumpible */ }
public void run (AsynchronouslyInterruptedException e) throws
AsynchronouslyInterruptedExcepcion {
interrumpible();
noInterrumpible ();
e.disable();
// no interrumpible
e.enable(); }
public void interruptAction (AsynchronouslyInterruptedExcepcion e){
// Acciones a ejecutar cuando se recibe la interrupción
}}
ARCOS- UC3M
63
ATC ejem 1b
public class Prueba {
private static void main (String a[]){
ATCPrueba atc= new ATCPrueba();
Timed t= new Timed (new RelativeTime(500,0));
t.doInterruptible(atc);
}
}
ARCOS- UC3M
64
AsynchronouslyInterruptedException 1a
import javax.realtime.*;
public class AIEExample {
private class MyTimed extends Timed {
public MyTimed(HiResTime timeout) {
super(timeout);
}}
/** Calculo “largo” que debe ser controlado con timed out. */
int computeRefinedAnswer(MyTimed T) throws MyTimed {
int refinedAnswer = 0;
T.start();
// Calculo largo
T.disable();
return refinedAnswer;
}
ARCOS- UC3M
65
AsynchronouslyInterruptedException 1b
/** Si ocurre un timeout mientras estoy calculando se devuelve el valor
por defecto*/
public int computeAnswer() {
int roughAnswer = 3;
// 100 usec de timeout
MyTimed T = new MyTimed((new RelativeTime(0, 100000)));
try {
return computeRefinedAnswer(T);
} catch (MyTimed t) {
return roughAnswer; // timed out cumplido
}
}
}
ARCOS- UC3M
66