Java en Tiempo Real

Java en TiempoJava en Tiempo
RealReal
Óliver CentenoÓliver Centeno

TemarioTemario
1. Sistemas de Tiempo Real (RTS)
2. Java y RTS
3. Modelo de Objetos en RTSJ
4. Sincronización
5. Eventos Asíncronos
6. Control Asíncrono
7. Caso de Estudio

Sistemas de Tiempo RealSistemas de Tiempo Real
• ¿Qué es RTS?
– No es alto rendimiento
– No es computación eficiente/rápida
– No son aplicaciones dinámicas
– Es responder a eventos del mundo real
– En un intervalo de tiempo acotado
– En un instante preciso
– De manera predecible y determinista

• ¿Qué es RTS?
– El sensor que detecta cada piso de un
ascensor
– El sistema de navegación de un avión
que monitoriza altitud, temperatura,…

• Conceptos
– Job (Trabajo)
• Elemento básico de ejecución en RTS
– Task (Tarea)
• Conjunto de trabajos relacionados
• Para completar una operación determinada
• READY, RUNNING/EXECUTING, BLOCKED
– Thread (Hilo de ejecución)
– Deadline (Tiempo de entrega)

• Conceptos
– Release Time (r)
• Una tarea entra en estado READY
– Start Time (s)
• Una tarea entra en estado RUNNING
– Finish Time (f)
– Task Completion Time (c = f – r)
– Lateness (t)
• Diferencia entre f y su tiempo de entrega

• Conceptos
– Latency (Latencia)
• Retardo entre un evento y la respuesta al mismo
• El objetivo NO ES minimizarla
• El objetivo ES normalizarla, hacerla predecible
– Jitter (Fluctuaciones)
• Variación de la latencia en eventos similares
• Desviación típica de la latencia
– Outliers (Valores extraños)

• Conceptos
– Soft Real Time (SRT)
• Se puede perder algún deadline pero no muchos
• Reproductor de vídeo
– Hard Real Time (HRT)
• No se admite la pérdida de ningún deadline
• El estado del sistema se vuelve inconsistente
• Sincronizar el audio del video
– Isochronal Real Time (IRT)
• Implica un deadline y un tiempo NO ANTES DE

• Conceptos
– Task Completion Value (Valor de
ejecución)

Computación en TiempoComputación en Tiempo
RealReal
• Construir aplicaciones con
restricciones de tiempo real
• Tradicionalmente mediante
controladores específicos HW
• Actualmente mediante interrupciones
• Sistemas de propósito general
– Servidores, PCs, portátiles,…

RealReal
• ¿Cómo implementarla?
– Analogía de la autopista
– Carril VAO
– En general, el sistema pierde
rendimiento
– Se debe controlar la entrada/salida del
VAO
– A algunos coches se les deniega el
acceso

RealReal
• Restricciones
– Recursos limitados
• CPU, memoria, controlador de disco,…
• Objetos synchronized, Bus,…
– Precedencia
• Independientemente del número de
procesadores
– Tiempo de Ejecución

RealReal
• Restricciones

RealReal
• Schedulling
– Preemtive/No-Preemptive
• Con derecho preferente (mayor prioridad)
• Puede desplazar a un thread en ejecución
– Estática/Dinámica
• Poder cambiar la prioridad en ejecución
– Tarea Periódica/Aperiódica/Esporádica
• En cuanto a su Release Time

Java en Tiempo RealJava en Tiempo Real
• JVM
– Plataforma de propósito general
– Escritorio y servidor
– Mejora del rendimiento mediante tunning
– Dependencia de la aplicación
– GC impredecible e incontrolable
– No se garantiza la prioridad de los Thread
– …

• Garbage Collector
– Resuelve problemas de
asignación/liberación de memoria
– Zona de memoria asignada -> objeto
– Montículo (heap) de objetos
– Varios GC implementados en JVM

• Algoritmos para Garbage Collector
– Tracing
• Recorre las dependencias de las variables
locales y descarta objetos no referenciados
– Stop-the-World
• Detener la ejecución para examinar todo
• Impedir que se creen objetos nuevos
– Mover y Copiar
• Desfragmentar la memoria

• Algoritmos para Garbage Collector
– Generational
• Desfragmentación metódica
• Distintas áreas de memoria (generaciones)

