Compartiendo tu Conocimiento

Relojes Vectoriales

2011-01-28T23:24:00.001-06:00

Un pequeño ejemplo del manejo de relojes vectoriales, para el curso de sistemas operativos 2, Facultad de Ingenieria, USAC.

Relojes Vectoriales

Un Don Que Hay Que Aprovechar

2010-09-01T17:38:00.002-06:00

Retomando la actividad en el blog...

Todos tenemos un gran potencial, lo unico que tenemos que hacer es utilizarlo.

Dime algo y lo olvidaré, enséñame algo y lo recordaré, pero hazme partícipe de algo y lo aprenderé. (Proverbio Chino)

Mi Animación 3D

2009-11-04T23:49:00.002-06:00

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

2009-10-15T23:11:00.005-06:00

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
NetWare núcleo[4]
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

2009-09-09T21:14:00.004-06:00

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); :}

Codigo de Tres Direcciones Arreglos

2009-09-09T13:58:00.012-06:00

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++; :}

Codigo de Tres Direcciones

2009-09-09T12:46:00.001-06:00

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

Definicion para Expresiones Condicionales Corto Circuito

Se manejaran 2 atributos uno para las etiquetas Verdaderas y Otro pra etiquetas falsas.

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)

Aqui solo se manjea un atributo que contendra el valor falso o verdadero de la condicion

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

2009-09-03T16:41:00.001-06:00

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