Bueno, aqui les presento mi animación que realicé en blender, aun toy lejos de pixar pero bueno lo intente XD, espero que les guste
Nucleo Hibrido
jueves, 15 de octubre de 2009
Son fundamentalmente micro núcleos que tienen código no esencial, en el espacio del kernel con el fin de ejecutar este de forma mas rápida de que lo haría si estuviera en espacio de usuario.
Un termino erróneo es comparar el núcleo híbrido con los núcleos monolíticos que pueden cargar módulos después del arranque. El núcleo híbrido nos indica que el núcleo en cuestión usa conceptos de arquitectura o mecanismos tanto del diseño monolítico como el micro núcleo, especialmente el paso de los mensajes y migración de código no esencial para pasarlo al espacio del usuario, pero conservando código no esencial en el espacio del núcleo, para optimizar el rendimiento
Sistemas que utlizan nucléo híbrido:
BeOS núcleo
Haiku núcleo
DEB- basado
DEB de la libélula
XNU núcleo
Plan 9 núcleo
Infierno núcleo
Núcleo del NT
ReactOS núcleo
Núcleo híbrido es una arquitectura basada en la combinación de microkernel y núcleo monolítico, estas arquitecturas son utilizadas dentro de las computadoras por medio de los sistemas operativos
esta categoría, crea diferencias debido a su semejanza al núcleo monolítico, las categorías mas conocidas son nanokernels y exokernels, que no son mas que versiones externas de microkernels.
Una característica especial con que cuenta el núcleo híbrido es que incluyen código extra con el objetivo de mejorar el rendimiento.
Codigo de Tres Direcciones SWITCH
Etiquetas:
COMPILADORES
miércoles, 9 de septiembre de 2009
Hola de nuevo, siguiendo con mi contribucion a temas para segundo parcial del curso compiladores 2, aqui les coloco una nueva traduccion dirigida, esta ves para la sentencia SWITCH - CASE.
Nota: '<'cuerpo'>' cualquier sentencia valida
SW := SWITCH '(' EXP ')' {: LC.cad = EXP.cad; write('goto Comparacion'); :} LC {: write('Comparacion:');
write(LC.text);
write('goto Salida');
write('Salida:') :}
LC := {: LC.cad = LC.cad; :} LC CASE EXP ':' {:write('L', contEtiq, ':'); LC.eti = concat('T', contEtiq); contEtiq++; :} '<'cuerpo'>' {: LC.text = concat(LC.text, 'if', LC.cad, '==', EXP.cad, 'then goto ', LC.eti); :}
| {: LC.cad = LC.cad; :} LC CASE EXP ':' {:write('L', contEtiq, ':'); LC.eti = concat('T', contEtiq); contEtiq++; :} '<'cuerpo'>' 'break' {: write('goto Salida');
LC.text = concat(LC.text, 'if', LC.cad, '==', EXP.cad, 'then goto ', LC.eti); :}
| CASE EXP ':' {:write('L', contEtiq, ':'); LC.eti = concat('T', contEtiq); contEtiq++; :} '<'cuerpo'>' {: LC.text = concat('if', LC.cad, '==', EXP.cad, 'then goto ', LC.eti); :}
| CASE EXP ':' {:write('L', contEtiq, ':'); LC.eti = concat('T', contEtiq); contEtiq++; :} '<'cuerpo'>' 'break' {: write('goto SALIDA');
LC.text = concat('if', LC.cad, '==', EXP.cad, 'then goto ', LC.eti); :}
Nota: '<'cuerpo'>' cualquier sentencia valida
SW := SWITCH '(' EXP ')' {: LC.cad = EXP.cad; write('goto Comparacion'); :} LC {: write('Comparacion:');
write(LC.text);
write('goto Salida');
write('Salida:') :}
LC := {: LC.cad = LC.cad; :} LC CASE EXP ':' {:write('L', contEtiq, ':'); LC.eti = concat('T', contEtiq); contEtiq++; :} '<'cuerpo'>' {: LC.text = concat(LC.text, 'if', LC.cad, '==', EXP.cad, 'then goto ', LC.eti); :}
| {: LC.cad = LC.cad; :} LC CASE EXP ':' {:write('L', contEtiq, ':'); LC.eti = concat('T', contEtiq); contEtiq++; :} '<'cuerpo'>' 'break' {: write('goto Salida');
LC.text = concat(LC.text, 'if', LC.cad, '==', EXP.cad, 'then goto ', LC.eti); :}
| CASE EXP ':' {:write('L', contEtiq, ':'); LC.eti = concat('T', contEtiq); contEtiq++; :} '<'cuerpo'>' {: LC.text = concat('if', LC.cad, '==', EXP.cad, 'then goto ', LC.eti); :}
| CASE EXP ':' {:write('L', contEtiq, ':'); LC.eti = concat('T', contEtiq); contEtiq++; :} '<'cuerpo'>' 'break' {: write('goto SALIDA');
LC.text = concat('if', LC.cad, '==', EXP.cad, 'then goto ', LC.eti); :}
Codigo de Tres Direcciones Arreglos
Etiquetas:
COMPILADORES
Un saludo a todos de nuevo en esta publicacion generaremos una definicion dirigida por la sintaxis para lo que son arreglos, pero para hacerlo un poco mas amplio sera para arreglos de arreglos, con un maximo de dos dimensiones, para la sentencias de asignacion
NOTA: seguimos asumiendo que la traduccion de EXP para representaciones numericas ya la tenemos, aunque en esta gramatica agregaremos la parte de los arreglos.
Los bloques de los arreglos los tomaremos como filas y luego columnas. Array[f, c]
ASIG := ID '=' EXP {: write(ID, ' = ', EXP1.cad); :}
| ID {: DIM.id = ID; :} DIM '=' EXP {: write(ID, '[', DIM1.cad, '] = ', EXP1.cad); :}
DIM := {: DIM.id = DIM.id :} DIM '[' {: AR.id = DIM1.id :} AR ']' {: write('T', contTemp, '=', DIM1.cad, '- 1');
contTemp++;
write('T', contTemp, '= T', contTemp - 1, '*', tamanioBloque(id, 2); //metodo que devuelve el tamanio del primer bloque
contTemp++;
write('T', contTemp, '= T', contTemp - 1, '+', AR1.cad);
DIM.cad = concat('T', contTemp);
contTemp++;
:}
| '[' AR ']' {: DIM.cad = AR1.cad:}
AR := {: AR.id = AR.id; :} AR , EXP {: write('T', contTemp, '=', AR1.cad, '- 1');
contTemp++;
write('T', contTemp, '= T', contTemp - 1, '*', tamanioBloque(id, 1);//metodo que devuelve el tamanio de las filas
contTemp++;
write('T', contTemp, '= T', contTemp - 1, '+', EXP1.cad);
AR.cad = concat('T', contTemp);
contTemp++;
:}
| EXP {: AR.cad = EXP1.cad:}
EXP := EXP '*' EXP
| EXP '/' EXP
| EXP '+' EXP
| EXP '-' EXP
| '(' EXP ')'
| NUMERO
| ID
| ID {: DIM.id = ID; :} DIM {:write('T', contTemp, '=', ID, '[', DIM1.cad, ']');
EXP.cad = concat('T', contTemp);
contTemp++; :}
NOTA: seguimos asumiendo que la traduccion de EXP para representaciones numericas ya la tenemos, aunque en esta gramatica agregaremos la parte de los arreglos.
Los bloques de los arreglos los tomaremos como filas y luego columnas. Array[f, c]
ASIG := ID '=' EXP {: write(ID, ' = ', EXP1.cad); :}
| ID {: DIM.id = ID; :} DIM '=' EXP {: write(ID, '[', DIM1.cad, '] = ', EXP1.cad); :}
DIM := {: DIM.id = DIM.id :} DIM '[' {: AR.id = DIM1.id :} AR ']' {: write('T', contTemp, '=', DIM1.cad, '- 1');
contTemp++;
write('T', contTemp, '= T', contTemp - 1, '*', tamanioBloque(id, 2); //metodo que devuelve el tamanio del primer bloque
contTemp++;
write('T', contTemp, '= T', contTemp - 1, '+', AR1.cad);
DIM.cad = concat('T', contTemp);
contTemp++;
:}
| '[' AR ']' {: DIM.cad = AR1.cad:}
AR := {: AR.id = AR.id; :} AR , EXP {: write('T', contTemp, '=', AR1.cad, '- 1');
contTemp++;
write('T', contTemp, '= T', contTemp - 1, '*', tamanioBloque(id, 1);//metodo que devuelve el tamanio de las filas
contTemp++;
write('T', contTemp, '= T', contTemp - 1, '+', EXP1.cad);
AR.cad = concat('T', contTemp);
contTemp++;
:}
| EXP {: AR.cad = EXP1.cad:}
EXP := EXP '*' EXP
| EXP '/' EXP
| EXP '+' EXP
| EXP '-' EXP
| '(' EXP ')'
| NUMERO
| ID
| ID {: DIM.id = ID; :} DIM {:write('T', contTemp, '=', ID, '[', DIM1.cad, ']');
EXP.cad = concat('T', contTemp);
contTemp++; :}
Codigo de Tres Direcciones
Etiquetas:
COMPILADORES
Un saludo a todos, bueno esta entrada esta destinada para los compañeros y amigos que necesiten una pequeña ayuda para su segundo parcial de Compiladores 2 :s Espero les pueda ayudar en algo.
Nota: EXP sera para la parte de las expresiones numericas que todos conocemos.
contEtiq sera el contador para el control de las etiquetas
contTemp sera el contador para el control de los temporales
COND := COND 'AND' {: write(COND1.verdadero, ':'); :} COND {:
COND.verdadero = COND2.verdadero;
COND.falso = concat(COND1.falso, ':', COND2.falso); :}
| COND 'OR' {: write(COND1.falso, ':'); :} COND {:
COND.verdadero = concat(COND1.verdadero, ':', COND2.verdadero);
COND.falso = COND2.falso; :}
| 'NOT' COND {: COND.verdadero = COND1.falso;
COND.falso = COND1.verdadero; :}
| '(' COND ')' {: COND.verdadero = COND1.verdadero;
COND.falso = COND1.falso; :}
| EXP '<' EXP {: write('if', EXP1.cad, '<', EXP2.cad, 'then goto L', contEtiq); COND.verdadero = concat('L', contEtiq); contEtiq++; write('goto L', contEtiq); COND.falso = concat ('L', contEtiq); contEti++; :}
| EXP '>' EXP {: write('if', EXP1.cad, '>', EXP2.cad, 'then goto L', contEtiq);
COND.verdadero = concat('L', contEtiq);
contEtiq++;
write('goto L', contEtiq);
COND.falso = concat ('L', contEtiq);
contEti++; :}
| EXP '==' EXP {: write('if', EXP1.cad, '==', EXP2.cad, 'then goto L', contEtiq);
COND.verdadero = concat('L', contEtiq);
contEtiq++;
write('goto L', contEtiq);
COND.falso = concat ('L', contEtiq);
contEti++; :}
| EXP '!=' EXP {: write('if', EXP1.cad, '!=', EXP2.cad, 'then goto L', contEtiq);
COND.verdadero = concat('L', contEtiq);
contEtiq++;
write('goto L', contEtiq);
COND.falso = concat ('L', contEtiq);
contEti++; :}
Para los siguientes ejemplos el codigo que genera:
a '<' b AND c '>' e
if a'<'b then goto L1 L1: goto L2 if c'>'e then goto L3
goto L4
al terminar la etiqueta verdadera seria L3 y las falsas L2 y L4.
a '<' b OR c '>' e
if a'<'b then goto L1 L2: goto L2 if c'>'e then goto L3
goto L4
al terminar las etiqueta verdadera seria L1 y L3 y la falsa L4.
COND := COND 'AND' COND {: write('T', contTemp, '=', COND1.temp, 'AND', COND2.temp);
COND.temp = concat('T', contTemp);
contTemp++; :}
| COND 'OR' COND {: write('T', contTemp, '=', COND1.temp, 'OR', COND2.temp);
COND.temp = concat('T', contTemp);
contTemp++; :}
| 'NOT' COND {: write(COND1.temp, '= NOT', COND1.temp);
COND.temp = COND1.temp;
:}
| '(' COND ')' {: COND.temp = COND1.temp; :}
| EXP '<' EXP {: write('if', EXP1.cad, '<', EXP2.cad, 'then goto L', contEtiq); write('T', contTemp, '= false'); contEtiq++; write('goto L' + contEtiq); write('L', contEtiq-1, ':'); write('T', contTemp, '= true'); write('L', contEtiq, ':'); COND.temp = concat('T', contTemp); contTemp++; :}
| EXP '>' EXP {: write('if', EXP1.cad, '>', EXP2.cad, 'then goto L', contEtiq);
write('T', contTemp, '= false');
contEtiq++;
write('goto L' + contEtiq);
write('L', contEtiq-1, ':');
write('T', contTemp, '= true');
write('L', contEtiq, ':');
COND.temp = concat('T', contTemp);
contTemp++;
:}
| EXP '==' EXP {: write('if', EXP1.cad, '==', EXP2.cad, 'then goto L', contEtiq);
write('T', contTemp, '= false');
contEtiq++;
write('goto L' + contEtiq);
write('L', contEtiq-1, ':');
write('T', contTemp, '= true');
write('L', contEtiq, ':');
COND.temp = concat('T', contTemp);
contTemp++;
:}
| EXP '!=' EXP {: write('if', EXP1.cad, '!=', EXP2.cad, 'then goto L', contEtiq);
write('T', contTemp, '= false');
contEtiq++;
write('goto L' + contEtiq);
write('L', contEtiq-1, ':');
write('T', contTemp, '= true');
write('L', contEtiq, ':');
COND.temp = concat('T', contTemp);
contTemp++;
:}
Para los siguientes ejemplos el codigo que genera:
a '<' b AND c '>' e
if a'<'b then goto L1 T1 = false goto L2 L1: T1 = true L2: if c'>'e then goto L3
T2 = false
goto L4
L3:
T2 = false
L4:
T3 = T1 AND T2
Al terminar el tempororal T3 tendra el resultado de la condicion
a '<' b OR c '>' e
if a'<'b then goto L1 T1 = false goto L2 L1: T1 = true L2: if c'>'e then goto L3
T2 = false
goto L4
L3:
T2 = false
L4:
T3 = T1 OR T2
Al terminar el tempororal T3 tendra el resultado de la condicion
Bueno Espero que les sirva de algo, mas tarde les subo una para generar codigo de tres direcciones de arreglos, saludos...
Nota: EXP sera para la parte de las expresiones numericas que todos conocemos.
contEtiq sera el contador para el control de las etiquetas
contTemp sera el contador para el control de los temporales
- Definicion para Expresiones Condicionales Corto Circuito
COND := COND 'AND' {: write(COND1.verdadero, ':'); :} COND {:
COND.verdadero = COND2.verdadero;
COND.falso = concat(COND1.falso, ':', COND2.falso); :}
| COND 'OR' {: write(COND1.falso, ':'); :} COND {:
COND.verdadero = concat(COND1.verdadero, ':', COND2.verdadero);
COND.falso = COND2.falso; :}
| 'NOT' COND {: COND.verdadero = COND1.falso;
COND.falso = COND1.verdadero; :}
| '(' COND ')' {: COND.verdadero = COND1.verdadero;
COND.falso = COND1.falso; :}
| EXP '<' EXP {: write('if', EXP1.cad, '<', EXP2.cad, 'then goto L', contEtiq); COND.verdadero = concat('L', contEtiq); contEtiq++; write('goto L', contEtiq); COND.falso = concat ('L', contEtiq); contEti++; :}
| EXP '>' EXP {: write('if', EXP1.cad, '>', EXP2.cad, 'then goto L', contEtiq);
COND.verdadero = concat('L', contEtiq);
contEtiq++;
write('goto L', contEtiq);
COND.falso = concat ('L', contEtiq);
contEti++; :}
| EXP '==' EXP {: write('if', EXP1.cad, '==', EXP2.cad, 'then goto L', contEtiq);
COND.verdadero = concat('L', contEtiq);
contEtiq++;
write('goto L', contEtiq);
COND.falso = concat ('L', contEtiq);
contEti++; :}
| EXP '!=' EXP {: write('if', EXP1.cad, '!=', EXP2.cad, 'then goto L', contEtiq);
COND.verdadero = concat('L', contEtiq);
contEtiq++;
write('goto L', contEtiq);
COND.falso = concat ('L', contEtiq);
contEti++; :}
Para los siguientes ejemplos el codigo que genera:
a '<' b AND c '>' e
if a'<'b then goto L1 L1: goto L2 if c'>'e then goto L3
goto L4
al terminar la etiqueta verdadera seria L3 y las falsas L2 y L4.
a '<' b OR c '>' e
if a'<'b then goto L1 L2: goto L2 if c'>'e then goto L3
goto L4
al terminar las etiqueta verdadera seria L1 y L3 y la falsa L4.
- Definicion para Expresiones Condicionales Valores Numericos (No Corto Circuito)
COND := COND 'AND' COND {: write('T', contTemp, '=', COND1.temp, 'AND', COND2.temp);
COND.temp = concat('T', contTemp);
contTemp++; :}
| COND 'OR' COND {: write('T', contTemp, '=', COND1.temp, 'OR', COND2.temp);
COND.temp = concat('T', contTemp);
contTemp++; :}
| 'NOT' COND {: write(COND1.temp, '= NOT', COND1.temp);
COND.temp = COND1.temp;
:}
| '(' COND ')' {: COND.temp = COND1.temp; :}
| EXP '<' EXP {: write('if', EXP1.cad, '<', EXP2.cad, 'then goto L', contEtiq); write('T', contTemp, '= false'); contEtiq++; write('goto L' + contEtiq); write('L', contEtiq-1, ':'); write('T', contTemp, '= true'); write('L', contEtiq, ':'); COND.temp = concat('T', contTemp); contTemp++; :}
| EXP '>' EXP {: write('if', EXP1.cad, '>', EXP2.cad, 'then goto L', contEtiq);
write('T', contTemp, '= false');
contEtiq++;
write('goto L' + contEtiq);
write('L', contEtiq-1, ':');
write('T', contTemp, '= true');
write('L', contEtiq, ':');
COND.temp = concat('T', contTemp);
contTemp++;
:}
| EXP '==' EXP {: write('if', EXP1.cad, '==', EXP2.cad, 'then goto L', contEtiq);
write('T', contTemp, '= false');
contEtiq++;
write('goto L' + contEtiq);
write('L', contEtiq-1, ':');
write('T', contTemp, '= true');
write('L', contEtiq, ':');
COND.temp = concat('T', contTemp);
contTemp++;
:}
| EXP '!=' EXP {: write('if', EXP1.cad, '!=', EXP2.cad, 'then goto L', contEtiq);
write('T', contTemp, '= false');
contEtiq++;
write('goto L' + contEtiq);
write('L', contEtiq-1, ':');
write('T', contTemp, '= true');
write('L', contEtiq, ':');
COND.temp = concat('T', contTemp);
contTemp++;
:}
Para los siguientes ejemplos el codigo que genera:
a '<' b AND c '>' e
if a'<'b then goto L1 T1 = false goto L2 L1: T1 = true L2: if c'>'e then goto L3
T2 = false
goto L4
L3:
T2 = false
L4:
T3 = T1 AND T2
Al terminar el tempororal T3 tendra el resultado de la condicion
a '<' b OR c '>' e
if a'<'b then goto L1 T1 = false goto L2 L1: T1 = true L2: if c'>'e then goto L3
T2 = false
goto L4
L3:
T2 = false
L4:
T3 = T1 OR T2
Al terminar el tempororal T3 tendra el resultado de la condicion
Bueno Espero que les sirva de algo, mas tarde les subo una para generar codigo de tres direcciones de arreglos, saludos...
Sistemas Operativos de Tiempo Real
Etiquetas:
Sistemas Operativos
jueves, 3 de septiembre de 2009
Al hablar de un sistema operativo de tiempo real, conocido por sus siglas en ingres RTOS –Real Time Operrating System-, nos referimos a que este ha sido desarrollado para aplicaciones que funcionan en tiempo real. Debito a esto, el sistema operativo es exigido en sus respuestas que tienen restricción del tiempo (muy corto). A este tipo de sistemas se les denomina Determinísticos, debido a que el tiempo requerido para la realización de las actividades es predecible, esto con el objetivo de asegurar su funcionamiento, caso contrario el sistema operativo no tendría razón de ser y como consecuencia se catalogaría como fallido.
Otro término que surge al referirnos a sistemas operativos de tiempo real, son aquellos sistemas en donde el usuario no tiene importancia, si no, le importancia total esta destinada a los procesos. Frecuentemente todos los procesos que administra este tipo de sistemas operativos, están subutilizando sus recursos con el objetivo de que puedan tomarlos en el momento que se requieran sin la necesidad de esperar por ellos.
Clases de RTOS
· Tiempo real estricto (Hard Real Time): sus procesos deben ejecutarse en un tiempo específico.
· Tiempo real flexible (Soft Real Time): al ejecutar sus procesos pueden perderse instantes despreciables algunas veces, pero en el transcurso del tiempo estos tiempos deben ser cada vez menores.
· Tiempo real firme (Firm Real Time): en este tipo pueden perderse tiempos, pero las respuestas tardías no tendrán validez.
Los sistemas Operativos de Tiempo Real son aplicados en diversas áreas:
· Control de trenes.
· Control de tráfico aéreo
· Bolsas de valores
· Control de refinerías
· Control de laminadores
· Control de trafico
· Controles electrónicos
· Telecomunicaciones.
· Sistemas de fabricación integrada.
· Producción y distribución de energía eléctrica.
· Control de edificios.
· Sistemas multimedia.
Algunos Ejemplos de Sistemas Operativos que Trabajan en Tiempo Real:
· QNX
· LynxOS
· RedHat Embedded Linux
· eCos (Linux)
· SOOS
· Ubuntu Studio (Linux)
· VxWorks
· Windows CE
· Linchos
· UNIX (Some)
Características de los Sistemas Operativos en Tiempo Real
Un RTOS para ser considerado como tal debe atender cinco áreas especificas:
Se caracterizan por presentar requisitos especiales en cinco áreas generales:
· Determinismo: cuanto tiempo consume un SO en reconocer una interrupción.
· Sensibilidad: cuanto tiempo consume un SO en dar servicio a la interrupción después de reconocerla.
o La cantidad de tiempo necesario para iniciar la gestión de la interrupción y comenzar la ejecución de su rutina de tratamiento (ISR, interrupt service routine).
o La cantidad de tiempo necesario para ejecutar la ISR. Generalmente, depende de la plataforma del hardware.
o El efecto del tratamiento de interrupciones. El servicio se retrasara si una ISR puede ser interrumpida por la llegada de otra interrupción.
· Control del usuario: es primordial que el usuario posea un control preciso sobre la prioridad de las tareas.
· Fiabilidad: en estos tipos de sistemas una falla puede ser catastrófica, asi que no pueden permitirse como en los sistemas normales.
· Tolerancia a los fallos: el sistema en todo momento debe ser estable, y en caso no puede atender todas sus tareas debe atender las mas criticas y con mayor prioridad.
Para cumplir los requisitos anteriores los sistemas operativos actuales en tiempo real incluyen normalmente las siguientes características:
· Cambios rápidos de procesos o hilos.
· Pequeño tamaño (con una mínima funcionalidad asociada).
· Capacidad de responder rápidamente a interrupciones externas.
· Multitarea con herramientas de comunicación entre procesos, como semáforos, señales y sucesos.
· Uso de archivos secuénciales especiales que puedan acumular datos a alta velocidad.
· Planificación preferente basadas en prioridades.
· Reducción de intervalos en los que están inhabilitadas las interrupciones.
· Primitivas para demorar tareas durante un tiempo fijo y para detenerlas y reanudarlas.
· Alarmas especiales y temporizadores.
Arquitectura de un sistema operativo de tiempo real
Los RTOS tienen como objetivo principal reducir la latencia y el jitter en las interrupciones, tanto internas como externas, al orden de microsegundos.
El procesamiento de interrupciones en el kernel estándar esta divido en 2 tareas.
· Una que se encarga de la lectura de los dispositivos físicos y escribir los datos a un buffer, esta tarea es conocida como administrador de interrupciones.
· La otra tarea está encargada de la lectura de los datos del buffer a otro buffer con la finalidad de que sean accedidos desde el kernel.
Hoy en dia se manejan dos tipos de diseño para manejar las interrupciones:
· Atención prioritaria en el kernel estándar (Preemptable kernel)
· Modificaciones sobre el kernel estándar (Patch)
Lecturas Recomendadas
http://www.realtimelinuxfoundation.org/
http://www.linuxdevices.com/articles/AT8073314981.html/
http://www.fact-index.com/r/re/real_time_operating_system.html
http://www.se.rit.edu/~jrv/research/RT_Embedded.html
http://www.linuxworld.com/story/34335.htm
http://www.redsonic.com/products/real-time.htm
http://linuxdevices.com/articles/AT4627965573.html
http://www.linuxdevices.com/articles/AT4503827066.html
http://www.linuxdevices.com/articles/AT7005360270.html
http://www.linuxdevices.com/articles/AT5709748392.html
http://www.mnis.fr/opensource/ocera/rtos/
Documentos Relacionados
http://tornasol.datsi.fi.upm.es/ciclope/doc/rtos/cache/doc/embeddedlinux.ppt
http://tornasol.datsi.fi.upm.es/ciclope/doc/rtos/cache/doc/linux_as_rtos.pdf
http://tornasol.datsi.fi.upm.es/ciclope/doc/rtos/cache/doc/realtimelinuxreport.pdf
Referencias Bibliográficas
http://dialnet.unirioja.es/servlet/articulo?codigo=495644
http://www.monografias.com/trabajos5/sisop/sisop.shtml
http://www-gti.det.uvigo.es/~pedro/pub/sodtr/
http://es.wikipedia.org/wiki/Sistema_operativo_de_tiempo_real
http://exa.unne.edu.ar/depar/areas/informatica/SistemasOperativos/MonogSO/PLAPRO02_archivos/caracteristicas_de_los_s.o._en_t.r.htm
Otro término que surge al referirnos a sistemas operativos de tiempo real, son aquellos sistemas en donde el usuario no tiene importancia, si no, le importancia total esta destinada a los procesos. Frecuentemente todos los procesos que administra este tipo de sistemas operativos, están subutilizando sus recursos con el objetivo de que puedan tomarlos en el momento que se requieran sin la necesidad de esperar por ellos.
Clases de RTOS
· Tiempo real estricto (Hard Real Time): sus procesos deben ejecutarse en un tiempo específico.
· Tiempo real flexible (Soft Real Time): al ejecutar sus procesos pueden perderse instantes despreciables algunas veces, pero en el transcurso del tiempo estos tiempos deben ser cada vez menores.
· Tiempo real firme (Firm Real Time): en este tipo pueden perderse tiempos, pero las respuestas tardías no tendrán validez.
Los sistemas Operativos de Tiempo Real son aplicados en diversas áreas:
· Control de trenes.
· Control de tráfico aéreo
· Bolsas de valores
· Control de refinerías
· Control de laminadores
· Control de trafico
· Controles electrónicos
· Telecomunicaciones.
· Sistemas de fabricación integrada.
· Producción y distribución de energía eléctrica.
· Control de edificios.
· Sistemas multimedia.
Algunos Ejemplos de Sistemas Operativos que Trabajan en Tiempo Real:
· QNX
· LynxOS
· RedHat Embedded Linux
· eCos (Linux)
· SOOS
· Ubuntu Studio (Linux)
· VxWorks
· Windows CE
· Linchos
· UNIX (Some)
Características de los Sistemas Operativos en Tiempo Real
Un RTOS para ser considerado como tal debe atender cinco áreas especificas:
Se caracterizan por presentar requisitos especiales en cinco áreas generales:
· Determinismo: cuanto tiempo consume un SO en reconocer una interrupción.
· Sensibilidad: cuanto tiempo consume un SO en dar servicio a la interrupción después de reconocerla.
o La cantidad de tiempo necesario para iniciar la gestión de la interrupción y comenzar la ejecución de su rutina de tratamiento (ISR, interrupt service routine).
o La cantidad de tiempo necesario para ejecutar la ISR. Generalmente, depende de la plataforma del hardware.
o El efecto del tratamiento de interrupciones. El servicio se retrasara si una ISR puede ser interrumpida por la llegada de otra interrupción.
· Control del usuario: es primordial que el usuario posea un control preciso sobre la prioridad de las tareas.
· Fiabilidad: en estos tipos de sistemas una falla puede ser catastrófica, asi que no pueden permitirse como en los sistemas normales.
· Tolerancia a los fallos: el sistema en todo momento debe ser estable, y en caso no puede atender todas sus tareas debe atender las mas criticas y con mayor prioridad.
Para cumplir los requisitos anteriores los sistemas operativos actuales en tiempo real incluyen normalmente las siguientes características:
· Cambios rápidos de procesos o hilos.
· Pequeño tamaño (con una mínima funcionalidad asociada).
· Capacidad de responder rápidamente a interrupciones externas.
· Multitarea con herramientas de comunicación entre procesos, como semáforos, señales y sucesos.
· Uso de archivos secuénciales especiales que puedan acumular datos a alta velocidad.
· Planificación preferente basadas en prioridades.
· Reducción de intervalos en los que están inhabilitadas las interrupciones.
· Primitivas para demorar tareas durante un tiempo fijo y para detenerlas y reanudarlas.
· Alarmas especiales y temporizadores.
Arquitectura de un sistema operativo de tiempo real
Los RTOS tienen como objetivo principal reducir la latencia y el jitter en las interrupciones, tanto internas como externas, al orden de microsegundos.
El procesamiento de interrupciones en el kernel estándar esta divido en 2 tareas.
· Una que se encarga de la lectura de los dispositivos físicos y escribir los datos a un buffer, esta tarea es conocida como administrador de interrupciones.
· La otra tarea está encargada de la lectura de los datos del buffer a otro buffer con la finalidad de que sean accedidos desde el kernel.
Hoy en dia se manejan dos tipos de diseño para manejar las interrupciones:
· Atención prioritaria en el kernel estándar (Preemptable kernel)
· Modificaciones sobre el kernel estándar (Patch)
Lecturas Recomendadas
http://www.realtimelinuxfoundation.org/
http://www.linuxdevices.com/articles/AT8073314981.html/
http://www.fact-index.com/r/re/real_time_operating_system.html
http://www.se.rit.edu/~jrv/research/RT_Embedded.html
http://www.linuxworld.com/story/34335.htm
http://www.redsonic.com/products/real-time.htm
http://linuxdevices.com/articles/AT4627965573.html
http://www.linuxdevices.com/articles/AT4503827066.html
http://www.linuxdevices.com/articles/AT7005360270.html
http://www.linuxdevices.com/articles/AT5709748392.html
http://www.mnis.fr/opensource/ocera/rtos/
Documentos Relacionados
http://tornasol.datsi.fi.upm.es/ciclope/doc/rtos/cache/doc/embeddedlinux.ppt
http://tornasol.datsi.fi.upm.es/ciclope/doc/rtos/cache/doc/linux_as_rtos.pdf
http://tornasol.datsi.fi.upm.es/ciclope/doc/rtos/cache/doc/realtimelinuxreport.pdf
Referencias Bibliográficas
http://dialnet.unirioja.es/servlet/articulo?codigo=495644
http://www.monografias.com/trabajos5/sisop/sisop.shtml
http://www-gti.det.uvigo.es/~pedro/pub/sodtr/
http://es.wikipedia.org/wiki/Sistema_operativo_de_tiempo_real
http://exa.unne.edu.ar/depar/areas/informatica/SistemasOperativos/MonogSO/PLAPRO02_archivos/caracteristicas_de_los_s.o._en_t.r.htm
Suscribirse a:
Entradas (Atom)