• Algoritmos para GC en Java
– Serial Collector
• Tipo Stop-the-World
• -XX:+UseSerialGC
– Parallel [Compacting] Collector
• Sólo para la generación Young
• -XX:+UseParallelGC
• -XX:+UseParallelOldGC
– Concurrent Mark-Sweep Collector
• Sólo para la generación Old
• -XX:+CMSIncrementalMode

– Garbage-First (G1)
• GC de servidor con soporte para varios
procesadores y amplia memoria
• Incluido en JRE 7
• Memoria dividida en "cards" de 512 byte
referenciadas desde una tabla de cards

• ¿Algoritmos GC en tiempo real?
– Deben ser deterministas y predecibles
– Varias estrategias
• Basadas en trabajo, en tiempo, …
– ¿Y en Java?
• Java Real-Time System (RTSJ)
• Incluye el RTGC de Henriksson

• ¿Algoritmos GC en tiempo real?
– RTGC de Henriksson (1998)
• Muchos RTS tienen pocos threads de alta
prioriodad y muchos de baja
• El GC debe tener una prioridad intermedia
• Para que se ejecute con los demás hilos
• 2 heaps: FROM y TO
• Tabla de punteros a
objeto

RTSJRTSJ
• Especificación para RTS en Java
• Primer JSR liberado (JSR-001)
• http://www.rtsj.org/
• http://jcp.org/en/jsr/detail?id=282
• Planificación de tareas en tiempo real
• Mejorar tu habilidad para escribir
código en tiempo real y portable
• javax.realtime

RTSJRTSJ
• Principios
– Agnosticidad de JRE
• No incluir ninguna versión de JRE ni JDK
– Predecibilidad
– Compatibilidad
– Sintaxis
– Write-Once-Run-Anywhere
– Flexibilidad
– Extensibilidad

RTSJRTSJ
• Requisitos de implementación
– Búsqueda y descubrimiento de perfiles
• Baja prioridad, alta disponibilidad,…
– GC con latencia acotada
– Relaciones entre real-time threads
• Detección/Reflexión del tipo de thread
– Sincronización
– Manejo asíncronos de Eventos
– Terminación asíncrona de threads
– Exclusión mútua

RTSJRTSJ
• Scheduling
– La unidad de planificación no es Thread
– Interfaz Schedulable

RTSJRTSJ
• Manejo de Memoria
– 4 zonas de memoria
– Algoritmo GC opcional
– Heap
– Scoped
– Inmortal
– Física

RTSJRTSJ
– ScopedMemory
– Creación dinámica
– Tamaño configurable
– No GC
– Método enter()
– Conteo de referencias

RTSJRTSJ
– ImmortalMemory
– Existencia única
– Tamaño limitado
– Nunca se hace GC
– No admite referencias a Scoped
– Datos estáticos

RTSJRTSJ
– Memoria física
• LTPhysicalMemory
• VTPhysicalMemory
• ImmortalPhysicalMemory
– Usadas para DMA
– Comunicación con controladores

RTSJRTSJ
• Recursos Compartidos
– Evitar el problema de inversión de
prioridad
– MonitorControl

RTSJRTSJ
• Eventos Asíncronos
– Manejo de eventos de SO, IO, red,
manejo de threads,…
– AsyncEvent y AsyncEventHandler
– AsynchronouslyInterruptedException

RTSJRTSJ
• Implementaciones
– Sun Java Real-Time System
• http://www.oracle.com/technetwork/java/
javase/tech/rts-142899.html
– IBM WebSphere Real Time
– Timesys
• http://www.timesys.com/java/
– JamaicaVM
• http://www.aicas.com/jamaica.html

RTSJRTSJ
• Implementaciones
– Sun Java RTS no es Java SE
– Es una JVM completa
– Pero requiere capacidades RTS
– Sistemas Operativos soportados:
• Solaris 10
• SuSE Enterprise Real-Time (SLERT) 10
• RedHat Enterprise (MRG)

RTSJRTSJ
• Instalación
– Obtener y descomprimir el paquete de
instalación
– Modificar /etc/security/limits.conf
– Crear un grupo "realtime" si no existe
• Y añadir al usuario actual
@realtime soft cpu unlimited
@realtime - rtprio 100
@realtime - nice 40
@realtime - memlock unlimited

Modelo de Objetos RTSJModelo de Objetos RTSJ
• En RTS es importante garantizar el
determinismo
• Los objetos normales no lo hacen
• Nuevo objeto raíz "Schedulable"
– Extiende Runnable
– Permite configurar parámetros de
• Memoria, planificación, liberación,…

