Tema 5. Software y sistemas operativos

Computadores y Comunicaciones
Tema 5: Software y sistemas operativos
Febrero, 2011
Jorge Juan Chico <jjchico@dte.us.es>, Julián Viejo Cortés <julian@dte.us.es>
Departamento de Tecnología Electrónica
Universidad de Sevilla
Usted es libre de copiar, distribuir y comunicar públicamente la obra y de hacer obras derivadas siempre que
se cite la fuente y se respeten las condiciones de la licencia Attribution-Share alike de Creative Commons.
Puede consultar el texto completo de la licencia en http://creativecommons.org/licenses/by-sa/3.0/
Objetivos
Conocer el tipo de instrucciones que ejecuta la CPU de un
ordenador
Comprender los procesos de compilación y ensamblado de los
programas de ordenador
Conocer la forma en que se organiza el software para crear
programas complejos
Conocer las funciones de los sistemas operativos bajo la
perspectiva de los distintos tipos de usuarios
Conocer la evolución histórica de los sistemas operativos y
relacionarla con los cambios en la forma de usar el ordenador
Conocer los tipos de tareas principales que realiza un sistema
operativo moderno
2
Contenidos
Lenguaje máquina y ensamblador
Jerarquía del software
–
Sistema operativo. Bibliotecas. Aplicaciones.
Funciones del sistema operativo
–
Para el usuario. Para el programador.
Tareas del sistema operativo
–
Evolución. Gestión de procesos. Gestión de memoria. Gestión de
E/S
3
Lenguaje máquina y ensamblador
Lenguaje (código) máquina: código binario de las instrucciones
que ejecuta la CPU
Lenguaje ensamblador: representación del lenguaje máquina
mediante palabras clave fáciles de entender para el
programador
Ensamblador
mov
mov
mov
mov
mov
mov
top:
top: add
add
add
add
dec
dec
jnz
jnz
done:
done: mov
mov
eax,
eax, 44
ebx,
ebx, 00
ecx,
ecx, xx
ebx,
ebx, [ecx]
[ecx]
ecx,
ecx, 44
eax
eax
top
top
[sum],
[sum], ebx
ebx
Código máquina
000000b0
000000b0
000000b5
000000b5
000000ba
000000ba
000000bf
000000bf
000000c2
000000c2
000000c5
000000c5
000000c7
000000c7
000000c9
000000c9
b804000000
b804000000
bb00000000
bb00000000
b9d0006000
b9d0006000
670319
670319
83c104
83c104
ffc8
ffc8
75f6
75f6
891c25e0006000
891c25e0006000
4
Lenguaje ensamblador
Ejemplo
;; ejemplo
ejemplo introductorio;
introductorio; suma
suma los
los números
números de
de una
una lista
lista
SECTION
SECTION .data
.data
global
global xx
x:
x:
dd
dd
dd
dd
dd
dd
dd
dd
sum:
sum:
dd
dd
;; comienzo
comienzo del
del segmento
segmento de
de datos
datos
11
55
22
18
18
00
SECTION
SECTION .text
.text
;; comienzo
comienzo del
del segmento
segmento de
de código
código
mov
mov eax,
eax, 44
mov
mov ebx,
ebx, 00
mov
mov ecx,
ecx, xx
top:
top: add
add
add
add
dec
dec
jnz
jnz
done:
done: mov
mov
ebx,
ebx, [ecx]
[ecx]
ecx,
ecx, 44
eax
eax
top
top
[sum],
[sum], ebx
ebx
;;
;;
;;
;;
;;
EAX
EAX servirá
servirá de
de contador
contador para
para el
el
número
número de
de datos
datos que
que quedan
quedan por
por sumar
sumar
EBX
EBX almacenará
almacenará la
la suma
suma
ECX
ECX apunta
apunta al
al siguiente
siguiente elemento
elemento
aa sumar
sumar
;;
;;
;;
;;
mueve
mueve el
el puntero
puntero al
al siguiente
siguiente elemento
elemento
decrementa
decrementa el
el contador
contador
si
si el
el contador
contador no
no es
es 0,
0, repetir
repetir
hecho,
hecho, almacena
almacena el
el resultado
resultado en
en [sum]
[sum]
5
http://heather.cs.ucdavis.edu/~matloff/50/LinuxAssembly.html
Compiladores
suma2.c
#include
#include <stdio.h>
<stdio.h>
int
int main(void)
main(void)
{{
int
int x[]
x[] == {1,
{1, 5,
5, 2,
2, 18};
18};
int
int cont
cont == 4;
4;
int
int sum
sum == 0;
0;
int
int ii == 0;
0;
while
while (cont
(cont >> 0)
0)
{{
sum
=
sum
+
sum = sum + x[i];
x[i];
i++;
i++;
cont--;
cont--;
}}
printf("sum
printf("sum == %d\n",
%d\n", sum);
sum);
}}
Compilador
suma2.o
0:
0:
4:
4:
7:
7:
a:
a:
b:
b:
d:
d:
e:
e:
11:
11:
18:
18:
1f:
1f:
26:
26:
2d:
2d:
34:
34:
3b:
3b:
42:
42:
44:
44:
47:
47:
4b:
4b:
4e:
4e:
51:
51:
54:
54:
58:
58:
5a:
5a:
5d:
5d:
61:
61:
68:
68:
6d:
6d:
70:
70:
71:
71:
72:
72:
75:
75:
8d
8d 4c
4c 24
24 04
04
83
83 e4
e4 f0
f0
ff
71
fc
ff 71 fc
55
55
89
89 e5
e5
51
51
83
83 ec
ec 34
34
c7
c7 45
45 e0
e0 01
01 00
00 00
00 00
00
c7
45
c7 45 e4
e4 05
05 00
00 00
00 00
00
c7
45
e8
02
00
00
00
c7 45 e8 02 00 00 00
c7
c7 45
45 ec
ec 12
12 00
00 00
00 00
00
c7
c7 45
45 f0
f0 04
04 00
00 00
00 00
00
c7
c7 45
45 f4
f4 00
00 00
00 00
00 00
00
c7
c7 45
45 f8
f8 00
00 00
00 00
00 00
00
eb
eb 10
10
8b
8b 45
45 f8
f8
8b
8b 44
44 85
85 e0
e0
01
01 45
45 f4
f4
ff
ff 45
45 f8
f8
ff
ff 4d
4d f0
f0
83
83 7d
7d f0
f0 00
00
7f
ea
7f ea
8b
8b 45
45 f4
f4
89
89 44
44 24
24 04
04
c7
c7 04
04 24
24 00
00 00
00 00
00 00
00
e8
fc
ff
e8 fc ff ff
ff ff
ff
83
83 c4
c4 34
34
59
59
5d
5d
8d
8d 61
61 fc
fc
c3
c3
lea
lea
and
and
push
push
push
push
mov
mov
push
push
sub
sub
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
jmp
jmp
mov
mov
mov
mov
add
add
inc
inc
dec
dec
cmp
cmp
jg
jg
mov
mov
mov
mov
mov
mov
call
call
add
add
pop
pop
pop
pop
lea
lea
ret
ret
ecx,[esp+4]
ecx,[esp+4]
esp,0xfffffff0
esp,0xfffffff0
DWORD
DWORD PTR
PTR [ecx-4]
[ecx-4]
ebp
ebp
ebp,esp
ebp,esp
ecx
ecx
esp,0x34
esp,0x34
DWORD
DWORD PTR
PTR [ebp-32],0x1
[ebp-32],0x1
DWORD
DWORD PTR
PTR [ebp-28],0x5
[ebp-28],0x5
DWORD
PTR
[ebp-24],0x2
DWORD PTR [ebp-24],0x2
DWORD
DWORD PTR
PTR [ebp-20],0x12
[ebp-20],0x12
DWORD
DWORD PTR
PTR [ebp-16],0x4
[ebp-16],0x4
DWORD
DWORD PTR
PTR [ebp-12],0x0
[ebp-12],0x0
DWORD
DWORD PTR
PTR [ebp-8],0x0
[ebp-8],0x0
54
54 <main+0x54>
<main+0x54>
eax,DWORD
eax,DWORD PTR
PTR [ebp-8]
[ebp-8]
eax,DWORD
eax,DWORD PTR
PTR [ebp+eax*4-32]
[ebp+eax*4-32]
DWORD
PTR
[ebp-12],eax
DWORD PTR [ebp-12],eax
DWORD
DWORD PTR
PTR [ebp-8]
[ebp-8]
DWORD
DWORD PTR
PTR [ebp-16]
[ebp-16]
DWORD
DWORD PTR
PTR [ebp-16],0x0
[ebp-16],0x0
44
<main+0x44>
44 <main+0x44>
eax,DWORD
eax,DWORD PTR
PTR [ebp-12]
[ebp-12]
DWORD
DWORD PTR
PTR [esp+4],eax
[esp+4],eax
DWORD
DWORD PTR
PTR [esp],0x0
[esp],0x0
69
69 <main+0x69>
<main+0x69>
esp,0x34
esp,0x34
ecx
ecx
ebp
ebp
esp,[ecx-4]
esp,[ecx-4]
9
Compiladores. Enlazado
#include
#include <stdio.h>
<stdio.h>
Interpretan un lenguaje de
programación de alto nivel y
generan código máquina que puede
ejecutar la CPU
int
int main(void)
main(void)
{{
int
int x[]
x[] == {1,
{1, 5,
5, 2,
2, 18};
18};
int
int cont
cont == 4;
4;
int
sum
=
0;
int sum = 0;
int
int ii == 0;
0;
while
while (cont
(cont >> 0)
0)
{{
sum
sum == sum
sum ++ x[i];
x[i];
i++;
i++;
cont--;
cont--;
}}
printf("sum
printf("sum == %d\n",
%d\n", sum);
sum);
}}
Compilador
biblioteca
(printf, ...)
suma.o
suma
Enlazador
10
Compilación. Comparativa
mov
mov eax,
eax, 44
mov
mov ebx,
ebx, 00
mov
mov ecx,
ecx, xx
top:
top: add
add ebx,
ebx, [ecx]
[ecx]
add
ecx,
add ecx, 44
dec
eax
dec eax
jnz
jnz top
top
done:
done: mov
mov [sum],
[sum], ebx
ebx
#include
#include <stdio.h>
<stdio.h>
int
int main(void)
main(void)
{{
int
int x[]
x[] == {1,
{1, 5,
5, 2,
2, 18};
18};
int
int cont
cont == 4;
4;
int
sum
=
0;
int sum = 0;
int
int ii == 0;
0;
while
while (cont
(cont >> 0)
0)
{{
sum
sum == sum
sum ++ x[i];
x[i];
i++;
i++;
cont--;
cont--;
}}
printf("sum
printf("sum == %d\n",
%d\n", sum);
sum);
}}
0:
0:
4:
4:
7:
7:
a:
a:
b:
b:
d:
d:
e:
e:
11:
11:
18:
18:
1f:
1f:
26:
26:
2d:
2d:
34:
34:
3b:
3b:
42:
42:
44:
44:
47:
47:
4b:
4b:
4e:
4e:
51:
51:
54:
54:
58:
58:
5a:
5a:
5d:
5d:
61:
61:
68:
68:
6d:
6d:
70:
70:
71:
71:
72:
72:
75:
75:
8d
8d 4c
4c 24
24 04
04
83
83 e4
e4 f0
f0
ff
ff 71
71 fc
fc
55
55
89
89 e5
e5
51
51
83
83 ec
ec 34
34
c7
c7 45
45 e0
e0 01
01 00
00 00
00 00
00
c7
c7 45
45 e4
e4 05
05 00
00 00
00 00
00
c7
45
e8
02
00
00
c7 45 e8 02 00 00 00
00
c7
c7 45
45 ec
ec 12
12 00
00 00
00 00
00
c7
c7 45
45 f0
f0 04
04 00
00 00
00 00
00
c7
c7 45
45 f4
f4 00
00 00
00 00
00 00
00
c7
c7 45
45 f8
f8 00
00 00
00 00
00 00
00
eb
eb 10
10
8b
8b 45
45 f8
f8
8b
8b 44
44 85
85 e0
e0
01
01 45
45 f4
f4
ff
ff 45
45 f8
f8
ff
ff 4d
4d f0
f0
83
83 7d
7d f0
f0 00
00
7f
ea
7f ea
8b
45
f4
8b 45 f4
89
89 44
44 24
24 04
04
c7
c7 04
04 24
24 00
00 00
00 00
00 00
00
e8
e8 fc
fc ff
ff ff
ff ff
ff
83
c4
34
83 c4 34
59
59
5d
5d
8d
8d 61
61 fc
fc
c3
c3
lea
lea
and
and
push
push
push
push
mov
mov
push
push
sub
sub
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
mov
jmp
jmp
mov
mov
mov
mov
add
add
inc
inc
dec
dec
cmp
cmp
jg
jg
mov
mov
mov
mov
mov
mov
call
call
add
add
pop
pop
pop
pop
lea
lea
ret
ret
ecx,[esp+4]
ecx,[esp+4]
esp,0xfffffff0
esp,0xfffffff0
DWORD
DWORD PTR
PTR [ecx-4]
[ecx-4]
ebp
ebp
ebp,esp
ebp,esp
ecx
ecx
esp,0x34
esp,0x34
DWORD
DWORD PTR
PTR [ebp-32],0x1
[ebp-32],0x1
DWORD
DWORD PTR
PTR [ebp-28],0x5
[ebp-28],0x5
DWORD
PTR
DWORD PTR [ebp-24],0x2
[ebp-24],0x2
DWORD
DWORD PTR
PTR [ebp-20],0x12
[ebp-20],0x12
DWORD
DWORD PTR
PTR [ebp-16],0x4
[ebp-16],0x4
DWORD
DWORD PTR
PTR [ebp-12],0x0
[ebp-12],0x0
DWORD
DWORD PTR
PTR [ebp-8],0x0
[ebp-8],0x0
54
54 <main+0x54>
<main+0x54>
eax,DWORD
eax,DWORD PTR
PTR [ebp-8]
[ebp-8]
eax,DWORD
eax,DWORD PTR
PTR [ebp+eax*4-32]
[ebp+eax*4-32]
DWORD
PTR
[ebp-12],eax
DWORD PTR [ebp-12],eax
DWORD
DWORD PTR
PTR [ebp-8]
[ebp-8]
DWORD
DWORD PTR
PTR [ebp-16]
[ebp-16]
DWORD
DWORD PTR
PTR [ebp-16],0x0
[ebp-16],0x0
44
<main+0x44>
44 <main+0x44>
eax,DWORD
PTR
eax,DWORD PTR [ebp-12]
[ebp-12]
DWORD
DWORD PTR
PTR [esp+4],eax
[esp+4],eax
DWORD
DWORD PTR
PTR [esp],0x0
[esp],0x0
69
69 <main+0x69>
<main+0x69>
esp,0x34
esp,0x34
ecx
ecx
ebp
ebp
esp,[ecx-4]
esp,[ecx-4]
11
Contenidos
Lenguaje máquina y ensamblador
Jerarquía del software
–
Sistema operativo. Bibliotecas. Aplicaciones.
Funciones del sistema operativo
–
Para el usuario. Para el programador.
Tareas del sistema operativo
Evolución. Gestión de procesos. Gestión de memoria. Gestión de
E/S
12
Jerarquía del software
Software
–
Aplicaciones
Aplicaciones
Sistema
Sistema Operativo
Operativo
Hardware
Hardware
13
Jerarquía del software
aplicaciones
utilidades
usuario
desarrollador
bibliotecas
kernel
implementador
S.O.
hardware
14
Contenidos
Lenguaje máquina y ensamblador
Jerarquía del software
–
Sistema operativo. Bibliotecas. Aplicaciones.
Funciones del sistema operativo
–
Para el usuario. Para el programador.
Tareas del sistema operativo
–
Evolución. Gestión de procesos. Gestión de memoria. Gestión de
E/S
15
Funciones del S.O.
El Usuario: interfaz
Software genérico que “viene” instalado con el ordenador
–
–
–
Interfaz hombre/máquina: interfaz de usuario
Utilidades varias: editor de textos, calculadora, etc.
Aplicaciones de uso general: reproductor multimedia, navegador
web, correo electrónico, etc.
Funciones del S.O. El programador: interfaz
de programación
Funciones y utilidades básicas que permiten la instalación y
desarrollo de otras aplicaciones
–
–
–
Programas básicos: editor de textos, comandos básicos
Biblioteca de funciones básicas
Herramientas de desarrollo: compilador, enlazador, ensamblador,
etc.
Funciones del S.O.
El Implementador: máquina virtual
Como gestor de recursos y controlador de la ejecución de
procesos. Abstracción del hardware
–
–
–
–
–
Gestión de archivos
Gestión de memoria
Gestión de tareas
Gestión de entrada/salida
Máquina virtual
Contenidos
Lenguaje máquina y ensamblador
Jerarquía del software
–
Sistema operativo. Bibliotecas. Aplicaciones.
Funciones del sistema operativo
–
Para el usuario. Para el programador.
Tareas del sistema operativo
–
Evolución. Gestión de procesos. Gestión de memoria.
Gestión de E/S
20
Evolución de los S.O.
Sistemas sin S.O.
–
–
–
programación directa en código máquina
los programas (cada instrucción) se cargan en memoria
directamente (ej: mediante tarjetas perforadas)
los errores se indican con indicadores luminosos
Sistemas primitivos
–
–
–
–
–
existe software pre-programado de uso general
ensambladores, compiladores, bibliotecas, ...
se escriben programas en lenguajes de alto nivel
planificación de tareas manual
tiempo de preparación alto, grandes pausas entre tareas
gran desperdicio de tiempo de CPU
entrada: tarjetas/cinta magnética
salida: impresora
Evolución de los S.O.
Sistemas de colas sencillos
–
–
–
–
–
trabajos ordenados en una cola de entrada
monitor residente: programa que carga y ejecuta trabajos
automáticamente
preparación automática: lenguaje de control de trabajos
soporte del hardware:
interrupciones
protección de memoria
temporización
instrucciones privilegiadas: E/S, etc.
inconveniente: pérdida de tiempo de CPU durante E/S
Evolución de los S.O.
Sistemas de colas sofisticados
–
–
–
Multiprogramación: varios programas cargados en memoria a la
vez
necesaria protección de memoria
necesaria planificación de tareas
Un nuevo proceso pasa a ejecutarse cuando otro está en espera de
que concluya una operación de E/S
Soporte del hardware
múltiples interrupciones
acceso directo a memoria (DMA)
Sistemas de tiempo compartido
–
–
Uso interactivo del sistema
Ejecución de tareas de forma “casi” simultánea
multitarea preeventiva
Tareas de los S.O.
Planificación de procesos
–
–
–
–
asignación eficiente de recursos a programas en ejecución
implementación de la multitarea
protección entre procesos
comunicación entre procesos
Gestión de memoria
–
–
–
asignación dinámica de memoria
protección de memoria
implementación de la memoria virtual
Gestión de entrada/salida (E/S)
–
–
–
control del acceso a E/S
gestión de permisos
implementación de sistemas de archivos