• Save
Java en Tiempo Real
Upcoming SlideShare
Loading in...5
×
 

Java en Tiempo Real

on

  • 951 views

 

Statistics

Views

Total Views
951
Views on SlideShare
951
Embed Views
0

Actions

Likes
0
Downloads
0
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

CC Attribution-NonCommercial-NoDerivs LicenseCC Attribution-NonCommercial-NoDerivs LicenseCC Attribution-NonCommercial-NoDerivs License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Java en Tiempo Real Java en Tiempo Real Presentation Transcript

  • 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
  • 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
  • Sistemas de Tiempo RealSistemas de Tiempo Real • ¿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,…
  • Sistemas de Tiempo RealSistemas de Tiempo Real • 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)
  • Sistemas de Tiempo RealSistemas de Tiempo Real • 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
  • Sistemas de Tiempo RealSistemas de Tiempo Real • 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)
  • Sistemas de Tiempo RealSistemas de Tiempo Real • 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
  • Sistemas de Tiempo RealSistemas de Tiempo Real • 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,…
  • Computación en TiempoComputación en Tiempo 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
  • Computación en TiempoComputación en Tiempo RealReal • Restricciones – Recursos limitados • CPU, memoria, controlador de disco,… • Objetos synchronized, Bus,… – Precedencia • Independientemente del número de procesadores – Tiempo de Ejecución
  • Computación en TiempoComputación en Tiempo RealReal • Restricciones
  • Computación en TiempoComputación en Tiempo 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
  • 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
  • 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 – …
  • Java en Tiempo RealJava en Tiempo Real • 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
  • Java en Tiempo RealJava en Tiempo Real • 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
  • Java en Tiempo RealJava en Tiempo Real • Algoritmos para Garbage Collector – Generational • Desfragmentación metódica • Distintas áreas de memoria (generaciones)
  • Java en Tiempo RealJava en Tiempo Real • 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
  • Java en Tiempo RealJava en Tiempo Real • Algoritmos para GC en Java
  • Java en Tiempo RealJava en Tiempo Real • Algoritmos para GC en Java – 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
  • Java en Tiempo RealJava en Tiempo Real • ¿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
  • Java en Tiempo RealJava en Tiempo Real • ¿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 • Manejo de Memoria – ScopedMemory – Creación dinámica – Tamaño configurable – No GC – Método enter() – Conteo de referencias
  • RTSJRTSJ • Manejo de Memoria – ImmortalMemory – Existencia única – Tamaño limitado – Nunca se hace GC – No admite referencias a Scoped – Datos estáticos
  • RTSJRTSJ • Manejo de Memoria – 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
  • 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
  • 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,…
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • Implementaciones de Schedulable – RealtimeThread (RTT) – NoHeapRealtimeThread (NHRT) – AsyncEventHandler (AEH) – BoundAsyncEventHandler (BAEH)
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • Estos objetos Schedulable son manejados por Scheduler • Clase abstracta • Implementación obligatoria • Otras opcionales • PriorityScheduller – Implementa prioridad real – Parámetros de prioridad
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • PriorityParameters – Indica la prioridad del Schedulable – Extiende SchedulingParameters • setSchedulingParameters() • ImportanceParameters – Hereda de PriorityParameters – Actúa ante misma prioridad • setImportance()
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • ReleaseParameters – Indican cada cuanto se va a liberar un Schedulable • setReleaseParameter() • setDeadline() – PeriodicParameters – AperiodicParameters – SporadicParameters
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • ReleaseParameters
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • Ejemplos – PriorityParameters Schedulable rt1 = new RealtimeThread(); int maxPri = PriorityScheduler.instance() .getMaxPriority(); PriorityParameters p = new PriorityParameters(maxPri); rt1.setSchedulingParameters(p);
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • Ejemplos – ImportanceParameters Schedulable rt2 = new RealtimeThread(); int maxPri = PriorityScheduler.instance().getMaxPriority(); ImportanceParameters i1 = new ImportanceParameters(maxPri, 1); rt2.setSchedulingParameters(i1); Schedulable rt3 = new RealtimeThread(); ImportanceParameters i2 = new ImportanceParameters(maxPri, 2); rt3.setSchedulingParameters(i2); // Aumento la importancia de rt2 i1.setImportance(3);
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • Ejemplos – ReleaseParameters RelativeTime milli = new RelativeTime(1,0); ReleaseParameters p = new PeriodicParameters(milli); rt1.setReleaseParameters(p); rt2.setReleaseParameters(p); rt3.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();
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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);
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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) } }
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • RealtimeThread – Parámetros configurables • Prioridad: SchedulingParameters • Periodo: ReleaseParameters • Memoria asignada: MemoryParameters • Contexto de memoria: MemoryArea • … – Distintos constructores – Getters y Setters
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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... } }
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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(); }
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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);
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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){}
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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(); } }
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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(); } }
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • Hilos Periódicos public class ControlTemperatura implements Runnable{ public void run() { boolean ok = waitForNextPeriod(); if(!ok){ System.out.println("Se ha perdido el deadline"); } } }
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • Ejemplo public static void main(String[] args) { // 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(); }
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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(); } }
  • Modelo de Objetos RTSJModelo de Objetos RTSJ • 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
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • Modelo de Memoria 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() ); }
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • Modelo de Memoria – 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); }
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • Modelo de Memoria
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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)
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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'
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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(); } }
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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); waitForNextPeriod(); } }
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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) ); } }
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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; } }
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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) { } }
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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
  • Modelo de Memoria RTSJModelo de Memoria RTSJ • 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()
  • 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
  • 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
  • SincronizaciónSincronización • 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*"); } } } }
  • SincronizaciónSincronización • PriorityInheritance – 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(); }
  • SincronizaciónSincronización • PriorityInheritance – 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
  • SincronizaciónSincronización • 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
  • SincronizaciónSincronización • Acceso a recursos compartidos (II)
  • SincronizaciónSincronización • 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
  • SincronizaciónSincronización • WaitFreeWriteQueue 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"); } }
  • SincronizaciónSincronización • WaitFreeWriteQueue 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(); } }
  • SincronizaciónSincronización • WaitFreeWriteQueue 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(); } });
  • SincronizaciónSincronización • 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
  • SincronizaciónSincronización • WaitFreeReadQueue – Se puede controlar la lectura con waitForData() – Es una forma de implementar hilos aperiódicos – Con objetos de la cola no compartidos
  • SincronizaciónSincronización • WaitFreeReadQueue 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"); } }
  • SincronizaciónSincronización • WaitFreeReadQueue private void escribir(final 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 ) { } } }); }
  • SincronizaciónSincronización • WaitFreeReadQueue 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 ) { e.printStackTrace(); } }
  • SincronizaciónSincronización • WaitFreeReadQueue 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ónSincronización • 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); }
  • 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
  • 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 • ReleaseParameters • 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 • Eventos Internos 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 • Eventos Internos class Listener extends AsyncEventHandler { String symbol; public Listener(String symbol) { this.symbol = symbol; } public void handleAsyncEvent() { // Hacer algo para responder System.out.println("Recibido evento " + symbol + " desde el hilo " + RealtimeThread.currentThread().getName()); } }
  • EventosEventos • Eventos Internos 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.fire(); RealtimeThread.waitForNextPeriod(); } } }
  • EventosEventos • Eventos Internos public static void main(String[] args) { 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 • Eventos Internos – 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 • Eventos de Tiempo – 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 • Eventos de Tiempo – 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 • Eventos de Tiempo – PeriodicTimer public static void main(String[] args) { RelativeTime period = new RelativeTime(10,0); PeriodicTimer timer = new PeriodicTimer( period, period, new Manejador()); timer.enable(); timer.start(); }
  • 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
  • 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()
  • Control de HilosControl de Hilos • ATC (Asynchronous Transfer Control)
  • Control de HilosControl de Hilos • ATC (Asynchronous Transfer Control) – 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()
  • Control de HilosControl de Hilos • ATC (Asynchronous Transfer Control) – 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
  • Control de HilosControl de Hilos • 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 ) { } } }
  • Control de HilosControl de Hilos • 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; } } }
  • Control de HilosControl de Hilos • Ejemplo class SensorAterrizaje extends AsyncEventHandler { AsynchronouslyInterruptedException aie; public SensorAterrizaje ( AsynchronouslyInterruptedException aie) { this.aie = aie; } public void handleAsyncEvent() { System.out.println("Iniciando aterrizaje"); ControlCentral.Mode = TOUCHDOWN_MODE; aie.fire(); } }
  • Control de HilosControl de Hilos • Ejemplo public static void main(String[] args) { 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.fire(); }catch ( Exception e ) { e.printStackTrace(); } }
  • Control de HilosControl de Hilos • ATC (Asynchronous Transfer Control) – 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);
  • Control de HilosControl de Hilos • Interrupción Temporizada class MiOperación implements Interruptible { public void run(AsynchronouslyInterruptedException aie) throws AsynchronouslyInterruptedException { // 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"); } }
  • Control de HilosControl de Hilos • Interrupción Temporizada public class Main extends RealtimeThread { public void run() { RelativeTime interval = new RelativeTime(5000,0); Timed timed = new Timed(interval); MiOperación interuptible = new MiOperación(); timed.doInterruptible(interuptible); } public static void main(String[] args) { new Main().start(); } }
  • Control de HilosControl de Hilos • 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()
  • Control de HilosControl de Hilos • Terminación de Threads class Worker extends RealtimeThread implements Interruptible{ AsynchronouslyInterruptedException aie; public void run(AsynchronouslyInterruptedException aie) throws AsynchronouslyInterruptedException { while ( true ) { System.out.println("Worker doing work..."); waitForNextPeriod(); } } public void run() { aie.doInterruptible(this); } }
  • Control de HilosControl de Hilos • Terminación de Threads public static void main(String[] args) { Worker w = new Worker(); w.start(); // Simulo una espera try { RelativeTime interval = new RelativeTime(3000,0); RealtimeThread.sleep(interval); }catch ( Exception e ) { } // Termino el hilo de manera forzada w.interrupt(); System.out.println("Application terminating"); }
  • 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
  • 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
  • SILSIL • Ravenscar-Java
  • SILSIL • Ravenscar-Java
  • SILSIL • Ravenscar-Java
  • SILSIL • Ravenscar-Java