• Implementaciones de Schedulable
– RealtimeThread (RTT)
– NoHeapRealtimeThread (NHRT)
– AsyncEventHandler (AEH)
– BoundAsyncEventHandler (BAEH)

• Estos objetos Schedulable son
manejados por Scheduler
• Clase abstracta
• Implementación obligatoria
• Otras opcionales
• PriorityScheduller
– Implementa prioridad real
– Parámetros de prioridad

• PriorityParameters
– Indica la prioridad del Schedulable
– Extiende SchedulingParameters
• setSchedulingParameters()
• ImportanceParameters
– Hereda de PriorityParameters
– Actúa ante misma prioridad
• setImportance()

• ReleaseParameters
– Indican cada cuanto se va a liberar un
Schedulable
• setReleaseParameter()
• setDeadline()
– PeriodicParameters
– AperiodicParameters
– SporadicParameters

• Ejemplos
– PriorityParameters
Schedulable rt1 = new RealtimeThread();
int maxPri = PriorityScheduler.instance()
.getMaxPriority();
PriorityParameters p =
new PriorityParameters(maxPri);
rt1.setSchedulingParameters(p);

• Ejemplos
– ImportanceParameters
int maxPri = PriorityScheduler.instance().getMaxPriority();
ImportanceParameters i1 =
new ImportanceParameters(maxPri, 1);
rt2.setSchedulingParameters(i1);
ImportanceParameters i2 =
new ImportanceParameters(maxPri, 2);
rt3.setSchedulingParameters(i2);
// Aumento la importancia de rt2
i1.setImportance(3);

• Ejemplos
– ReleaseParameters
RelativeTime milli = new RelativeTime(1,0);
ReleaseParameters p = new PeriodicParameters(milli);
rt1.setReleaseParameters(p);
RelativeTime deadline = milli;
// Cambio el deadline de los 3 objetos Schedulable
p.setDeadline(deadline);
// Obtengo el deadline de rt1
RelativeTime d = rt1.getReleaseParameters().getDeadline();

• Ejemplos
– PeriodicalParameters
// Periodo de 1ms con retardo de 1sg
RelativeTime milli = new RelativeTime(1,0); // 1 milli
RelativeTime delay = new RelativeTime(1000,0); // 1 second
PeriodicParameters per = new PeriodicParameters(delay, milli);
rt1.setReleaseParameters(per);

• Threads (I de III)
– RealtimeThread (RTT)
– Hereda de Thread
– Implementa Schedulable
– Se ejecuta en el Heap por defecto
– Pero con más prioriodad
• Que el GC
• Que el compilador JIT
• Que otros Thread

• RealtimeThread
import javax.realtime.RealtimeThread;
public class UnRTT {
public static void main(String[] args) {
RealtimeThread rtt = new RealtimeThread() {
public void run() {
// Código real-time
}
};
rtt.start();
// El thread principal pierde la preferencia (1CPU)
}
}

• RealtimeThread
– Parámetros configurables
• Prioridad: SchedulingParameters
• Periodo: ReleaseParameters
• Memoria asignada: MemoryParameters
• Contexto de memoria: MemoryArea
• …
– Distintos constructores
– Getters y Setters

• RealtimeThread
– Ejemplo
class ControlTemperatura extends RealtimeThread {
public TempGauge(SchedulingParameters sched,
ReleaseParameters rel) {
super(sched, rel);
// iniciar el thread aquí o en otro sitio
this.start();
}
public void run() {
// Comprobar la temperatura periódicamente...
}
}

• RealtimeThread
– Se puede separar la ejecución de RTT
– Extender Runnable
– Utilizar el constructor de RTT que lo
admite como parámetro
class ControlTemperatura implements Runnable { }
public void ejecutar(SchedulingParameters sched,
ReleaseParameters rel) {
ControlTemperatura ct = new ControlTemperatura();
// iniciar el thread
RealtimeThread rtt = new RealtimeThread(
sched, rel, null, null, null, ct).start();
}

• RealtimeThread
– Se puede indicar una periodicidad
– PeriodicParameters
// Parámetro de prioridad
PriorityParameters sched = new PriorityParameters(
PriorityScheduler.instance().getMaxPriority());
// Parámetro de periodicidad (1ms)
ReleaseParameters rel = new PeriodicParameters(
new RelativeTime(1, 0) );
// Ejecutar el thread con estos parámetros
ejecutar(sched, rel);

• Threads (II de III)
– NoHeapRealtimeThread
– No puede acceder al heap
• MemoryAccessError
– Puede interrumpir al GC
– RTT debería esperar a un estado
consistente del heap
– Se debe indicar siempre un MemoryArea

• NoHeapRealtimeThread
static {
// Crear el NHRT con memoria inmortal
NoHeapRealtimeThread nhrt = new NoHeapRealtimeThread(
null, ImmortalMemory.instance()){
public void run() {
// Código de ejecución...
}
};
nhrt.start();
}
public static void main(String[] args){}

• NoHeapRealtimeThread
– Hilo determinista con la mejor latencia
– No se puede iniciar por sí solo
– Ejecutar desde el run() de un RTT
– Para crear la memoria inmortal/scoped
– E instanciar los objetos en ella
– Ejemplo página 168
– Clase NHHelper

• Uso de NHHelper
public class Main {
public static void main(String[] args) throws Exception {
NHHelper nhrtHelper =
new NHHelper(ControlTemperatura.class);
// arranco el hilo
nhrtHelper.start();
}
}

• Uso de NHHelper
public class Main {
static ScopedMemory sm = new LTMemory(8192000);
public static void main(String[] args) throws Exception {
NHHelper nhrtHelper =
new NHHelper(sm , ControlTemperatura.class);
nhrtHelper.start();
}
}

• Threads (III de III)
– Periodic Threads
– ¿Cada cuánto ejecutar una tarea?
– ¿Cuál es el deadline de ejecución?
– De controlar la altitud cada milisegundo

• Hilos Periódicos
public class ControlTemperatura implements Runnable{
public void run() {
boolean ok = waitForNextPeriod();
if(!ok){
System.out.println("Se ha perdido el deadline");
}
}
}

• Hilos Periódicos
– Manejo del Deadline
– Implementar un AsyncEventHandler
• Asociado al objeto a manejar
• handleAsyncEvent()
• Cambiar el perido (por ej.)
• Añadir el manejador al PeriodicParameters

• Ejemplo
// Creo el Schedulable
ControlTemperatura task = new ControlTemperatura();
// Creo el manejador
DeadlineMissHandler dmh = new DeadlineMissHandler(task);
// Indico el periodo y el manejador como parámetros
RelativeTime period = new RelativeTime(1,0); // 1 milli
// Si no indico deadline se toma el valor del periodo
ReleaseParameters release = new PeriodicParameters(
null, period, null, null, null, dmh );
// Parametrizo e inicio la tarea
task.setReleaseParameters(release);
task.start();
}

• DeadlineMissHandler
// Código completo en página 180
class DeadlineMissHandler extends AsyncEventHandler {
private RealtimeThread thread = null;
public void handleAsyncEvent() {
// Manejo el evento, que sólo puede ser Deadline,
// cambiando el periodo del Schedulable
ReleaseParameters release = new PeriodicParameters(
new RelativeTime(5,0) ); // 5ms
setReleaseParameters(release);
// Replanifico el hilo
thread.schedulePeriodic();
}
}

• Hilos Aperiódicos
– No se sabe cada cuánto se van a liberar
– NO hay un waitForNextRelease()
– Se crea el RTT a través de un método
– Invocable en momentos puntuales
public void deshabilitarPilotoAutomatico() {
RealtimeThread rt = new RealtimeThread( sched, rel ) {
public void run() {
// ...
}
};
rt.start();
}

Modelo de Memoria RTSJModelo de Memoria RTSJ
• Modelo de Memoria
– Heap, Scoped e Immortal
– Configurables por redondeo
• -XX:ImmortalSize32M
• -XX:ScopedSize16M
• -XX:+RTSJShowHeapLayout
– Objeto MemoryArea
• Crea una zona de memoria de tamaño dado
• Método enter() ejecuta un Runnable

static ScopedMemory sm = null;
public void run() {
// Creo una memoria de ~4MB
int memSize = 4096000;
// Lanzo una tarea Runnable
sm = new LTMemory( memSize, new MiTarea() );
sm.enter();
// En dos pasos
sm = new LTMemory( memSize );
sm.enter( new MiTarea() );
}

– Se puede consultar el MemoryArea
• MemoryArea.getMemoryArea(obj)
• rtt.getMemoryArea()
– Se pueden referenciar objetos de otras
areas (no todas)
– OJO con la recursividad
public void run() {
ImmortalMemory.instance().enter(this);
}

• ScopedMemory
– Tamaño inicial y máximo
– No hay GC sino conteo de referencias
– OJO con los objetos inmutables (String)
– 4 tipos de memoria Scoped
• LT y VT
• Normal y Física

• ScopedMemory
– LT: Linear Time
• A la hora de asignar objetos
• Tamaño inicial reservado
• Ampliable hasta el tamaño máximo
– VT: Variable Time
• NO garantiza tiempos de asignación
– Physical
• Trabajan sobre memoria física

• ScopedMemory
– Los scopes se apilan a modo de herencia
(padre-hijo)
– Un Schedulable se crea en un área pero
puede ejecutarse en otro
– Acceso a los distintos scopes
• getCurrentMemoryArea()
• getMemoryAreaStackDepth()
• getInitialMemoryAreaIndex()
• getOuterMemoryArea(index)

• ScopedMemory
– Single Parent Rule
• Cada ScopeMemory tiene un padre
• Scope "Primordial" o el de un thread
– Heap e Immortal tienen padre primordial
• Ejemplo
– Se crea un RTT en el Heap y se ejecuta en 'a'

• ScopedMemory
– Usos (I)
• Scope Run-Loop
– Crear una memoria Scoped
– Ejecutar un Schedullable mediante enter()
static ScopedMemory smArea =
new LTMemory(4096000);
public void run() {
MiTarea task = new MiTarea();
while ( true ) {
smArea.enter(task);
waitForNextPeriod();
}
}

• ScopedMemory
– Usos (II)
• Scope Múltiple
– Crear objetos en una memoria Scoped "padre"
– Ejecutarlos en otra "hija"
– El acceso a campos se hace en el scope "padre"
public void run() {
Cuaderno c = new Cuaderno();
Escritor e = new Escritor(c);
for(int i=0; i< 10; i++ ) {
smHija.enter(e);
}
}

• ScopedMemory
– Usos (II)
• Scope Múltiple
class Escritor implements Runnable {
public Cuaderno c;
public void run() {
c.escribir("Lorem ipsum…"); // memoria hija
}
}
class Cuaderno {
private Vector datos = new Vector();
void escribir(String val) {
MemoryArea.getMemoryArea(this)
.executeInArea( new Boligrafo(val) );
}
}

• ScopedMemory
– Usos (II)
• Scope Múltiple
class Boligrafo implements Runnable {
public void run() {
// ejecutado en la memoria padre
datos.addElement( copiar(val) );
}
private String copiar(String s) {
String r = (String)getMemoryArea().
newInstance(String.class);
r = r.copyValueOf( s.toCharArray() );
return r;
}
}

• ScopedMemory
– Usos (III)
• Portal
– Objeto especial de un Scope
– Compartible por varios hilos
– setPortal() y getPortal()
– Puede ser cualquier tipo de objeto
– Puede ser un array
– Se debe sincronizar el acceso al scope
public void run() {
synchronized (sm) {
}
}

• PhysicalMemory
– Permite reservar memoria física
– De tipos determinados
• PhysicalMemoryManager
– ALIGNED, BYTESWAP, DMA, IO_PAGE, SHARED
– Con un tamaño dado
– Y opcionalmente
• En una posición dada
• Ejecutando un Runnable dado

• Se pueden crear objetos en cualquier
memoria
– Método newInstance()
String s = (String) HeapMemory.instance()
.newInstance(String.class);
Clase c = (Clase) ImmortalMemory.instance()
.newInstance(Clase.class);
Integer i = new LTMemory(4096000)
.newInstance(Integer.class);

Modelo de Tiempo de RTSJModelo de Tiempo de RTSJ
• Clock.getRealtimeClock()
– Mayor precisión y fiabilidad que
• System.currentTimeMillis
• System.nanoTime
• java.util.Date
– Mide tiempo absoluto y relativo
• Clases AbsoluteTime y RelativeTime
– Permite lanzar ticks
• Clases PeriodicTimer y OneShotTimer

Modelo de Tiempo de RTSJModelo de Tiempo de RTSJ
• Clock.getRealtimeClock()

SincronizaciónSincronización
• Acceso a recursos compartidos (I)
– synchronized
– Puede hacer perder un deadline
– PriorityInheritance
– Permite aplicar políticas
– De inversión de prioridad
– A objetos concretos

• PriorityInheritance
– Simulación
static public Object lock = new Object();
class HighPriority extends RealtimeThread {
public HighPriority() {
int pri = PriorityScheduler.instance().getMaxPriority()-1;
PriorityParameters sched = new PriorityParameters(pri);
this.setSchedulingParameters(sched);
}
public void run() {
synchronized ( lock ) {
for ( int i = 0; i < 100; i++ ) {
System.out.println("Altattt*");
}
} } }

– Simulación
public void run() {
this.setSchedulingParameters(new PriorityParameters(
PriorityScheduler.instance().getMaxPriority()));
LowPriority low = new LowPriority();
MedPriority med = new MedPriority();
HighPriority high = new HighPriority();
low.start();
RelativeTime abs = new RelativeTime(0,500000);
try {this.sleep(abs);} catch( Exception e ) { }
med.start();
high.start();
}

– Simulación
– Hilo de baja prioridad bloquea recurso
– Hilo de mayor prioridad lo quiere
– RTS aumenta la prioridad de baja
– Para que libere lo antes posible

• Acceso a recursos compartidos (II)
– ¿Y si quiero compartir un recurso entre
hilos RT e hilos no-RT?
– WaitFreeReadQueue y
WaitFreeWriteQueue
– Se encargan de sincronizar
– Garantizan tiempo acotado
– A menos que haya varios escritores

• Acceso a recursos compartidos (II)

• WaitFreeWriteQueue
– Lector Thread, Escritor RTT
– Los lectores podrían quedar bloqueados
– Limitar el tamaño de la cola
– El escritor se queda sin espacio (false)
– Puede forzar la escritura
• En un hueco intermedio (true)
• Sobrescribiendo el último dato insertado

public static WaitFreeWriteQueue queue =
new WaitFreeWriteQueue(5);
class QProducer implements Runnable {
public void run() {
for (int i=0; i < 100; i ++) {
String s = "This is msg# " + i;
queue.write(s);
RealtimeThread.waitForNextPeriod();
}
queue.force("FIN");
}
}

class QConsumer implements Runnable {
public void run() {
try {
boolean loop = true;
while ( loop ) {
String msg = (String)queue.read();
System.out.println("Leido: "+msg);
loop = ! msg.equalsIgnoreCase("FIN");
}
}
catch ( Exception e ) {
e.printStackTrace();
}
}

private void startConsumer() {
new Thread( new QConsumer() ).start();
}
private void startProducer() {
ImmortalMemory.instance().enter(
new Runnable() {
public void run() {
// Creo PriorityParams y ReleaseParams
PeriodicParameters rel = new PeriodicParameters(
new RelativeTime( 1,0 ));
new NoHeapRealtimeThread(sched, rel, null,
ImmortalMemory.instance(),
null, new QProducer() ).start();
}
});

• WaitFreeReadQueue
– Lector NHRT, Escritor Thread
– Los escritores podría quedar bloqueados
– Implementar escritura segura
• La cola debe ser compartida
• Boligrafo
– Limitar el tamaño de la cola

– Se puede controlar la lectura con
waitForData()
– Es una forma de implementar hilos
aperiódicos
– Con objetos de la cola no compartidos

public static WaitFreeReadQueue queue =
new WaitFreeWriteQueue(5, true);
class QProducer implements Runnable {
public void run() {
for (int i=0; i < 100; i ++) {
String s = "This is msg# " + i;
escribir(s);
try {Thread.sleep(250);} catch (Exception e){}
}
escribir("FIN");
}
}

private void escribir(ﬁnal String msg) {
ImmortalMemory.instance().executeInArea(
new Runnable() {
public void run() {
try {
if ( queue.isFull() )
System.out.println("Productor bloqueado");
queue.write( msg );
} catch ( Exception e ) { }
}
});
}

class QConsumer implements Runnable {
public void run() {
try {
boolean loop = true;
while ( loop ) {
queue.waitForData();
String msg = (String)queue.read();
System.out.println("Leido: "+msg);
loop = ! msg.equalsIgnoreCase("FIN");
}
}
catch ( Exception e ) {
}
}

private void startProducer() {
new Thread( new QProducer() ).start();
}
private void startConsumer() {
ImmortalMemory.instance().enter(
new Runnable() {
public void run() {
// Creo PriorityParams pero no ReleaseParams
new NoHeapRealtimeThread(sched, null, null,
ImmortalMemory.instance(),
null, new QConsumer() ).start();
}
});
}

• Sincronización mediante Clock
– HighResolutionTime.waitForObject()
Object lock = new Object();
Object compartido = null;
RelativeTime timeout = new RelativeTime(10, 0);
synchronized ( lock ) {
// espera a un lock.notify()
lock.wait();
Object cambiado = compartido;
// espera con un timeout
HighResolutionTime.waitForObject(lock, timeout);
}

EventosEventos
• AsyncEvent
– Clase central del control de eventos
• Eventos internos a la JVM
• Eventos externos a la JVM
• Eventos temporales

EventosEventos
• AsyncEventHandler
– Hereda de Schedulable
– Admite parámetros
• SchedulingParameters
• MemoryParameters
– Admite MemoryArea
– Admite no heap

EventosEventos
• Procedimiento
– Asociar uno/varios Handler a un Evento
– Iniciar el Handler
– Los eventos dispararán el método
handleAsyncEvent()
– Modelo de hilo aperiódico/esporádico

EventosEventos
• Eventos Internos
– El AsyncEvent es campo de una clase
– El Handler es externo a ella
– Aunque se puede referenciar como
parámetro del constructor
– Se debe asociar el Handler y el evento
– Se dispara el evento con fire() activando
los Handlers asociados

EventosEventos
class Stock {
public Stock (String s, double v) {
symbol = s;
value = v;
event = new AsyncEvent();
}
public String symbol;
public double value;
public AsyncEvent event;
}

EventosEventos
class Listener extends AsyncEventHandler {
String symbol;
public Listener(String symbol) {
this.symbol = symbol;
}
// Hacer algo para responder
System.out.println("Recibido evento " +
symbol + " desde el hilo " +
RealtimeThread.currentThread().getName());
}
}

EventosEventos
class Generador implements Runnable {
Random random = new Random(System.currentTimeMillis());
public void run() {
while ( true ) {
// Cambio el valor
double factor = random.nextDouble();
if (random.nextBoolean())
change *= -1;
stock.value += change;
// Notify handler(s)
stock.event.ﬁre();
RealtimeThread.waitForNextPeriod();
}
}
}

EventosEventos
Stock stock = new Stock("JAVA", 3.99);
Listener h = new Listener(stock.symbol);
stock.event.addHandler(h);
// Iniciar el generador
ReleaseParameters rel = new PeriodicParameters(
new RelativeTime(500,0));
RealtimeThread rtt = new RealtimeThread(
null, rel, null,
null, null, new Generador() );
rtt.start();
}

EventosEventos
– Se puede separar la lógica del Handler
– En un objeto Runnable
– Al igual que con los RTT
– Y el run() se ejecuta con cada evento

EventosEventos
• Cola de Eventos
– Al disparar un evento se coloca en cola
– Para cada Handler
– Esperando a su ejecución (async)
– Según prioridad
– Se puede comprobar si hay eventos
pendientes en la cola
• getPendingFireCount()
• getAndDecrementPendingFireCount()

EventosEventos
• Eventos de Tiempo
– OneShotTimer
– Ejecutar algo pasado un cierto tiempo
• RelativeTime
– O en un instante y durante un periodo
de tiempo
• AbsoluteTime
– Ascensor que abre las puertas pero
después se cierran

EventosEventos
– OneShotTimer
– Se dispara invocando a un método
– Debe habilitarse e iniciarse para ser
efectivo
• Métodos enable() y start()
public void abrirPuertas() {
OneShotTimer doorTimer = new OneShotTimer(
new RelativeTime(10000, 0), new Manejador());
doorTimer.enable();
doorTimer.start();
}

EventosEventos
– PeriodicTimer
– Invoca al Handler periódicamente
• Instante de inicio e intervalo
– Debe habilitarse e iniciarse para ser
efectivo
– Mínimo 500ns de intervalo
• -DTimerMinInterval=500

EventosEventos
– PeriodicTimer
RelativeTime period = new RelativeTime(10,0);
PeriodicTimer timer = new PeriodicTimer(
period, period, new Manejador());
timer.enable();
timer.start();
}

Control de HilosControl de Hilos
• ATC (Asynchronous Transfer Control)
– Excepciones que permiten propagar un
cambio repentino
– AsynchronouslyInterruptedException
– Se puede disparar por
• Evento asíncrono
• Thread.interrupt()
• AIE.fire()

– Permite alterar la ejecución de un
Schedulable a través de otro
– Cumpliendo algunas reglas:
• ATC no interrumpe bloques synchronized ni
static
• No se garantiza la reanudación
• La excepción debe confirmarse
– doInterrumpible()
– clear()

– Un método "interrumpible" debe
declarar un throws AIE
– Su clase debe implementar Interruptible
– Debe tener un método run(AIE) que se
ejecutará como interrumpible
– Mediante invocación de doInterruptible
– También se puede descartar con clear
– Y un método interruptAction

• Ejemplo
class Altitud extends ControlCentral{
public Altitud(AsynchronouslyInterruptedException aie) {
super("Altitud", aie, new RelativeTime(1000,0),
PriorityScheduler.instance().getMinPriority());
start();
}
public void run(AsynchronouslyInterruptedException aie)
throws AsynchronouslyInterruptedException {
System.out.println("tComprobación de altitud");
// Simulo retardo para ver que se interrumpe
RelativeTime slow = new RelativeTime(250,0);
try { RealtimeThread.sleep(slow); }
catch ( Exception e ) { }
}
}

• Ejemplo
class ControlCentral extends RealtimeThread
implements Interruptible {
public int Mode;
public void run() {
while ( Mode == LANDING_MODE ) {
// Ejecuto código interrumpible run(AIE)
if ( ! aie.doInterruptible(this) ) RealtimeThread.yield();
// Pero no se pueden ejecutar 2 interrumpibles a la vez
else if ( ! isInterrupted() ) waitForNextPeriod();
// Y podría no haberse interrumpido
if ( aie.clear() )
interrupted = true;
}
} }

• Ejemplo
class SensorAterrizaje extends AsyncEventHandler {
AsynchronouslyInterruptedException aie;
public SensorAterrizaje (
AsynchronouslyInterruptedException aie) {
this.aie = aie;
}
System.out.println("Iniciando aterrizaje");
ControlCentral.Mode = TOUCHDOWN_MODE;
aie.ﬁre();
}
}

• Ejemplo
try {
AsynchronouslyInterruptedException aie =
new AsynchronouslyInterruptedException();
Altitud alt = new Altitud(aie);
SensorAterrizaje sensor = new SensorAterrizaje(aie);
AsyncEvent evento = new AsyncEvent();
evento.setHandler(sensor);
// Espero un momento a tocar tierra
RealtimeThread.sleep(5000, 0);
evento.ﬁre();
}catch ( Exception e ) {
}
}

– Interrupción temporizada
– Utilizando el objeto Timed
– Muy similar pero disparado por reloj
RelativeTime interval = new RelativeTime(10000,0);
Interruptible interruptible = new MyInterruptible();
Timed t = new Timed(interval);
t.doInterruptible(interruptible);

• Interrupción Temporizada
class MiOperación implements Interruptible {
// Código a ejecutar dentro de tiempo
System.out.println("SUCCESS");
}
public void interruptAction(
AsynchronouslyInterruptedException aie) {
// Si se consume el tiempo se ejecuta esto
System.out.println("FAILED");
}
}

• Interrupción Temporizada
public class Main extends RealtimeThread {
public void run() {
Timed timed = new Timed(interval);
MiOperación interuptible = new MiOperación();
timed.doInterruptible(interuptible);
}
new Main().start();
}
}

• Terminación de Threads
– Necesidad de matar un hilo
– Dado un cierto evento
– Método interrupt()
– Manejado a través del ATC
– Pero no dispara interruptAction()

class Worker extends RealtimeThread implements Interruptible{
AsynchronouslyInterruptedException aie;
while ( true ) {
System.out.println("Worker doing work...");
}
}
public void run() {
aie.doInterruptible(this);
}
}

Worker w = new Worker();
w.start();
// Simulo una espera
try {
RealtimeThread.sleep(interval);
}catch ( Exception e ) { }
// Termino el hilo de manera forzada
w.interrupt();
System.out.println("Application terminating");
}

SILSIL
• Ravenscar-Java
– http://ravenscar.cs.aau.dk/
– www.cs.york.ac.uk/rts/documents/thesis/jag
– ftp.cs.york.ac.uk/papers/rtspapers/R:Kwon:
• Perfil RTSJ con restricciones de uso
• Fase de inicialización y de misión

Java en Tiempo Real

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (18)

Semelhante a Java en Tiempo Real

Semelhante a Java en Tiempo Real (20)

Mais de Oliver Centeno

Mais de Oliver Centeno (6)

Último

Último (12)

Java en Tiempo Real