Teorico Con Preguntas de Examen

FINGUDELAR
TericodeSistemas
Operativos
Extradodelcursode:
FacultaddeIngeniera
UniversidaddelaRepblica
Uruguay
Elmaterialcontienelacompaginacindetodaslastransparencias
delcurso2008mselresumendeMnicaCantodelcurso2002.
SistemasOperativosActualizadoal2008
FINGUDELAR
TabladeContenidos
1Introduccin....................................................................................................................13
1.1ComponentesdeunSistemadeComputacin.........................................................13
1.2Definicindesistemaoperativo...............................................................................13
1.2.1Metas.................................................................................................................13
1.2.2Tareasprincipales.............................................................................................13
2PerspectivaHistrica......................................................................................................15
2.1SistemasBatch(70)................................................................................................15
2.2SistemasBatchconMultiprogramacin(Com.80)...............................................15
2.3Sistemasdetiempocompartido.(Fines80)............................................................16
2.4Computadorespersonales(Fines80)......................................................................16
2.5SistemasParalelos(com.90)..................................................................................17
2.6TaxonomadeFlynn(comienzosdelos'90):..........................................................17
2.7SistemasParalelosMultiprocesadores.....................................................................18
2.8SistemasCluster.......................................................................................................19
2.9SistemasdeTiempoReal.........................................................................................20
2.10SistemasMultimedia..............................................................................................20
2.11SistemasdeMano..................................................................................................20
3EstructuradelosSistemasdeComputacin...................................................................22
3.1Componentesdeunsistema.....................................................................................22
3.1.1CPU(procesador)..............................................................................................22
3.1.2Memoria............................................................................................................23
3.1.2.1Cache.......................................................................................................24
3.1.2.2Memoriaprincipal(RAM).......................................................................24
3.1.2.3Discosmagnticos(harddisk).................................................................24
3.1.3DispositivosdeEntrada/Salida(IO).................................................................25
3.1.3.1DeviceDrivers.........................................................................................26
3.1.3.2MemorymappedIO................................................................................26
3.1.3.3IOportaddress.........................................................................................27
3.1.3.4Comparacindeacceso...........................................................................27
3.1.3.5Interaccinconlacontroladora...............................................................27
3.1.3.5.1Polling..............................................................................................27
3.1.3.5.2Interrupciones...................................................................................28
3.1.3.5.3DMA................................................................................................28
3.2ProteccindeHardware...........................................................................................29
3.2.1ModoDual........................................................................................................29
3.2.2ProteccindeE/S..............................................................................................30
3.2.3ProteccindeMemoria.....................................................................................31
3.2.4ProteccindeCPU............................................................................................31
3.3Red...........................................................................................................................32
3.3.1LANLocalAreaNetwork..............................................................................32
FINGUDELAR
3.3.2WANWideAreaNetworks............................................................................32
3.3.3Topologasdered..............................................................................................33
4EstructuradelosSistemasOperativos............................................................................35
4.1Componentesdelsistemaoperativo.........................................................................35
4.1.1Administracindeprocesos..............................................................................35
4.1.2Administracindememoria..............................................................................35
4.1.3SubsistemadeE/S.............................................................................................36
4.1.4Administracindealmacenamientosecundario...............................................36
4.1.5Subsistemadearchivos.....................................................................................37
4.1.6Red....................................................................................................................37
4.1.7Sistemadeproteccin.......................................................................................37
4.1.8Intrpretedecomandos.....................................................................................37
4.2ServiciosdelSO.......................................................................................................37
4.2.1Ejecucindeprogramas....................................................................................38
4.2.2OperacionesdeEntrada/Salida.........................................................................38
4.2.3Manipulacindesistemasdearchivos..............................................................38
4.2.4Comunicacinentreprocesos...........................................................................38
4.2.5Deteccindeerrores.........................................................................................38
4.2.6PropsitoGeneral..............................................................................................38
4.3Llamadosalsistema.................................................................................................38
4.4Estructuradelsistema..............................................................................................40
4.4.1SistemaMonoltico...........................................................................................41
4.4.2Sistemaencapas...............................................................................................41
4.4.3Sistemaconmicroncleo(microkernel)...........................................................42
4.4.4Sistemaconmdulos........................................................................................43
5Procesos..........................................................................................................................45
5.1DefinicindeProceso..............................................................................................45
5.2Contadordeprograma..............................................................................................45
5.3Memoriadelosprocesos.........................................................................................45
5.4Estadosdelosprocesos............................................................................................46
5.5Transicionesentreestados.......................................................................................47
5.6Bloquedescriptordeproceso...................................................................................47
5.7Creacindeprocesos...............................................................................................48
.......................................................................................................................................49
5.8Listasycolasdeprocesos........................................................................................50
5.9Cambiodecontexto.................................................................................................51
5.10Cooperacinentreprocesos...................................................................................53
5.11Threads...................................................................................................................53
6Planificacin...................................................................................................................58
6.1Introduccin.............................................................................................................58
6.2Clasesdeprocesos...................................................................................................58
6.3Esquemasdeplanificacin.......................................................................................58
FINGUDELAR
6.4Criteriosdeplanificacin.........................................................................................60
6.5Algoritmosdeplanificacin.....................................................................................60
6.5.1FirstComeFirstServed(FCFS)......................................................................60
6.5.2ShortestJobFirst(SJF)....................................................................................60
6.5.3BasadosenPrioridad.........................................................................................61
6.5.4RoundRobin(RR)............................................................................................62
6.5.5Colasmultinivel(MultilevelQueue)................................................................64
6.5.6MultilevelFeedbackQueue.............................................................................64
6.5.7Sistemasmultiprocesadores..............................................................................65
6.6Despachador.............................................................................................................67
7ProcesosyRecursos........................................................................................................68
7.1Bloquedescriptordeprocesos(PCB)......................................................................68
7.2BloquedescriptorderecursosRCB.........................................................................68
7.3Transicionesdeestados............................................................................................69
7.4Operacionessobreprocesos.....................................................................................69
7.5OperacionessobreRecursos....................................................................................70
7.5.1RequerirRecurso..............................................................................................70
7.5.2LiberarRecurso.................................................................................................70
7.6Planificador..............................................................................................................71
7.7Ejemplo(semforobinario).....................................................................................72
8Administracindememoria............................................................................................73
8.1Introduccin.............................................................................................................73
8.2Conceptosbsicos....................................................................................................73
8.3AsociacindeDirecciones(AddressBinding)........................................................75
8.4Tiposdedireccionamiento.......................................................................................76
8.5Cargadinmica(dynamicloading):.........................................................................77
8.6Ensamblajedinmico(dynamiclinking).................................................................77
8.7Overlays...................................................................................................................78
8.8Swapping..................................................................................................................78
8.9Asignacindememoria...........................................................................................79
8.10Multiprogramacinconparticionesfijas...............................................................79
8.11Multiprogramacinconparticionesvariables........................................................80
8.12Estructurasparaasignacin....................................................................................80
8.13Estrategiadeasignacin.........................................................................................80
8.14Fragmentacin........................................................................................................81
8.15Paginacin..............................................................................................................82
8.16Direccionamientoenpaginacin............................................................................82
8.17Soporteaniveldehardware...................................................................................84
8.18Tiempoefectivodeacceso(EffectiveAccessTime).............................................86
8.19Proteccindememoria..........................................................................................86
8.20Estructuradelatabladepgina.............................................................................87
8.20.1Jerrquica........................................................................................................87
FINGUDELAR
8.20.2Diccionarios....................................................................................................88
8.20.3Invertida..........................................................................................................89
8.21Compartimiento.....................................................................................................89
8.22Segmentacin.........................................................................................................90
8.22.1Soporteaniveldehardware............................................................................91
8.22.2Proteccindememoria...................................................................................93
8.22.3Compartimiento..............................................................................................94
8.23ComparacinPaginacinSegmentacin.............................................................94
8.24Segmentacinconpaginacin................................................................................96
9MemoriaVirtual..............................................................................................................97
9.1Introduccin.............................................................................................................97
9.2Implementacin........................................................................................................98
9.2.1Rutinadeatencindelfallodepgina:..........................................................100
9.3Estudiodelaperformance.....................................................................................101
9.4Algoritmosdereemplazo.......................................................................................102
9.4.1FIFO(FirstInFirstOut)..............................................................................102
9.4.1.1AnomaladeBeladyparaFIFO.............................................................103
9.4.2Segundachance(Secondchance)...................................................................104
9.4.3ptimo(OptimalPageReplacement).............................................................104
9.4.4Norecientementeusada(NotRecentlyUsedNRU)....................................104
9.4.5Recientementemenosusada(LeastRecentlyUsedLRU)...........................105
9.5Estrategiadeasignacindeframes........................................................................106
9.6Hiperpaginacin.....................................................................................................107
9.6.1Causasdelahiperpaginacin..........................................................................107
9.6.2ElmodeloWorkingSet..................................................................................108
10SistemadeArchivos...................................................................................................110
10.1Archivos...............................................................................................................110
10.2Operacionessobrelosarchivos............................................................................110
10.3Mtodosdeacceso...............................................................................................111
10.4Directorios............................................................................................................111
10.4.1Operacionessobredirectorios.......................................................................112
10.4.2Estructuradedirectorios...............................................................................112
10.4.2.1Nivelnico...........................................................................................112
10.4.2.2rbol....................................................................................................112
10.4.3Grafo.............................................................................................................113
10.4.4Montajededirectorios..................................................................................113
10.5Seguridadenarchivos..........................................................................................114
10.6Implementacin....................................................................................................114
10.6.1Sistemadearchivosvirtual...........................................................................115
10.6.2Estructuradelosdirectorios..........................................................................115
10.6.3Mtodosdeasignacin..................................................................................116
10.6.3.1Asignacincontigua(ContiguosAllocation)......................................116
FINGUDELAR
10.6.3.2Asignacinenformadelista(LinkedAllocation)..............................116
10.6.3.2.1Ej.FAT.........................................................................................116
10.6.3.3Asignacinindexada(IndexedAllocation).........................................117
10.6.4Administracindelespaciolibre..................................................................118
10.6.4.1EjemploUNIX.....................................................................................119
11Estructuradedispositivosmasivosdedatos...............................................................121
11.1Planificacindedisco..........................................................................................121
11.1.1FCFSFirstCome,FirstServed..................................................................121
11.1.2SSTFShortestSeekTimeFirst..................................................................122
11.1.3SCAN............................................................................................................122
11.1.4CSCAN........................................................................................................123
11.1.5CLOOK.......................................................................................................123
11.1.6Comparacindelosalgoritmosdeplanificacin..........................................124
11.2EstructurasRAID.................................................................................................125
12SubsistemadeEntradaSalida.....................................................................................127
12.1Introduccin.........................................................................................................127
12.2MtodosparaefectuarunaE/S............................................................................128
12.2.1E/Sprogramada(ProgrammedI/O)..............................................................128
12.2.2Interrupciones(InterruptDriven).................................................................129
12.2.3Accesodirectoamemoria(DMADirectMemoryAccess).......................130
12.2.3.1InterfazdeaplicacindeE/S...............................................................132
13Concurrencia...............................................................................................................136
13.1Antecedentes........................................................................................................136
13.2Elproblemadelaseccincrtica.........................................................................137
13.2.1Solucionesparadosprocesos........................................................................138
13.3Hardwaredesincronizacin.................................................................................144
13.4Semforos............................................................................................................146
13.4.1Uso...............................................................................................................146
13.4.2Implementacin.............................................................................................146
13.4.3Bloqueosmutuoseinanicin........................................................................148
13.4.4Semforosbinarios........................................................................................149
13.5Problemasclsicosdesincronizacin..................................................................150
13.5.1Elproblemadelbuffer..................................................................................150
13.5.2Elproblemadeloslectoresyescritores........................................................150
13.5.3Elproblemadelosfilsofos.........................................................................151
13.6Regionescrticas..................................................................................................153
13.7Monitores.............................................................................................................153
13.8SincronizacinenSolaris2..................................................................................157
13.9Transaccionesatmicas.......................................................................................157
13.9.1Modelodelsistema.......................................................................................157
13.9.2Recuperacinbasadaenbitcoras................................................................158
13.9.3Puntosdeverificacin(checkpoints)............................................................158
FINGUDELAR
13.9.4Transaccionesatmicasconcurrentes...........................................................159
13.9.4.1Seriabilidad..........................................................................................159
13.9.4.2Protocolodecerraduras.......................................................................159
13.9.4.3Protocolosbasadosenmarcasdetiempo.............................................160
14Ada..............................................................................................................................161
14.1Unpocodehistoria..............................................................................................161
14.1.1Pequeadescripcindellenguaje.................................................................161
14.2Tiposdedatosprimitivos.....................................................................................161
14.2.1VariablesyConstantes..................................................................................161
14.3TiposdeDatosNumricos...................................................................................162
14.3.1Enumeraciones..............................................................................................162
14.3.2TiposCaracteryBoleano..............................................................................162
14.3.3TipodeDatoApuntador...............................................................................162
14.4Tipodedatosestructurados.................................................................................163
14.4.1VectoresyArreglos......................................................................................163
14.4.2CadenadeCaracteres....................................................................................163
14.4.3TipodeDatoArchivo...................................................................................163
14.4.4TipodeDatoDefinidoPorElUsuario.........................................................164
14.5Controldesecuencia............................................................................................164
14.5.1Expresiones...................................................................................................164
14.5.2Sentencias.....................................................................................................164
14.6Sentenciascondicionales.....................................................................................164
14.6.1SentenciaIf...................................................................................................164
14.6.2SentenciaCASE............................................................................................165
14.7Sentenciasdeiteracin.........................................................................................165
14.7.1SentenciaLoop..............................................................................................165
14.8Subprogramasymanejodealmacenamiento.......................................................166
14.8.1FuncionesyProcedimientos.........................................................................166
14.9Abstraccinyencapsulamiento...........................................................................167
14.9.1Paquetes........................................................................................................167
14.10HolaMundo!!.....................................................................................................167
14.11Ejemplosdeprocedimientos:.............................................................................168
14.11.1AliciaBernardo:.......................................................................................168
14.11.2Factorial:.....................................................................................................169
14.11.3ProductorConsumidor:............................................................................169
14.11.4Semforo:....................................................................................................171
14.11.5Productorconsumidor:.............................................................................171
15Bloqueosmutuos(Deadlock)......................................................................................173
15.1Modelodelsistema..............................................................................................173
15.2Caracterizacindebloqueosmutuos...................................................................173
15.2.1Condicionesnecesarias.................................................................................173
15.2.2Grafodeasignacinderecursos...................................................................174
FINGUDELAR
15.3Mtodosparamanejarbloqueosmutuos..............................................................174
15.4Evitacindebloqueosmutuos.............................................................................175
15.4.1Mutuaexclusin............................................................................................175
15.4.2Reteneryesperar...........................................................................................175
15.4.3Noexpropiacin............................................................................................175
15.4.4Esperacircular..............................................................................................175
15.5Prevencindebloqueosmutuos...........................................................................176
15.5.1Estadoseguro................................................................................................176
15.5.2Algoritmodegrafodeasignacinderecursos..............................................177
15.5.3Algoritmodelbanquero................................................................................177
15.5.4Algoritmodeseguridad.................................................................................181
15.5.4.1Algoritmodesolicitudderecursos......................................................181
15.6Deteccindebloqueosmutuos............................................................................181
15.6.1Unsoloejemplardecadatipoderecursos....................................................182
15.6.2Variosejemplaresdecadatipoderecursos..................................................182
15.6.3Usodelalgoritmodedeteccin.....................................................................182
15.7Recuperacindespusdelbloqueomutuo...........................................................183
15.7.1Terminacindeprocesos..............................................................................183
15.7.2Expropiacinderecursos..............................................................................183
15.8Estrategiacombinadaparaelmanejodebloqueosmutuos.................................184
16Proteccin...................................................................................................................185
16.1Objetivosdelaproteccin...................................................................................185
16.2Dominiosdeproteccin.......................................................................................185
16.2.1Estructuradedominios.................................................................................185
16.2.2Ejemplos.......................................................................................................186
16.2.2.1UNIX...................................................................................................186
16.2.2.2Multics.................................................................................................187
16.3Matrizdeacceso..................................................................................................187
16.4Implementacindelamatrizdeacceso...............................................................188
16.4.1Tablaglobal..................................................................................................188
16.4.2Listadeaccesoparaobjetos..........................................................................189
16.4.3Listadecapacidadesparadominios..............................................................189
16.4.4Unmecanismodecerradurayllave..............................................................189
16.4.5Comparacin.................................................................................................189
16.5Revocacindederechosdeacceso......................................................................189
16.6Sistemasbasadosencapacidades.........................................................................190
16.6.1Hydra.............................................................................................................190
16.6.2SistemaCambridgeCAP..............................................................................190
16.7Proteccinbasadaenellenguaje.........................................................................191
17Seguridad....................................................................................................................192
17.1Elproblemadelaseguridad.................................................................................192
17.2Validacin............................................................................................................192
FINGUDELAR
17.2.1Contraseas...................................................................................................192
17.2.2Vulnerabilidaddelascontraseas.................................................................192
17.2.3Contraseascifradas.....................................................................................192
17.3Contraseasdeunsolouso..................................................................................193
17.4Amenazasporprogramas.....................................................................................193
17.4.1CaballodeTroya...........................................................................................193
17.4.2Puertasecreta(Trapdoor).............................................................................193
17.5Amenazasalsistema............................................................................................193
17.5.1Gusanos.........................................................................................................193
17.5.2Virus..............................................................................................................194
17.6Vigilanciadeamenazas........................................................................................194
17.7Cifrado.................................................................................................................194
17.8Clasificacindeseguridaddeloscomputadores.................................................195
17.9Ejemplodemodelodeseguridad:WindowsNT.................................................197
18ElsistemaUNIX.........................................................................................................198
18.1Historia.................................................................................................................198
18.2Principiosdediseo.............................................................................................198
18.3Interfazconelprogramador.................................................................................198
18.3.1Manipulacindearchivos.............................................................................199
18.3.2Controldeprocesos.......................................................................................199
18.4Seales.................................................................................................................200
18.4.1Gruposdeprocesos.......................................................................................200
18.4.2Manipulacindeinformacin.......................................................................200
18.4.3Rutinasdebiblioteca.....................................................................................200
18.5Interfazconelusuario..........................................................................................200
18.5.1Shellsyrdenes............................................................................................201
18.5.2E/Sestndar..................................................................................................201
18.5.3Conductos,filtrosyguionesdeshell............................................................201
18.6Gestindeprocesos.............................................................................................201
18.6.1Bloquesdecontroldeprocesos.....................................................................202
18.6.2PlanificacindeCPU....................................................................................202
18.7Gestindememoria.............................................................................................202
18.7.1Intercambio...................................................................................................202
18.7.2Paginacin.....................................................................................................202
18.8Sistemadearchivos..............................................................................................203
18.8.1Bloquesyfragmentos...................................................................................203
18.8.2Inodos..........................................................................................................203
18.8.3Directorios.....................................................................................................203
18.8.4Transformacindeundescriptordearchivoenuninodo...........................204
18.8.5Estructurasdedisco......................................................................................204
18.8.6Organizacinypolticasdeasignacin.........................................................204
18.9SistemasdeE/S....................................................................................................204
FINGUDELAR
18.9.1cachedebuffersdebloques..........................................................................205
18.9.2Interfacescondispositivoscrudas................................................................205
18.9.3ListasC.........................................................................................................205
18.10Comunicacinentreprocesos(IPC)..................................................................205
18.10.1Sockets........................................................................................................205
18.10.2Soportepararedes.......................................................................................206
19ElsistemaLinux.........................................................................................................207
19.1Historia.................................................................................................................207
19.1.1ElncleodeLinux........................................................................................207
19.1.2ElsistemaLinux...........................................................................................207
19.1.3DistribucionesdeLinux................................................................................207
19.1.4LicenciasdeLinux........................................................................................208
19.2PrincipiosdeDiseo............................................................................................208
19.2.1ComponentesdeunsistemaLinux...............................................................208
19.3MdulosdelNcleo.............................................................................................209
19.3.1Gestindemdulos.......................................................................................209
19.3.2Registrodecontroladores.............................................................................209
19.3.3Resolucindeconflictos...............................................................................210
19.4Gestindeprocesos.............................................................................................210
19.4.1Elmodelodeprocesofork/exec....................................................................210
19.4.1.1Identidaddelproceso...........................................................................210
19.4.1.2Entornodelproceso.............................................................................210
19.4.1.3Contextodeunproceso.......................................................................210
19.4.2ProcesoseHilos............................................................................................211
19.5Planificacin........................................................................................................211
19.5.1Sincronizacindelncleo.............................................................................211
19.5.2Planificacindeprocesos..............................................................................212
19.5.3Multiprocesamientosimtrico......................................................................212
19.6Gestindememoria.............................................................................................213
19.6.1Gestindememoriafsica............................................................................213
19.6.2Memoriavirtual............................................................................................213
19.6.2.1Regionesdememoriavirtual...............................................................213
19.6.2.2Tiempodevidadeunespaciodedireccionesvirtual..........................214
19.6.2.3Intercambioypaginacin....................................................................214
19.6.2.4Memoriavirtualdelncleo..................................................................214
19.6.3Ejecucinycargadeprogramasdeusuario..................................................214
19.6.4Correspondenciaentrelosprogramasylamemoria.....................................214
19.6.4.1Enlazadoestticoydinmico..............................................................215
19.7.1Elsistemadearchivosvirtual.......................................................................215
19.7.2ElsistemadearchivosLinuxext2fs.............................................................216
19.7.3ElsistemadearchivosprocdeLinux...........................................................216
10
FINGUDELAR
19.8Entradaysalida....................................................................................................216
19.8.1Dispositivosporbloques...............................................................................216
19.8.1.1Elcachedebuffersporbloques...........................................................217
19.8.1.2Elgestordesolicitudes........................................................................217
19.8.2Dispositivosporcaracteres...........................................................................217
19.9ComunicacinentreProcesos..............................................................................217
19.9.1Sincronizacinyseales...............................................................................217
19.9.2Transferenciadedatosentreprocesos..........................................................218
19.10Estructuraderedes.............................................................................................218
19.11Seguridad...........................................................................................................218
19.11.1Validacin...................................................................................................218
19.11.2Controldeacceso........................................................................................218
20WindowsNT...............................................................................................................220
20.1Historia.................................................................................................................220
20.2Principiosdediseo.............................................................................................220
20.3Componentesdelsistema.....................................................................................221
20.3.1Capadeabstraccindehardware..................................................................221
20.3.2Ncleo...........................................................................................................221
20.3.3Ejecutivo.......................................................................................................223
20.3.3.1Gestordeobjetos.................................................................................223
20.3.3.2Nombresdeobjetos.............................................................................223
20.3.3.3Gestordememoriavirtual...................................................................223
20.3.3.4Gestordeprocesos...............................................................................225
20.3.3.5Recursodellamadasaprocedimientoslocales....................................225
20.3.3.6GestordeE/S:......................................................................................226
20.3.3.7Gestordereferenciasdeseguridad......................................................227
20.4Subsistemasdeentorno........................................................................................227
20.4.1EntornoMSDOS..........................................................................................227
20.4.2EntornoWindowsde16bits.........................................................................228
20.4.3EntornoWin32..............................................................................................228
20.4.4SubsistemaPOSIX........................................................................................228
20.4.5SubsistemaOS/2...........................................................................................228
20.4.6Subsistemasdeingresoyseguridad..............................................................228
20.5.1Organizacininterna.....................................................................................229
20.5.2Recuperacin.................................................................................................230
20.5.3Seguridad......................................................................................................230
20.5.4Gestindevolmenesytoleranciadefallos.................................................230
20.5.5Compresin...................................................................................................232
20.6Trabajoconredes.................................................................................................232
20.6.1Protocolos.....................................................................................................232
20.6.2Mecanismosdeprocesamientodistribuido...................................................232
11
FINGUDELAR
20.6.3Redirectoresyservidores..............................................................................233
20.6.4Dominios.......................................................................................................233
20.6.5ResolucindenombresenredesTCP/IP......................................................234
20.7Interfazconelprogramador.................................................................................234
20.7.1Accesoaobjetosdelncleo..........................................................................234
20.7.1.1Compartimientodeobjetos..................................................................234
20.7.2Gestindeprocesos......................................................................................234
20.7.3Comunicacinentreprocesos.......................................................................235
20.7.4Gestindememoria......................................................................................235
12
FINGUDELAR
1 Introduccin
1.1 ComponentesdeunSistemadeComputacin
1.2 Definicindesistemaoperativo
Un sistema operativo es un programa o conjunto de programas que tornan
productivo, amigable y eficiente el uso de un computador (hardware) permitiendo
ejecutar aplicaciones del usuario.
1.2.1 Metas
Brindar un ambiente para realizar y ejecutar los programas y aplicaciones de

los usuarios.
Proveer un entorno sin interferencias a cada usuario.
Administrar en forma equitativa los recursos de hardware y software del
sistema.
Hacer que el uso del sistema tan amigable, intuitivo y expresivo como permita
el estado de la tecnologa.
Todas las aplicaciones requieren un conjunto de operaciones comunes que son

incorporadas al sistema operativo o a su entorno.
1.2.2 Tareasprincipales
Proveer uno o varios entornos y contexto apropiado para la ejecucin

de los programas de los usuarios de propsito general, incluyendo
exclusivamente el cdigo de la aplicacin.
13
FINGUDELAR
Podr implementar diferentes entornos adecuados para diferentes

usos, como interfaz grfica, lnea de comando o shell, o transaccional
tipo Web.
Deber proveer una o mas interfaces con el usuario, expresivas e
intuitivas.
Proporcionar a las aplicaciones un conjunto de servicios a travs de
una interfaz conocida como system services
Brindar eficiencia y equidad en la administracin de los recursos.
Examen marzo 2006:

Cules son los objetivos principales de un sistema operativo?
Elsistemaoperativoesun:
Administrador de recursos.
Administra todos los recursos disponibles.

Decide cmo asignar estos recursos segn los pedidos y
asignaciones que tenga.
Programa de control.
Controla la ejecucin de los programas para la prevencin de

errores y mal uso del sistema.
Frecuentemente, la porcin residente del propio sistema operativo se denomina

ncleo del sistema (kernel).
14
FINGUDELAR
2 PerspectivaHistrica
2.1 SistemasBatch(70)
En las primeras pocas los sistemas eran grandes y costosos.
Constaban de un entrada de trabajos o cola y una salida
impresa.
Prcticamente no haba interaccin alguna con el usuario.
La funcin principal era la del cargador (loader) de programas
y soporte de E/S a dispositivos.
El sistema soportaba un nico trabajo a la vez.
Lectora de Entrada > Proceso > Salida y resultado
Las tareas relacionadas, se agrupaban en conjuntos de trabajos o lotes (batches)
para su procesamiento ms eficiente.
Con el advenimiento de los discos se comenz a realizar el Spool de los
dispositivos haciendo ms rpidas las operaciones e introduciendo por primera vez el
solapamiento o concurrencia de operaciones. El recurso ms caro de la poca era el
procesador (CPU), que tena un bajo porcentaje de utilizacin.
2.2 SistemasBatchconMultiprogramacin(Com.80)
El disponer de un Pool de Jobs en memoria secundaria y la
implementacin de tcnicas de multiprogramacin permiti
desarrollar tcnicas de planificacin de despacho de job
scheduling as como de multiprogramacin.
El sistema deba seleccionar un subconjunto de trabajos o
lotes (jobs) que estaban en memoria secundaria para cargar
en memoria principal.
El sistema operativo seleccionaba un trabajo para ejecutar.
Cuando el trabajo seleccionado deba esperar por alguna
tarea (por ej. ejecucin de una E/S), el sistema elega otro
para utilizar el procesador.
Todo esto implic el desarrollo de tcnicas incipientes para
el manejo de la memoria, ya que haba que compartirla entre
todos los trabajos.
La multiprogramacin incrementa la utilizacin del recurso
procesador.
Examen diciembre 2004:
Qu se logra en los sistemas multiprogramados? Justifique.
Respuesta:
Se logra el incremento de utilizacin de CPU. Esto se logra al cargar varios procesos en memoria
y alternar la ejecucin cuando se producen requerimientos de E/S por ejemplo.
Examen julio 2005:
Cul es la principal ventaja de la multiprogramacin?
Respuesta:
Logra el incremento de utilizacin de CPU. Esto se consigue al cargar varios procesos en
memoria y alternar la ejecucin cuando se producen requerimientos de E/S por ejemplo.
15
FINGUDELAR
Examen marzo 2006:
Qu beneficios brinda el concepto de multiprogramacin?
Respuesta:
Incrementar el aprovechamiento del sistema, incluyendo los recursos de procesador, dispositivos
de E/S, memoria , etc. Varios programas son cargados en memoria y cuando alguno se bloquea,
el sistema operativo le asigna la CPU a otro proceso.
Qu beneficio brinda la multiprogramacin?
Discuta segn el sistema sea monoprocesador o multiprocesador.
Respuesta:
La maximizacin del recurso procesador tanto en monoprocesador como en multiprocesadores .
Examen julio 2007:
Cul es el beneficio de la multiprogramacin?
2.3 Sistemasdetiempocompartido.(Fines80)
Los sistemas Batch multiprogramados adolecan de una nula interaccin con el
usuario adems de un tiempo de retorno (turnaround time) extenso.
El debug de un programa segua siendo tortuoso (dump de la memoria).
Sistemas de tiempo compartido, ejecutan programas en forma concurrente con
una elevada tasa de despacho de procesador (context switch) de forma tal de
permitir que usuarios interacten directamente con el sistema como si fueran su
nico usuario.
Se debe combinar multiprogramacin con tcnicas de planificacin de CPU
(scheduling) para proveer a cada usuario con una porcin adecuada del sistema.
Los sistemas de tiempo compartido (time sharing systems) son una extensin
lgica de los sistemas multiprogramados.
Los usuarios utilizaban terminales para implementar la interaccin y eran
atendidos por un shell o intrprete de comandos (multiusuarios).
La calidad de la interaccin era un resultado de la transmisin carcter a carcter
o en modo bloque.
Todos los usuarios crean tener el computador a su disposicin.
Si bien un procesador ejecuta un nico proceso por vez, el despacho del mismo 30
40 veces por segundo entre diferentes tareas, le brinda a los usuarios la sensacin
de que est para su uso exclusivo. Este intercambio es tan frecuente que el usuario
puede interactuar con el trabajo suyo con total comodidad.
La necesidad de acceder y actualizar datos en forma concurrente, cre la
necesidad de evolucionar el sistema de archivos a uno multiusuario, incorporando
tcnicas de proteccin y serializacin del acceso.
En estas condiciones, los procesos deben contar con la memoria y procesador
necesarias para su ejecucin eficiente dando forma a los requerimientos de los
sistemas operativos de hoy da.
La expresin de gran porte de estos sistemas MainFrames incluy monitores de
teleproceso e interaccin con los usuarios mediante terminales que operaban en
modo de transmisin por bloque.
2.4 Computadorespersonales(Fines80)
Con costos de hardware decrecientes fue posible el diseo y uso de computadores
personales.
El sistema era diseando en base a que sera dedicado a un nico usuario.
16
FINGUDELAR
Con en un principio modestos recursos de procesador, el nfasis y desarrollo
estuvo por mejorar la interfaz con el usuario.
Para ello el sistema operativo debi maximizar la habilidad de interaccin con el
usuario en vez de uso de CPU, etc.
La interfaz de comandos habitual y diseada para tcnicos fue substituida por la
interfaz de ventanas que hoy conocemos.
Todo dispositivo es bueno si mejora la interaccin con el usuario (audio, ratn,
video, micrfono, cmara, disquete, etc.).
Finalmente, los PC invadieron el ambiente empresarial al ser dispuestos en red.
Para ello, utilizando sistemas homogneos y servidores con habilidades especficas
de impresin, base de datos, sistema de archivo, seguridad, correo, etc..
Esta es la disposicin reciente donde las aplicaciones se implementan en
modalidad cliente-servidor (tcnica obsoleta por las nueva herramientas
desarrolladas para Internet).
2.5 SistemasParalelos(com.90)
Sistemas donde se dispone de ms de un procesador permiten la ejecucin
simultnea de ms de un proceso.
Se clasifican en:
Sistemas altamente integrados(tightly coupled). Son sistemas
en donde los canales de interconexin son de alta velocidad (bus
comn o memoria compartida).
Sistemas poco integrados (closely coupled). Sistemas en
donde los canales de interconexin son de baja velocidad relativa.
Sistemas en red.
SistemasSimtricosoAsimtricosenfuncindesihayespecializacinonodelosprocesadores.1
2.6 TaxonomadeFlynn(comienzosdelos'90):
Caracteriz las arquitecturas de computadores y los datos sobre los cuales stas
se aplican:
SISD (Single Instruction, Single Data): una arquitectura secuencial

donde no existe paralelismo (sistemas monoprocesadores).
SIMD (Single instruction, Multiple Data): sistemas que ejecutan la
misma instruccin sobre un conjunto distinto de datos (sistemas
vectoriales).
MISD (Multiple Instruction, Single Data): utilizado para
paralelismo redundante.
MIMD (Multiple Instruction, Multiple Data): sistemas con
procesadores autnomos que ejecutan en forma simultnea diferentes
instrucciones sobre diferentes datos.
Dentro de los sistemas MIMD se suelen hacer dos divisiones:

Sistemas de memoria compartida: sistemas donde los
procesadores coexisten en un nico nodo o en un sistema altamente
integrado. Escalan poco debido a que el acceso a memoria desde los
procesadores se convierte en un "cuello de botella".
Sistemas de memoria distribuida: son sistemas donde los nodos
son independientes que se interconectan a travs de una red de alta
velocidad. Escalan a miles de procesadores.
1Quitadodelastransparenciasen2008
17
FINGUDELAR
2.7 SistemasParalelosMultiprocesadores
Sistemas asimtricos: al surgir los sistemas multiprocesadores los

ncleos de los sistemas operativos se modificaron para soportar este
tipo de sistema. La forma ms sencilla fue asignar la ejecucin de
cdigo del ncleo a un nico procesador. De esta forma, los sistemas
operativos no tenan que lidiar con la programacin concurrente, ya
que su cdigo estaba restringido a ejecutarse en un nico procesador.
Posteriormente, se empez a asignar ciertas tareas a otros
procesadores, generando una jerarqua entre ellos.
Sistemas simtricos. al avanzar el diseo de los sistemas operativos
se desarrollaron sistemas en donde el cdigo del ncleo se dispone en
la memoria comn y puede ser ejecutado por cualquier procesador. Se
pierde la jerarqua de los sistemas asimtricos y todos los
procesadores pasan a ser simtricos. La reentrancia del ncleo se
transforma en una necesidad crtica. Los proveedores debieron
18
FINGUDELAR
redisear totalmente sus sistemas operacionales. El cdigo del sistema
operativo, al igual que el ancho de banda de la memoria, se
transforman en un recursos crticos, que determinan la escalabilidad
del sistema.
Examen marzo 2004:
Defina sistema multiprocesador simtrico y asimtrico.
Qu tipo de procesamientos existen en un sistema multiprocesador?
Describa brevemente cada uno de los que nombre.
Respuesta:
Multiprocesamiento simtrico: el ncleo del sistema operativo puede correr en cualquier
procesador.
Multiprocesamiento asimtrico: cada procesador tiene asignadas tareas especficas. Existe un
procesador maestro donde corre el ncleo del sistema.
Examen julio 2005:
En una arquitectura multiprocesador, sera conveniente utilizar un sistema operativo cuyas
primitivas o servicios no sean en su mayora reentrantes?. Justifique. Respuesta: No, dado que el
cdigo no reentrante si es ejecutado simultneamente por ms de un proceso puede generar
inconsistencias.
En un equipo multiprocesador que dispone de 4 procesadores, se instal un sistema operativo
basado en multiprocesamiento simtrico. Los procesos del sistema operativo pueden ejecutar en
cualquiera de ellos, o son restringidos a ser ejecutados en algn procesador especfico?
De estar restringido, describa como se organiza la estructura de los procesadores.
Respuesta:
Al ser un sistema operativo simtrico (SMP) los procesos del sistema operativo pueden ejecutar
en cualquier procesador sin restricciones.
Examen febrero 2008:
En un equipo multiprocesador, qu beneficio se obtiene el tener un sistema operativo simtrico
frente a uno asimtrico?
Los sistemas multiprocesadores se caractrizan en dos tipos:
Sistemas UMA (Uniform Memory Access): acceso uniforme a la

memoria. Cada procesador accede a cualquier lugar de memoria a la
misma velocidad.
Sistemas NUMA (Non-Uniform Memory Access): acceso no
uniforme a la memoria. Los procesadores tienen un conjunto de
memoria a la cual acceden ms rpido que el resto.

Mencione el principal problema que debe enfrentar un sistema operativo si ejecuta sobre un
equipo multiprocesador, con una nica memoria comn.
Respuesta:
El principal desafo es proteger las secciones crticas del sistema operativo. Esto no era un
problema cuando haba un solo procesador y a lo sumo un proceso del sistema ejecutando en un
momento dado.
2.8 SistemasCluster
Son sistemas donde participan varios nodos. Se enfocan en brindar alta
disponibilidad y balance de carga.
Los nodos estn interconectados por varios canales para verificar (monitorear) el
estado de cada uno.
Los cluster de alta disponibilidad se pueden estructurar en simtricos o
asimtricos:
19
FINGUDELAR
Simtricos: todos los nodos ejecutan tareas y asumen las de otros

ante fallas (activo-activo).
Asimtricos: existen nodos primarios donde se ejecutan las tareas y
nodos secundarios que estn a la espera de una falla para asumir el rol
de primario (activo-pasivo).
2.9 SistemasdeTiempoReal
En sistemas de este tipo estricto, todo resultado debe producirse en un cierto
tiempo, o de lo contrario el sistema falla.
En la prctica, sistemas de tiempos compartido con prioridades dinmicas y
despacho preemptivo en general pueden ser utilizados en estas condiciones ya que
adems se pueden utilizar como de propsito general.
2.10 SistemasMultimedia
Sistemas especializados en la incorporacin de datos multimedia (audio y video).
Estos tipos de datos deben reproducirse bajo ciertas restricciones de tiempo.
2.11 SistemasdeMano
Sistemas PDA (Personal Digital Assistant) como PALMs, Pocket-PCs, telefona
mvil. Utilizan sistemas operativos embebidos que tienen grandes limitaciones de
recursos y altos requerimientos de prestaciones.
Examen abril 2003:
Describa las principales caractersticas de los siguientes tipos de sistemas operativos:
1. Por lotes
2. Interactivos
3. De tiempo compartido
4. De tiempo real
5. Distribuidos
Respuesta:
Por lotes
Recibe un flujo de trabajos separados, los ejecuta y vuelca los resultados de los mismos,
devolvindolos por una impresora, medio de almacenamiento o similar. Se caracterizan
por la ausencia de interaccin
entre el usuario y el trabajo en tanto que este se ejecuta. El trmino "por lotes" se
refiere a un modelo en que los trabajos similares se agrupaban en lotes, a fin de reducir
el tiempo total dedicado a preparar
el computador entre distintos trabajos. Los sistemas modernos no presentan esta
limitacin.
Interactivos
Provee una comunicacin en lnea entre el usuario y el sistema, donde el usuario da
instrucciones al sistema o a las aplicaciones, y recibe una respuesta a la misma.
De tiempo compartido
Es un caso particular de la multiprogramacin, donde la CPU es compartida entre los
procesos con una frecuencia alta, presentndose al usuario como si este tuviera su
propio computador.
De tiempo real
En general se usan para el control de aplicaciones dedicadas. Tiene restricciones
temporales bien definidas, por lo que si el procesamiento no se lleva a cabo dentro de
lmites esperados, el sistema falla.
Distribuidos
Son un conjunto de computadoras independientes (desacopladas en cuanto a hardware,
no comparten memoria ni reloj) comunicadas por una red, que se presentan al usuario
en la mayor medida que sea posible, como un nico sistema. Su motivacin son
compartir recursos (mejorar la utilizacin) y aumentar tanto la escalabilidad como la
confiabilidad.
Examen marzo 2004:
20
FINGUDELAR
Describa brevemente: sistemas batch, sistemas de tiempo compartido, sistemas de tiempo real y
sistemas distribuidos.
Defina brevemente: sistema distribuido y sistema de tiempo real.
Respuesta:
Sistema distribuido:
Sistema operativo fuertemente acoplado en software y dbilmente acoplado en
hardware, donde los procesadores no comparten memoria fsica ni reloj. El objetivo es
compartir recursos, compartir cargas, sostener
la comunicacin entre procesos y usuarios, y aumentar la confiabilidad del
conjunto.
Sistema de tiempo real:
Sistema que tiene restricciones temporales bien definidas, a diferencia de los sistemas
por lotes o de tiempo compartido. La ejecucin para considerarse correcta debe hacerse
dentro de un margen de tiempo definido. Generalemente se utilizar ROM en vez de
almacenamiento secundario. Suelen utilizarse para aplicaciones dedicadas.
21
FINGUDELAR
3 EstructuradelosSistemasde
Computacin
3.1 Componentesdeunsistema
CPU (procesador)
Unidad central de procesamiento (procesador).
La velocidad del CPU es varios rdenes mayor con respecto al acceso a memoria.
Memoria
Permite mantener la informacin disponible.
Existe una Jerarqua de memoria: registros, caches, memoria fsica de
tipo RAM (Random Access Memory), dispositivos magnticos y pticos.
Dispositivos de Entrada/Salida
(IO)
Permiten interactuar con el
sistema. Algunos dispositivos:
Impresoras, teclados, ratn,
video, discos duros, etc.
3.1.1 CPU(procesador)
La unidad central de procesamiento es la que ejecuta los programas. En un
sistema puede haber ms de una.
El ciclo bsico consiste en tomar la instruccin apuntada por el PC (program
counter) (fetching), decodificarla para determinar su tipo y operandos (decoding),
ejecutarla (executing), y luego continuar con la siguiente instruccin.
Arquitecturas modernas aumentan la performance ejecutando las operaciones en
paralelo (fetching, decoding, executing). Esta tcnica es conocida como pipeling. Cada
CPU ejecuta un conjunto de instrucciones especfico(verificar).
Existen varias arquitecturas de procesadores, se clasifican en RISC (Reduced

Instruction Set Computer) y CISC (Complex Instruction Set Computer). Algunas
arquitecturas: SPARC, x86, Power, Itanium.
La velocidad del procesador es varios rdenes de magnitud mayor que la
velocidad de acceso a informacin que est en memoria voltil (RAM). Esto implic la
creacin de registros a nivel del procesador y finalmente una cache de memoria
(caches de 1er. nivel, 2do. nivel y hasta 3er. nivel).
Los registros son la memoria ms rpida que accede un procesador y estn
integrados al chip.
En los ltimos aos han surgido procesadores que en un mismo chip contienen
varios cores de ejecucin. Esto ha llevado a una nueva terminologa: single-core,
dual-core, quad-core, etc.
Instrucciones
Operador Operandos...
22
FINGUDELAR
Los operandos pueden ser inmediatos, registros, relativos, de memoria DS:[SI]
segn diferentes tcnicas. (visto en Arquitectura de sistemas).
Las familias de instrucciones incluyen: aritmticas, lgicas, transferencia control
(Jmp, Call, Loop, etc), de memoria, de stack, de sincronizacin (loopz Lock:XChg ax) y
de entrada y salida.
Dentro del mismo chip del procesador se incluyen registros de rpido acceso:
Registros punto fijo y punto flotante (decimal o no).
Registros de direccionamiento ES, SS, DS, CS, etc.
Registro de Estado. Incluye PC y banderas con Zero, Carry.
Caches:
1er. Nivel (del orden de 20 Kb).
2do. Nivel (del orden de 512Kb a 2Mb).
3er. Nivel (del orden de 8Mb).
Instrucciones Privilegiadas
Se establecen niveles de ejecucin y conjunto de instrucciones para cada nivel.
Un protocolo seguro para aumentar el nivel de ejecucin que se basa en siempre
transferir el control a cdigo autenticado (trusted) para aumentar el nivel de
ejecucin.
Familias de E/S, proteccin de memoria, memoria virtual.
Interrupciones
Capacidad de procesar interrupciones.
El sistema operativo preserva el estado actual (previo a la interrupcin) del
procesador (registros, etc.).
Se determina qu tipo de interrupcin ocurri.
Se ejecuta la rutina de atencin correspondiente.
3.1.2 Memoria
El sistema de memoria se construye en base a una jerarqua, lo que permite
mejorar la utilizacin del procesador:
23
FINGUDELAR
3.1.2.1 Cache
El cache es un principio muy importante, es utilizado a varios niveles en el sistema
de computacin (hardware, sistema operativo, software).
El concepto es mantener una copia de la memoria que est siendo utilizada en un
medio temporal de mayor velocidad.
El medio de memoria cache es mucho menor y mas veloz que el dispositivo
principal. Esto genera que el manejo de cache sea un problema de diseo
importante.
El tamao del cache y sus polticas de reemplazo tienen un alto impacto en la
mejora real de la performance.
Examen marzo 2007:
Qu entiende por memoria cache?
Coherencia de cache
Un problema que introduce la memoria cache en ambientes de multiprocesadores,
es la coherencia y consistencia de los datos que estn replicados. Caches en
multiprocesadores:
Mayor rendimiento, no se satura el bus del sistema (cuello de botella).

An en un mono procesador, hay que contemplar a los controladores
de dispositivos.
Problemas de coherencia entre caches, ya que una palabra puede
estar replicados en diferentes cache de los procesadores.
A su vez, en sistemas multiprocesadores el problema de coherencia se
torna mucho ms complicado.
Surgen tcnicas como write-update, write-invalidated
Examen julio 2005:

En una arquitectura multiprocesador, describa las ventajas y desventajas de contar con cache a
nivel de los procesadores.
Respuesta:
La cache a nivel de procesador incrementa el desempeo ya que los procesadores pueden
obtener los datos de la cache (copias de los datos en memoria principal) y evitar la bsqueda en
la memoria principal. Por otro lado, se debe mantener la coherencia entre los datos de las caches
lo cual vuelve ms complejo el hardware necesario.
3.1.2.2 Memoriaprincipal(RAM)
Memoria de tipo voltil, direccionable a palabra o byte.
Palabra de 32, 48, 64 bits con paridad.
Transferencia en un ciclo del bus y acceso interlaceado (interleaving) a ms de un
mdulo de memoria.
Existen instrucciones que toman como argumentos direcciones e memoria.
Es til tambin para hacer transferencias con controladoras de dispositivos. Las
controladoras tienen su propio buffer de memoria, y existen instrucciones de E/S que
permiten la transferencia directa desde el buffer a memoria principal (ver DMA).
3.1.2.3 Discosmagnticos(harddisk)
Dispositivos de velocidad de acceso mucho menor que la memoria principal, pero
de mayor capacidad.
Tiene componentes mecnicas a diferencia de la memoria principal, cache y
registros. Consta de platos de metal (10000 ms rpm) y un brazo mecnico que
contiene las cabezas de lectura/escritura para cada plato.
24
FINGUDELAR
Pistas (tracks): La superficie de los platos es dividida lgicamente en

pistas circulares.
Sectores (sectors): Cada pista es dividida en un conjunto de
sectores.
Cilindros (cylinder): El conjunto de pistas (de todos los platos) que
estn en una posicin del brazo mecnico forman un cilindro
La velocidad del disco se compone de dos partes:

Tasa de transferencia (transfer rate): es la tasa con la cual los
datos van entre el disco y la computadora.
Tiempo de posicionamiento (positioning time): es el tiempo que
se tarda en ubicar el brazo en el cilindro adecuado (seek time), ms el
tiempo de rotar el plato al sector adecuado (rotational latency).
La unidad de transferencia es el bloque. Ocasionalmente los bloques pueden estar
con interleaving.
Existen distintos tipos de buses de conexin:
IDE (Integrated drive electronics),
ATA (Advanced Technology Attachment)
SCSI (Small Computer-Systems Interface)
SAS (Serial Attached SCSI)
3.1.3 DispositivosdeEntrada/Salida(IO)
Los dispositivos, por lo general, constan de una controladora y el dispositivo en s.
25
FINGUDELAR
La controladora es un chip que controla fsicamente al dispositivo. Acepta
comandos del sistema operativo y los ejecuta (genera las correspondientes seales
sobre el dispositivo para realizar la tarea).
La interfaz que le presenta la controladora al sistema operativo es bastante ms
simple que la provista por el dispositivo.
En un sistema existen distintas controladoras (de discos, red, etc.), por eso es
necesario distintos componentes de software para manejar cada uno.
3.1.3.1 DeviceDrivers
Al software que se comunica con la controladora se le denomina device driver.
Para cada controladora se debe de proveer el device driver adecuado. Estos son
incorporados al sistema operativo dado que son la va de comunicacin con los
dispositivos.
Examen marzo 2005:
Qu es lo que implementan los manejadores de los dispositivos (device drivers)? Forman parte
del sistema operativo?. Justifique.
Respuesta:
Implementan primitivas definidas por el sistema operativo utilizando el lenguaje del dispositivo.
S, el sistema operativo es el encargado de administrar el hardware, y de presentar al usuario una
interfaz para el uso de los distintos componentes del sistema.
a. Los manejadores de dispositivos (device drivers) son un componente de hardware o
software?
b. Cul es su funcin principal?
Respuesta:
a.Software.
b. Hacer la traduccin de los pedidos que el sistema realiza sobre el dispositivo dialogando con
la controladora del dispositivo. El manejador de dispositivo (device driver), por lo general,
implementa un conjunto de primitivas de alto nivel (impuestas por el sistema operativo), que
realizan la traduccin de los pedidos y respuestas que genera el sistema. Para esto, es necesario
que se pueda comunicar con el controlador del dispositivo en el lenguaje que ste propone.
Los device drivers son cargados de diferentes formas:
Ensamblarlos estticamente al ncleo del sistema.

Cuando se carga el sistema se lee un archivo de configuracin que dice
cules device drivers cargar.
Cargar dinmicamente a demanda.
Las controladoras contienen un conjunto de registros que sirven para comunicarse

con ella y ejecutar comandos. Ej.: la controladora de un disco podra tener registros
para especificar la direccin en disco, la direccin en memoria principal, el nmero
de sectores y el sentido (lectura y escritura).
Acceso a los registros de la controladora:
Memory-mapped-IO: Los registros son mapeados a direcciones de
memoria principal.
Direct IO instructions: A los registros se les asigna una direccin de
puerto (IO port address).
3.1.3.2 MemorymappedIO
Para facilitar el acceso a registros de los dispositivos, se reserva un espacio de la
memoria principal que mapea a los registros del dispositivo.
26
FINGUDELAR
Leer o escribir en los registros de los dispositivos se traduce en leer o escribir
sobre las direcciones de memoria. Al operar sobre estas direcciones de memoria se
genera la transferencia a los registros del dispositivos en forma transparente.
Las direcciones de memoria deben ser puesta fuera del alcance de los procesos
del usuario.
Ej.: La pantalla es mapeada a un lugar de memoria. Para desplegar un
carcter en pantalla solo basta con escribir sobre el lugar correcto de la
memoria principal.
3.1.3.3 IOportaddress
A cada registro se le
asigna una direccin de
puerto.
El sistema cuenta con
instrucciones
privilegiadas IN y OUT
que permiten a los device
drivers leer o escribir en
los registros de la
controladora.
La instruccin genera
seales en el bus del
sistema para seleccionar
el dispositivo adecuado.
3.1.3.4 Comparacindeacceso
Los sistemas manejan los dos mtodos de accesos a los registros de la
controladora.
El acceso memory-mapped IO no necesita de instrucciones privilegiadas.
El acceso a travs de instrucciones tiene la ventaja de no consumir memoria
principal.
3.1.3.5 Interaccinconlacontroladora
Mtodos para efectuar una operacin de entrada-salida:
Espera activa (Polling): El procesador le comunica un pedido a la
controladora del dispositivo y queda en un busy waiting consultando
a la controladora si est listo el pedido.
Interupciones (Interrupts): El procesador le comunica el pedido a la
controladora y se libera para realizar otras tareas. Al culminar el
pedido el dispositivo, la controladora genera una interrupcin al
procesador.
Acceso directo a memoria (DMA Direct Memory Access): Se
utiliza un chip especial que permite transferir datos desde alguna
controladora a memoria sin que el procesador tenga que intervenir en
forma continua.
3.1.3.5.1
Polling
El sistema queda en busy waiting consultando un registro del controlador para

saber si est listo.
27
FINGUDELAR
Ej.: Imprimir un buffer en una impresora.
p = copy_from_user(buffer, k_buffer, count);
for (i = 0; i < count; i++) {
while (*printer_status_reg != READY) ;
*printer_data.register = p[i];
}
return_to_user();
3.1.3.5.2
Interrupciones
El sistema se independiza del controlador, que genera una interrupcin cuando

finaliza el pedido.
Es necesario tener un vector de rutinas de atencin de interrupciones (interrupt
vector), que es cargado cuando se inicia el sistema operativo.
while (*printer_status_reg != READY) ;
i = 0;
scheduler();
Ej.: Rutina de atencin de la interrupcin.
if (i == count)
unblock_user();
else {
i++;
}
return_from_interrupt();
3.1.3.5.3
DMA
Se dispone de un dispositivo especializado que permite realizar transferencias

desde ciertos dispositivos a memoria. La transferencia sea hace en paralelo mientras
el procesador realiza otras tareas.
El procesador carga ciertos registros en el controlador DMA para realizar el
pedido. El controlador DMA se encarga de la tarea de transferencia, interrumpiendo
al procesador cuando finaliz.
set_up_DMA_controller();
scheduler();
Ej.: Rutina de atencin de la interrupcin de DMA.
unblock_user();
28
FINGUDELAR
Describa dos mtodos a travs de los cules el sistema operativo se entera de que un dispositivo
de E/S ha finalizado un pedido generado por el sistema operativo, mencionando las principales
caractersticas de cada uno y compare los mismos.
Respuesta:
Polling (Nota: ver si hay diferencia con Programmed I/O) e Interrupciones.
Polling:
El sistema realiza el pedido y queda en una iteracin consultando el busy bit del
controlador del dispositivo hasta que este quede limpio (seal que finaliz).
Interrupciones:
El sistema realiza el pedido y ser avisado de la finalizacin a travs de una
interrupcin.
El polling tiene como desventaja el hacer busy waiting. Ciclos de CPU sern desperdiciados. En
cambio el mtodo de interrupciones permite ejecutar otros procesos mientras el dispositivo
realiza el pedido. El polling sera til en casos en que el dispositivo est libre y que tenga mayor
velocidad que la del procesador. Las interrupciones permiten un manejo asincrnico y adems
permiten ser atendidas cuando el sistema operativo lo crea conveniente.
Describa 3 mtodos para efectuar una operacin de Entrada/Salida. (Formas de interaccin con la
controladora del dispositivo).
3.2 ProteccindeHardware
Con la introduccin de sistemas multiprogramados y multiusuarios se empezaron
a generar problemas debido a procesos mal programados o mal intencionados.
Fue necesario la introduccin de proteccin entre los distintos procesos que
ejecutaban en un sistema.
El hardware fue proveyendo a los sistemas operativos de mecanismos para la
proteccin:
Modo Dual: se provee de al menos dos modos de operacin.

Proteccin de E/S: todas las instrucciones de Entrada/Salida son
privilegiadas.
Proteccin de Memoria: evaluacin de las direcciones de memoria a
travs de la MMU.
Proteccin de CPU: introduccin de un timer que permite limitar el
uso de CPU.
Examen julio 2005:

De qu forma se puede garantizar que todos los accesos a los dispositivos, por parte de un
proceso, se deban hacer a travs del sistema operativo?
Respuesta:
Obligando a que las instrucciones de hardware que acceden al dispositivo sean privilegiadas. De
estar forma, solo el sistema operativo puede ejecutarlas.
Examen marzo 2006:
En los sistemas multiprogramados y multiusuarios pueden existir problemas por procesos mal
programados o mal intencionados. Esto puede llevar al sistema a un estado inconsistente.
Enuncie y comente brevemente distintos mecanismos provistos por hardware que permiten
protegerse de este tipo de programas.
El modo de ejecucin provisto por hardware permiten brindar proteccin entre los procesos.
Describa dos formas ms de proteccin que se proveen a nivel de hardware.
Examen marzo 2008:
Describa dos mecanismos de proteccin que le brinda el hardware al sistema operativo.
3.2.1 ModoDual
El hardware provee de dos modos de ejecucin:
29
FINGUDELAR
Modo usuario (user mode): en este modo de ejecucin se puede

ejecutar un conjunto reducido de instrucciones de hardware. Los
procesos a nivel de usuarios ejecutan en este modo.
Modo monitor (monitor mode): en este modo todas las
instrucciones de hardware estn disponibles. El sistema operativo es el
nico que debe ejecutar en este modo.
Un bit, llamado mode bit, es agregado al hardware para indicar el modo actual.
La ejecucin de instrucciones privilegiadas en el modo monitor garantiza que los
procesos, a nivel de usuario, no accedan directamente a los dispositivos de E/S.
El acceso a un dispositivo se realiza a travs de los servicios que brinda el sistema
operativo (syscall).
La solicitud de un servicio al sistema operativo es tratado como una interrupcin a
nivel de software (trap), y en ese momento el sistema pasa de modo usuario a modo
monitor.
En Intel la instruccin int $0x80 genera el cambio de modo.
Posteriormente, se ejecuta el handler de la excepcin 0x80 (128 decimal).
Esquema grfico del cambio de modo:
Examen marzo 2003:

Por que es necesario contar con dos modos de ejecucin distintos como ser modo supervisor y
modo
usuario?. Explique en detalle los procedimientos que permiten garantizar la integridad de un
sistema
operativo multiusuario.
Repuesta:
Para asegurar la ausencia de inteferencias entre procesos, en particular la memoria en un
ambiente de multiprogramacin, donde es compartida entre distintos programas y el mismo
sistema. Es posible definiendo un conjunto de instrucciones privilegiadas que el hardware
permite ejecutar slo en modo supervisor, y un protocolo que para aumentar el nivel de ejecucin
transfiere el control a cdigo autenticado del kernel.
Qu permite el bit de modo provisto a nivel de hardware?
Respuesta:
El bit de modo permite tener dos modos de ejecucin: modo monitor y modo de usuario.
El sistema operativo ejecuta en modo monitor y los procesos de usuario ejecutan en modo de
usuario.
De esta forma, se permite proteger el sistema de programas que funcionan mal.
3.2.2 ProteccindeE/S
Es necesario proteger al sistema de que los procesos a nivel de usuario no
accedan directamente a los dispositivos, sino que deben hacerlo a travs del SO.
30
FINGUDELAR
Todas las instrucciones de E/S se definen como privilegiadas.
Asegurarse que un programa a nivel de usuario nunca pueda lograr cambiar el
modo a monitor. Un usuario podra ingresar una nueva interrupcin, modificar una ya
existente, o cambiar el vector de interrupcin y luego generar un trap (interrupcin
por software) para que ejecute.
3.2.3 ProteccindeMemoria
Es necesario proteger la memoria del ncleo (p.ej.: el vector de interrupciones) y,
a su vez, proteger el acceso de memoria entre los distintos procesos (un proceso no
debera acceder a la memoria de otro).
El sistema debe lograr saber si cada direccin generada por un proceso es vlida.
Para esto se necesario de dos registros:
Base: Contiene la direccin de memoria fsica ms baja que puede
acceder.
Lmite: Contiene el tamao del memoria a partir del base.
Esquema grfico de la proteccin a travs de registros base y lmite:
Cada direccin fsica generada por la CPU debe ser controlada para comprobar si
es una direccin vlida. En caso de una acceso invlido se genera un trap al sistema
operativo.
La unidad que hace convierte direcciones lgicas a fsicas es la MMU (Memory
Management Unit), y es la que controla el acceso a memoria.
Los unidad MMU nicamente debe ser administrada en modo monitor. Por ejemplo
cargar los registros base y lmite.
Explique porqu debe protegerse el vector de interrupciones y las rutinas de procesamiento de
las interrupciones. Cmo se logra esta proteccin mediante hardware?
Respuesta:
Porque un programa de usuario (malintencionado) podra modificarlos para que le retornen el
control a l, y as pasar a ejecutar en modo monitor. Una forma posible de hacerlo es con
registros base y lmite que indiquen el intervalo de direcciones legales de cada proceso. El
hardware de CPU verifica que cada direccin generada por el proceso est en el intervalo, y si no,
se generar una trap, y el sistema abortar el proceso. Este mecanismo tambin protege los
programas entre s.
3.2.4 ProteccindeCPU
Una vez que a un proceso se le asigna el recurso procesador, puede entrar en una
iteracin infinita (infinite loop) y no retornar nunca ms el control al sistema.
Deben existir mecanismos de proteccin del uso del procesador.
31
FINGUDELAR
Una alternativa es la utilizacin de un timer que interrumpa el procesador cada
cierto tiempo (watch dog timer).
El sistema operativo al asignar la CPU carga un contador. Cada vez que la
interrupcin de timer se genera se ejecuta la rutina de atencin correspondiente.
En la rutina de atencin de la interrupcin el contador es decrementado
(envejecimiento). Si llega al valor 0, se le quita el recurso procesador al proceso y se
invoca al planificador.
La instruccin que permite cargar el contador es privilegiada.
Cmo se protege el excesivo uso de CPU por parte de un proceso?
Respuesta:
A travs de un timer. Cada cierta interrupcin a nivel de hardware.
En un sistema computacional, qu permite la proteccin de CPU? Respuesta: La proteccin de
CPU permite que los procesos no se apoderen de forma indefinida del recurso procesador. Si no
se existiera en una ambiente de tiempo compartido, los procesos podran hacer un uso excesivo
del procesador, limitando a otros del recurso.
3.3 Red
Las redes se pueden clasificar, bsicamente, en dos tipos:
Red LAN (Local Area Network): son pequeas y su alcance est

limitado por lo general a no ms de un edificio. Velocidades de 10, 100
1000 Gbits/s.
Red WAN (Wide Area Network): las redes WAN son redes
distribuidas sobre una regin grande. Velocidades de 1,5 a 100 Mbits/s.
La diferencia principal es cmo estn geogrficamente distribuidas.
3.3.1 LANLocalAreaNetwork
Son redes que interconectan sistemas a corta distancia y se tiende a tener
interconexiones de alta velocidad con baja tasa de error.
3.3.2 WANWideAreaNetworks
Son redes que interconectan sistemas remotos. Los enlaces por lo general son
provistos por empresas de telecomunicaciones.
32
FINGUDELAR
3.3.3 Topologasdered
Las redes pueden estar interconectadas de diferentes formas
Esto depender de:
Costos bsicos: qu costo a nivel monetario implica interconectar la

red.
Costo a nivel de comunicacin: qu tiempo lleva enviar un mensaje
desde un nodo a otro de la red.
Nivel de confianza: qu tan
resistente es la red ante
eventuales fallos de
componentes.
Las topologas que se implementen

dependern de estas tres variables.
Esquema grfico de algunas
topologas ms comunes:
Examen marzo 2005:

Describa lo que entiende por sistema altamente acoplado/integrado. Respuesta: Es un sistema
multiprocesador en donde los procesadores comparten un bus comn de alta velocidad, el reloj,
la memoria y los dispositivos.
Examen diciembre 2005.
Cules son las principales actividades del sistema operativo relacionadas con manejo de
memoria principal? y cules son las relacionadas con el manejo de volmenes y archivos
Respuesta:
o Manejo de Memoria principal
Mantener registros de qu partes de la memoria estn siendo utilizados y
por quin.
Decidir qu procesos sern cargados en memoria cuando quede espacio
libre.
Asignar y quitar espacio de memoria de acuerdo a la necesidad.
o Manejo de volmenes y archivos:
Definir, eliminar, incorporar volmenes. Administracin de volmenes.
33
FINGUDELAR
Creacin y eliminacin de archivos.
Creacin y eliminacin de directorios.
Soportar primitivas para la manipulacin tanto de archivos como de
directorios.
Mapeo de archivos en el almacenamiento secundario.
Respaldos de archivos en medios de almacenamiento estables (no voltiles)
34
FINGUDELAR
4 EstructuradelosSistemasOperativos
4.1 Componentesdelsistemaoperativo
Por su complejidad un sistema operativo debe ser, en su implementacin,
modularizado en varios componentes:
Administracin de procesos.
Administracin de memoria.
Subsistema de E/S.
Administracin de almacenamiento secundario.
Subsistema de archivos.
Subsistema de red.
Sistema de proteccin.
Intrprete de comandos.
4.1.1 Administracindeprocesos
Proceso:
Un programa en la memoria + CPU + dispositivos + recursos constituyen un
proceso.
Un programa es una entidad pasiva, mientras que un proceso es una entidad
activa.
Cada proceso cuenta con un contador de programa (PC program counter) que
determina la prxima instruccin de cdigo a ejecutar.
El proceso necesita de ciertos recursos (CPU, memoria, archivos, y dispositivos de
E/S) para realizar su tarea.
El sistema albergar muchos procesos compitiendo por los recursos y ser el
responsable de proveer de medios o servicios para que realicen su tarea:
Crear y destruir procesos.
Suspensin y reanudacin de procesos.
Proveer mecanismos para la cooperacin (sincronizacin) y
comunicacin entre los procesos.
Proveer mecanismos para prever la generacin de deadlocks o lograr
salir de ellos.
4.1.2 Administracindememoria
La memoria principal es un arreglo de palabras o bytes.
Es un repositorio de datos de rpido acceso compartido por los CPUs y los
dispositivos.
La memoria es un rea de almacenamiento comn a los procesadores y
dispositivos del sistema dnde se almacenan programas, para su ejecucin, y datos.
El vincular programas a direcciones absolutas es fuertemente dependiente del
hardware igual que la posibilidad de reubicacin.
El sistema deber administrar el lugar libre y ocupado, decidir qu proceso podr
comenzar cuando es cargado en memoria.
Para lograr la multiprogramacin es necesario mantener varios programas en
memoria al mismo tiempo.
35
FINGUDELAR
Existen varios esquemas para la administracin de la memoria y requieren distinto
soporte del hardware.
El sistema operativo es responsable de las siguientes tareas:
Mantener qu partes de la memoria estn siendo utilizadas y por
quin.
Decidir cules procesos sern cargados a memoria cuando exista
espacio de memoria disponible.
Asignar y quitar espacio de memoria segn sea necesario.
Examen julio 2003:
Describa los principios y beneficios en que se sustenta la multiprogramacin, mencionando qu
soporte de hardware requiere.
Describa 2 actividades que son principales en la administracin de la memoria de un computador
4.1.3 SubsistemadeE/S
El sistema operativo deber encapsular y ocultar las caractersticas especficas de
los diferentes dispositivos de almacenamiento y ofrecer servicios comunes para
todos los medios de almacenamiento.
Para ello proveer de:
Un conjunto de servicios que provean la interfaz con el subsistema e

implementen tcnicas de cache, buffering y spooling.
Una interfaz cliente con el sistema operativo para los manejadores de
dispositivos o device drivers que permitir interactuar (mediante
cargas dinmicas) con cualquier modelo de dispositivo.
Device drivers especficos.
Montaje y desmontaje (Mount/Dismount) de dispositivo
Examen marzo 2006:

a) Qu es un buffer?
b) Qu ventajas brinda el uso de la tcnica de buffering a nivel del sistema operativo?
Respuesta:
a. Es un rea de memoria que sirve para guardar datos mientras son transferidos entre
dispositivos o entre un dispositivo y un proceso.
b. - Salvar la distancia de velocidades entre diferentes dispositivos. - Adaptar la diferencia en el
tamao de la transmisin de datos de los dispositivos mediante tcnicas de bloqueo. Adelantarse en la lectura obteniendo datos antes de que sean requeridos.
Examen marzo 2007:
Qu entiende por spooling?
Respuesta:
es un buffer que permite guardar informacin mientras se efecta una transferencia entre dos
dispositivos, o entre un dispositivo y una aplicacin.El dispositivo que recibe la informacin no
permite que sea intercalada.
4.1.4 Administracindealmacenamientosecundario
La memoria principal es voltil y demasiado pequea para guardar todos los datos
y programas que son necesarios para el funcionamiento del sistema.
La mayora de los sistemas actuales utilizan discos como principal medio para
guardar toda la informacin.
El sistema operativo es responsable de las siguientes actividades en
administracin de almacenamiento secundario:
Administrar el espacio libre.
Asignacin del lugar de la informacin.
36
FINGUDELAR
Algoritmos de planificacin de disco.
4.1.5 Subsistemadearchivos
Proporciona una vista uniforme de todas las formas de almacenamiento en los
diferentes dispositivos implementando el concepto de archivo como una coleccin
arbitraria de bytes u otras clases o organizaciones mas sofisticadas aunque
habitualmente obsoletas.
Implementar los mtodos de:
Abrir, Cerrar, Extender.
Leer, Escribir.
4.1.6 Red
En un sistema distribuido (no se comparten fsicamente memoria ni dispositivos)
los conjuntos de procesos interactan a travs de un canal de comunicacin en el
contexto de una red de comunicacin.
En general se generaliza el concepto de dispositivo virtual implementando un
driver que encapsula el acceso a dispositivos remotos.
4.1.7 Sistemadeproteccin
En un sistema multiusuario donde se ejecutan procesos en forma concurrente se
deben tomar medidas que garanticen la ausencia de interferencia entre ellos.
Por proteccin nos referimos a los mecanismos por los que se controla al acceso
de los procesos a los recursos.
El mecanismo debe incorporar la posibilidad de definir reglas de acceso y
asegurar su verificacin en toda ocasin que corresponda.
4.1.8
Intrprete de comandos.
La interfaz con el usuario se implementa en trminos de un intrprete de comandos dispuesto en el ncleo

del sistema operativo o como un programa con privilegios especiales.
En sistemas de caracteres, la caracterizacin principal del sistema operativo es en funcin de su intrprete
de comandos. Ocasionalmente, algunos sistemas tuvieron ms de un intrprete de comandos de forma de
simular otros (aunque lo relevante es la interfase con el kernel).
Los intrpretes pueden implementar la mayora de los comandos o en su defecto invocar programas que
implementen el servicio (o algo intermedio).
El costo beneficio ser en funcin del tamao del mismo, y hay que determinar si se carga una sola vez en
el sistema o una para cada usuario.
Sistemas modernos han implementado el shell con una interfaz grfica donde el desplazamiento del ratn
sobre imgenes produce la ejecucin de comandos, apertura de mens, etc.
En su implementacin, se requerirn los diferentes servicios del ncleo (de procesos, IPC, seguridad,
archivos, etc.) para implementar las diferentes funcionalidades ofrecidas.
4.2 ServiciosdelSO
El sistema brindar un entorno de ejecucin de programas donde se
dispondr de un conjunto de servicios que sern accesible mediante una interfaz
bien definida.
Servicios bsicos que debe brindar un sistema operativo:
1.
2.
3.
4.
5.
Ejecucin de programas.
Operaciones de Entrada/Salida.
Manipulacin de sistemas de archivos.
Comunicacin entre procesos.
Manipulacin de errores (excepciones).
37
FINGUDELAR
4.2.1 Ejecucindeprogramas
El sistema debe ser capaz de cargar un programa a memoria y ejecutarlo.
El programa deber poder finalizar su ejecucin y finalizar de forma normal o
anormal (indicando un error).
4.2.2 OperacionesdeEntrada/Salida
Un programa en ejecucin necesitar de operaciones de E/S para acceder a un
archivo o dispositivo. Por eficiencia y proteccin los usuarios no accedern
directamente al dispositivo. El sistema deber proveer un mecanismo de acceso.
4.2.3 Manipulacindesistemasdearchivos
Los programas necesitarn leer y escribir archivos. A su vez, se debern crear o
borrar archivos.
4.2.4 Comunicacinentreprocesos
Los procesos podrn poder comunicarse. Se deber proveer mecanismos de
comunicacin entre ellos ya sea que estn en el mismo computador (a travs de
memoria compartida), o en diferentes computadores (a travs de transferencias de
paquetes entre los sistemas operativos involucrados).
4.2.5 Deteccindeerrores
El sistema deber tomar decisiones adecuadas ante eventuales errores que
ocurran (fallo en un dispositivo de memoria, fallo en la fuente de energa, etc.).
4.2.6 PropsitoGeneral
Otros servicios de propsito general para el adecuado funcionamiento del sistema
son:
Asignacin de recursos.
Contabilizacin.
Proteccin.
Una vez que estn definidos los servicios que brindar, la estructura del sistema
operativo puede empezar a desarrollarse.
Describa 3 servicios que debe proveer el sistema operativo
Examen juio 2005:
Describa tres servicios que debe brindar el sistema operativo.
describa los 5 servicios bsicos que debe brindar un sistema operativo
4.3 Llamadosalsistema
Los llamados al sistema (system calls) son una interfaz, provista por el ncleo,
para que los procesos de usuarios accedan a los diferentes servicios que brinda el
sistema operativo.
Qu son los llamados al sistema (system calls)?
Examen julio 2005:
38
FINGUDELAR
Qu son los llamados al sistema (system calls)? Respuesta: Los llamados al sistema proveen una
interfaz entre los procesos y el sistema operativo a travs de la cual los procesos pueden acceder
a los servicios que ste brinda.
Examen marzo 2006:
Qu son los denominados "llamados a sistema" (system calls)?
Al principio los system calls estaban programados en lenguaje ensamblador.

En los sistemas modernos estn programados en lenguajes de programacin
como C o C++. De esta forma, los programas de usuario tienen un acceso ms
directo a los servicios.
Los servicios son invocados por los procesos en modo usuario, cuando ejecutan lo
hacen en modo monitor, y al retornar vuelven al modo usuario.
Tpicamente a los system call se les asocia un nmero.
La llamada de un system call incluye las siguientes tareas:
Cargar los parmetros en el lugar adecuado (Stack).

Cargar el nmero de system call en algn registro especfico (Ej: eax
en Intel).
Invocar a la interrupcin por software (trap) adecuada (system call
handler).
La interrupcin cambia el bit de modo a monitor, controla que el
nmero de system call pasado en el registro sea menor que el mayor
del sistema y, finalmente, invoca al system call correspondiente.
El valor retornado por el system call es puesto en un registro especfico
(Ej: eax en Intel).
Examen julio 2005:

Para hacer un llamado al sistema, es necesario estar en modo monitor o de usuario? Justifique.
Respuesta:
Los llamados al sistema son ejecutados por procesos de usuario y por lo tanto ejecutan en modo
usuario. Para procesar el llamado el sistema operativo trabaja en modo monitor y una vez
finalizado, antes de retornar el control al proceso, vuelve a modo usuario.
Existen 3 formas de pasar los parmetros al sistema operativo:
A travs de los registros. Se utilizan un conjunto de registros para

pasar los parmetros. Tiene el problema de la cantidad de parmetros
es fija y que restringe el tamao del valor. En Intel se utilizan 5
registros: ebx, ecx, edx, esi, y edi.
Un bloque de memoria apuntado a travs de un registro.
En el stack del proceso que realiza el llamado. El proceso guarda
los parmetros con operaciones push sobre el stack y el sistema
operativo los saca con la operacin pop.
39
FINGUDELAR
Los system calls se clasifican en distintos tipos:
Control de procesos.
Cargar, ejecutar, finalizar, abortar, conseguir atributos, cargar
atributos, esperar por tiempo, esperar por un evento o seal,
conseguir o liberar memoria, etc..
Gestin de archivos.
Crear, borrar, abrir, cerrar, leer, escribir, conseguir o cargar
atributos, etc..
Gestin de dispositivos.
Requerir o liberar un dispositivo, leer o escribir, conseguir o cargar
atributos de un dispositivo, etc..
Gestin de informacin.
Conseguir o cargar la hora del sistema, datos del sistema, de
procesos, etc..
Comunicaciones.
Crear o destruir conexiones, enviar o recibir mensajes, etc.
Examen marzo 2005:

Enuncie y describa brevemente 3 tipos de llamados al sistema (system calls).
Los system calls son una forma a los servicios del sistema operativo. Existe alguna otra forma
de acceder a estos servicios por parte de los procesos de usuario?
Respuesta:
no, son la nica forma.
4.4 Estructuradelsistema
La estructura interna de los sistemas operativos pueden ser muy diferentes.
Se deben tener en cuenta:
40
FINGUDELAR
Metas de los usuarios: ser amigable, intuitivo, confiable, seguro,

rpido, etc.
Metas del sistema: fcil de disear, implementar y mantener,
tambin flexible, confiable y eficiente.
Diseo del sistema:

Sistema Monoltico.
Sistema en capas.
Sistema con microncleo (microkernel).
Sistema con mdulos.
4.4.1 SistemaMonoltico
No se tiene una estructura definida.
El sistema es escrito como una coleccin de procedimientos, que pueden ser
invocados por cualquier otro.
No existe ocultacin de informacin ya que cualquier procedimiento puede
invocar a otro.
Si bien todo procedimiento es pblico y accesible a cualquiera, es posible tener
buenos diseos y lograr, de esa forma, buena eficiencia en el sistema.
Ej.: MS-DOS.
Los componentes pueden invocar procedimientos de cualquiera.
Ej.: Linux
Linux es un ncleo monoltico que a logrado un buen diseo orientado a
objetos (sistema modular).
Mencione una ventaja y una desventaja de un sistema monoltico.
Respuesta:
La ventaja es la eficiencia, la desventaja es que la falta de modularizacin lo hace ms difcil de
mantener y portar por parte de los desarrolladores del sistema.
4.4.2 Sistemaencapas.
Se organiza el diseo en una jerarqua de capas construidas una encima de la
otra.
Los servicios que brinda cada capa son expuestos en una interfaz pblica y son
consumidos solamente por los de la capa de arriba.
La capa 0 es el hardware y la N es la de procesos de usuario.
Ventajas:
Modularidad.
Depuracin y verificacin de cada capa por separado.
Desventajas:
Alto costo de definicin de cada capa en la etapa de diseo.
Menos eficiente frente al sistema monoltico ya que sufre de overhead
al pasar por cada capa.
Esquema de un sistema en capas (OS/2)
41
FINGUDELAR
Examen abril 2003:

En el contexto de un sistema operativo diseado en capas, Por que el soporte para la memoria
virtual no utiliza las primitivas de sistemas de archivos ?
Respuesta:
En un sistema operativo correctamente estructurado, habitualmente el filesystem est en una
capa superior a la de gestin de memoria, hecho que inhibe la posibilidad de uso del mismo para
la implementacin de la memoria virtual. En algn escenario, el uso de las primitivas del
filesystem podra implicar un mayor overhead. Si bien esta razn como tal resulta invalida, ya
que la correccin debera ser el hacer eficiente el filesystem.
Examen julio 2005:
En el diseo de un sistema operativo, cul debera haber sido la justificacin de elegir un
sistema monoltico frente a un diseo por capas?
Respuesta:
La necesidad de implementar un sistema con mayor rendimiento. El sistema zooltico es ms
eficiente ya que disminuye la carga de la comunicacin entre capas.
Examen marzo 2008:
Describa brevemente las ventajas/desventajas de los sistemas operativos diseados con el
enfoque monoltico frente al enfoque en capas.
Examen julio 2007:
Describa ventajas/desventajas del diseo de un sistema monolticos frente al sistema en capas
4.4.3 Sistema con microncleo (microkernel).

Se constituye de un ncleo que brinde un manejo mnimo de procesos,
memoria y, adems, provea de una capa de comunicacin entre procesos.
La capa de comunicacin es la funcionalidad principal del sistema.
Los restantes servicios del sistema son construidos como procesos separados al
microncleo que ejecutan en modo usuario.
El acceso los servicios del sistema se realiza a travs de pasaje de mensajes.
Ventajas:
Aumenta la portabilidad y escalabilidad ya que encapsula las

caractersticas fsicas del sistema
Para incorporar un nuevo servicio no es necesario modificar el ncleo.
Es ms seguro ya que los servicios corren en modo usuario.
El diseo simple y funcional tpicamente resulta en un sistema ms
confiable.
42
FINGUDELAR
Windows:
Examen abril 2003:

Cul es la diferencia entre un sistema monoltico y uno basado en microkernel?. Indique
ventajas y desventajas.
Respuesta:
Un sistema monoltico no tiene una estructura bien integrada. Todas las funcionalidades del
sistema se ejecutan en modo monitor. Son difciles de extender, mantener y depurar. Los
sistemas con microkernel son sistemas estructurados, donde la mayora de los servicios y
funciones se implementan en mdulos, dejndose slo una pequea parte del sistema (el
microkernel) que ejecute en modo monitor. En general el microkernel se limita a gestin de
interrupciones, gestin bsica de procesos, gestin de memoria a bajo nivel y comunicacin entre
procesos. Sistemas de este tipo, son mas portables y escalables que los convencionales. No
obstante, debido a que los distintos componentes ejecutan en espacios de direccionamiento
distintos, se presenta un overhead mayor al de los sistemas monolticos.
Examen julio 2005:
Explicar los sistemas con estructura basada en microkernel.
Respuesta:
En una arquitectura basada en microkernel, el sistema operativo se ocupa slo de unas pocas
funciones, reduciendo el ncleo a su mnima expresin. El resto de funciones pasan a estar en el
espacio de usuario. Se debe de proveer una interfaz de comunicacin entre los procesos de
usuarios y los procesos que proveen los servicios del sistema.
Examen marzo 2006:
Cules son las principales ventajas de un sistema con microncleo?
Respuesta:
Aumenta la portabilidad y escalabilidad ya que encapsula las caractersticas , fsicas del sistema Para incorporar un nuevo servicio no es necesario modificar el ncleo. - Es ms seguro ya que los
servicios corren en modo usuario. - El diseo simple y funcional tpicamente resulta en un sistema
ms confiable.
Examen julio 2007:
Para el diseo de un sistema operativo, seale virtudes y defectos comparando una solucin
monoltica con una basada en un micro ncleo.
Examen marzo 2008:
Describa los sistemas operativos diseados con un micro-ncleo (microkernel).
4.4.4 Sistemaconmdulos.
Los sistemas actuales utilizan mdulos de ncleo.
De esta forma logran tener:
Enfoque orientado a objetos.
Logran separar los distintos componentes en una forma ms clara.
Las componentes se comunican entre s con una interfaz conocida.
Las componentes son cargadas dinmicamente segn la necesidad.
Solaris:
43
FINGUDELAR
44
FINGUDELAR
5 Procesos
5.1 DefinicindeProceso
El principal concepto en cualquier sistema operativo es el de proceso.
Un proceso es un programa en ejecucin, incluyendo el valor del program counter,
los registros y las variables.
Conceptualmente, cada proceso tiene un hilo (thread) de ejecucin que es visto
como un CPU virtual. El recurso procesador es alternado entre los diferentes
procesos que existan en el sistema, dando la idea de que ejecutan en paralelo.
Examen julio 2007:
cmo representa el sistema operativo el concepto de proceso?
5.2 Contadordeprograma
Cada proceso tiene su program counter, y avanza cuando el proceso tiene
asignado el recurso procesador. A su vez, a cada proceso se le asigna un nmero que
lo identifica entre los dems: identificador de proceso (process id).
5.3 Memoriadelosprocesos
Un proceso en memoria se constituye de varias
secciones:
Cdigo (text): Instrucciones del

proceso.
Datos (data): Variables globales del
proceso.
Heap: Memoria dinmica que genera el
proceso.
Stack: Utilizado para preservar el
estado en la invocacin anidada de
procedimientos.
45
FINGUDELAR
5.4 Estadosdelosprocesos
El estado de un proceso es definido por la actividad corriente en que se encuentra.
Los estados de un proceso son:
Nuevo (new): Cuando el proceso es creado.

Ejecutando (running): El proceso tiene asignado un procesador y
est ejecutando sus instrucciones.
Bloqueado (waiting): El proceso est esperando por un evento (que
se complete en pedido de E/S o una seal).
Listo (ready): El proceso est listo para ejecutar, solo necesita del
recurso procesador.
Finalizado (terminated): El proceso finaliz su ejecucin.
Transiciones y estados de procesos:
Examen abril 2003:

En el contexto de planificacin de procesos, describa los posibles estados en los cuales un
proceso pueda encontrarse.
Respuesta:
En ejecucin: el proceso tiene asignado el procesador, y el flujo de instrucciones del proceso se
est ejecutando.
Bloqueado: el proceso est en espera de que se le asigne algn recurso fsico (como el fin de una
E/S) o lgico.
Listo: El proceso no est bloqueado, sino compitiendo para que se le asigne un procesador y
pasar a estado de ejecucin.
Suspendido: El proceso fue suspendido explcitamente, saliendo del estado listo o ejecutndose.
Pasar al estado listo (y ser elegible para asignrsele la CPU) cuando sea reanudado, tambin
en forma explcita.
Bloqueado suspendido: Anlogo al anterior, se da cuando se suspende un proceso que estaba
bloqueado. Volver al estado bloqueado al ser reaunudado.
Describa los estados en los que puede permanecer un proceso y realice un diagrama mostrando
las transiciones de un estado a otro mencionando el, o los eventos que se producen para el
cambio de estado.
Realice y describa un esquema de los estados y las transiciones entre los estados de los procesos
en un sistema.
46
FINGUDELAR
5.5 Transicionesentreestados
Nuevo > Listo
Al crearse un proceso pasa inmediatamente al estado listo.
Listo > Ejecutando
En el estado de listo, el proceso solo espera para que se le asigne un
procesador para ejecutar (tener en cuenta que puede existir ms de un
procesador en el sistema).
Al liberarse un procesador el planificador (scheduler) selecciona el
prximo proceso, segn algn criterio definido, a ejecutar.
Ejecutando -> Listo
Ante una interrupcin que se genere, el proceso puede perder el
recuso procesador y pasar al estado de listo. El planificador ser el
encargado de seleccionar el prximo proceso a ejecutar.
Ejecutando -> Bloqueado
A medida que el proceso ejecuta instrucciones, realiza pedidos en los
distintos componentes (ej.: genera un pedido de E/S). Teniendo en
cuenta que el pedido puede demorar, y adems, si est en un sistema
multiprogramado, el proceso es puesto en una cola de espera hasta
que se complete su pedido. De esta forma, se logra utilizar en forma
ms eficiente el procesador.
Bloqueado > Listo
Una vez que ocurre el evento que el proceso estaba esperando en la
cola de espera, el proceso es puesto nuevamente en la cola de
procesos listos.
Ejecutando -> Terminado
Cuando el proceso ejecuta sus ltima instruccin pasa al estado
terminado.
El sistema libera las estructuras que representan al proceso
Examen julio 2003:
Describa los diferentes estados de un proceso, as como las principales colas asociadas al
planificador de los mismos.
5.6 Bloquedescriptordeproceso
El proceso es representado, a nivel del sistema operativo, a travs del bloque
descriptor de proceso (Process Control Block).
Todo proceso se describe mediante su estado, nombre,
recursos asignados, informacin contable, etc..
Para ello se utilizara una estructura de datos que ser el
operando de las operaciones sobre procesos, recursos y del
planificador (scheduler).
Estado CPU: El contenido de esta estructura
estar indefinido toda vez que el proceso est
en estado ejecutando (puesto que estar
almacenado en la CPU indicada por procesador).
Registro de flags.
Procesador: [1..#CPU]: Contendr el nmero
de CPU que est ejecutando al proceso (si esta
en estado ejecutando), sino su valor es
indefinido.
47
FINGUDELAR
Memoria: Describe el espacio virtual y/o real de direccionamiento

segn la arquitectura del sistema. Contendr las reglas de proteccin
de memoria as como cul es compartida, etc..
Estado del proceso: ejecutando, listo o bloqueado.
Ancestro: Indica quin cre este proceso.
Descendientes: Lista de punteros a PCBs de los hijos de este
proceso.
Recursos: Recursos de software (archivos, semforos, etc.) y
hardware dispositivos, etc.).
Planificacin: Tipo de planificador.
Prioridad: Podr incluir una prioridad externa de largo aliento, o en su
defecto una prioridad interna dinmica de alcance reducido.
Contabilizacin: Informacin contable como ser cantidad de E/S,
fallos de pginas (page faults), consumo de procesador, memoria
utilizada, etc.
Examen abril 2003:

Describa detalladamente que es el PCB
Respuesta:
Un PCB (Process Control Block) es una estructura de datos del sistema que representa un
proceso, almacenando informacin del mismo. Incluye
a. El estado del proceso (listo, en ejecucin, etc.)
b. El program counter, indicando la siguiente instruccin a ejecutar
c. Los registros, que son guardados junto con el PC por cada interrupcin.
d. Informacin adicional para la planificacin (prioridades, punteros a las colas donde se pudiera
encontrar el proceso, segn su estado, etc.)
e. Informacin de administracin de memoria (registros lmites, tablas de pginas)
f. Informacin contable: nmero de proceso, utilizacin de CPU, tiempo de creacin, etc.
g. Informacin de E/S: archivos abiertos, E/S pendientes.
h. Referencias a la genealoga o contexto de procesos, hijos, padre, etc.
Examen julio 2003:
Detalle y explique el cometido de los principales componentes del bloque descriptor de proceso
(PCB).
En el Process Control Block existe una seccin para los registros. Cundo es utilizada esta rea?
Respuesta:
Cuando el proceso no tiene asignado el recurso procesador. En esa rea se guarda el estado de
los registros del procesador cuando el proceso fue despachado. Cuando el planificador le asigne
el recurso procesador, el despachador cargar los registros del procesador con esos valores.
5.7 Creacindeprocesos
Los procesos de un sistema son creados a partir de otro proceso.
Al creador se le denomina padre y al nuevo proceso hijo. Esto genera una
jerarqua de procesos en el sistema.
En el diseo del sistema operativo se debe decidir, en el momento de creacin de
un nuevo proceso, cuales recursos compartirn el proceso padre e hijo. Las opciones
son que compartan todo, algo o nada.
Una vez creado el nuevo proceso tendrn un hilo (pc) de ejecucin propio. El
sistema genera un nuevo PCB para el proceso creado.
Ej.: UNIX
UNIX provee el system call fork para la creacin de un nuevo proceso.
La invocacin a esta funcin le retorna al padre el nmero de process id del hijo
recin creado y al hijo el valor 0. El hijo comienza su ejecucin en el retorno del fork.
48
FINGUDELAR
Adems, se provee del system call exec que reemplaza el espacio de memoria del
proceso por uno nuevo.
int main() {
pid_t pid;
/* fork another process */
pid = fork();
if (pid < 0) { /* error occurred */
fprintf(stderr, "Fork Failed");
exit(-1);
}
else if (pid == 0) { /* child process */
execlp("/bin/ls", "ls", NULL);
}
else { /* parent process */
/* parent will wait for the child to complete*/
wait (NULL);
printf ("Child Complete");
exit(0);
}
}
49
FINGUDELAR
5.8 Listasycolasdeprocesos
Los procesos, en los distintos estados que tienen, son agrupados en listas o colas:
Lista de procesos del sistema (job queue): En esta lista estn

todos los procesos del sistema. Al crearse un nuevo proceso se agrega
el PCB a esta lista. Cuando el proceso termina su ejecucin es borrado.
Cola de procesos listos (ready queue): Esta cola se compondr de
los procesos que estn en estado listo. La estructura de esta cola
depender de la estrategia de planificacin utilizada.
Cola de espera de dispositivos (device queue): Los procesos que
esperan por un dispositivo de E/S particular son agrupados en una lista
especfica al dispositivo. Cada dispositivo de E/S tendr su cola de
espera

Cuando los procesos realizan pedidos a dispositivos de entrada/salida. Adems de la cola de
procesos bloqueados, en qu otra cola del sistema son alojados mientras esperan que el
dispositivo realice el pedido?
Respuesta:
Cada dispositivo de entrada/salida posee de una cola de espera. Un proceso al ejecutar una
operacin de entrada/salida sobre un dispositivo, es puesto en la cola respectiva al dispositivo.
Diagrama de transicin de un proceso entre las colas del sistema:
50
FINGUDELAR
5.9 Cambiodecontexto
A la tarea de cambiar un proceso por otro en el procesador se le denomina
cambio de contexto (context switch).
El tiempo que implica cambiar realizar la tarea es considerado como overhead
(tiempo de procesador que no es til).
El cambio de contextos entre procesos implica las siguientes tareas:
Salvar el estado del proceso (registros, informacin de punteros de
memoria) que est ejecutando en su PCB.
Cambiar el estado del proceso que estaba ejecutando al que
corresponda.
Cargar el estado del proceso asignado a la CPU a partir de su PCB.
Cambiar el estado del proceso nuevo a ejecutando.
51
FINGUDELAR
Examen abril 2003:

Describa las acciones del kernel de un sistema operativo cuando ocurre un cambio de contexto:
1. entre hilos
2. entre procesos
Respuesta:
Para el caso de un cambio de contexto entre hilos de un mismo proceso, el sistema operativo
debe salvar los registros, el contador de programa y el registro de pila del hilo en el PCB. Sin
embargo no se requiere ninguna otra gestin relativa al espacio de memoria u otros recursos, ya
que el contexto es idntico para todos los hilos del proceso o tarea que contiene a los hilos. De
acuerdo a lo expuesto, para un proceso activo, el planificador podra priorizar el despacho de
hebras del mismo en el procesador o CPU corriente. Si los hilos pertenecen a tareas o procesos
diferentes, obviamente se hace necesario conmutar el contexto de acuerdo a la tcnica habitual.
Para el caso de cambio de contexto entre procesos diferentes, el sistema operativo debe realizar
las mismas tareas que con lo hilos, pero adems debe movilizar informacin relativa a los
recursos asignados al procesos, como ser bloques de memoria o disco asignado y procesos
descendientes del proceso actual.
Examen marzo 2006:
Describa brevemente el conjunto de tareas que implica realizar un cambio de
contexto (context switch), mencionando la utilidad del bloque de control del proceso (PCB:
Process Control Block).
Respuesta:
Cuando un cambio de contexto ocurre, el ncleo del sistema debe guardar (salvar) el contexto
del viejo proceso en el PCB y luego cargar el contexto del nuevo proceso (desde su PCB) en el
procesador asignado.
52
FINGUDELAR
5.10 Cooperacinentreprocesos
Procesos concurrentes pueden ejecutar en un entorno aislado (se debe asegurar la
ausencia de interferencias) o, eventualmente, podrn interactuar cooperando en pos
de un objetivo comn compartiendo objetos comunes.
Es necesario que el sistema operativo brinde unas herramientas especficas para
la comunicacin y sincronizacin entre los procesos (InterProcess Communication
IPC).
IPC es una herramienta que permite a los procesos comunicarse y sincronizarse
sin compartir el espacio de direccionamiento en memoria.
5.11 Threads
Hay aplicaciones donde es necesario utilizar y compartir recursos en forma
concurrente.
IPC brinda una alternativa a nivel de sistema operativo.
ltimamente los sistemas operativos estn comenzando a proporcionar servicios
para soportar crear ms de un hilo (thread) de ejecucin (control) en un proceso.
De esta forma, se tiene ms de un hilo de ejecucin en el mismo espacio de
direccionamiento.
Cada thread contendr su propio program counter, un conjunto de registros, un
espacio para el stack y su prioridad.
Todos los recursos, seccin de cdigo y datos son compartidos
por los distintos threads de un mismo proceso.
A nivel de sistema operativo y Process Control Block, cules estructuras son necesarias para
describir un hilo (thread)?
Respuesta:
A nivel del PCB, el sistema debe tener una estructura independiente para cada thread de un
proceso que contenga por lo menos el stack, registros y el program counter.
Proponga una estructura de datos necesaria para poder representar hilos (threads) a nivel del
sistema operativo. Mencione solamente los campos principales del bloque descriptor del
proceso .
Respuesta:
Para poder representar hilos (threads) es necesario tener estructuras para la pila (stack), el
contador de programa (program counter) y los registros de cada hilo. Se debe modificar el PCB de
forma tal de que cada hilo tenga estas estructuras de forma independiente.
Examen marzo 2008:
Realice un diagrama mostrando los principales campos del descriptor de proceso (PCB - Process
Control Block asumiendo que est en un sistema que reconoce hilos a nivel del sistema operativo.
53
FINGUDELAR
Ventajas del uso de threads:
Repuesta: desarrollar una aplicacin con varios hilos de control

(threads) permite tener un mejor tiempo de respuesta.
Compartir recursos: los threads de un proceso comparten la
memoria y los recursos que utilizan. A diferencia de IPC, no es
necesario acceder al kernel para comunicar o sincronizar los hilos de
ejecucin.
Economa: es ms fcil un cambio de contexto entre threads ya que
no es necesario cambiar el espacio de direccionamiento. A su vez, es
ms liviano para el sistema operativo crear un thread que crear un
proceso nuevo.
Utilizacin de arquitecturas con multiprocesadores: disponer de
una arquitectura con ms de un procesador permite que los threads de
un mismo proceso ejecuten en forma paralela.
Los threads pueden ser implementados tanto a nivel de usuario como a nivel de
sistemas operativo:
Hilos a nivel de usuario (user threads): son implementados en

alguna librera de usuario. La librera deber proveer soporte para
crear, planificar y administrar los threads sin soporte del sistema
operativo. El sistema operativo solo reconoce un hilo de ejecucin en el
proceso.
Hilos a nivel del ncleo (kernel threads): el sistema es quien
provee la creacin, planificacin y administracin de los threads. El
sistema reconoce tantos hilos de ejecucin como threads se hayan
creado.
Ventajas de user threads sobre kernel threads:
54
FINGUDELAR
Desarrollo de aplicaciones en sistemas sin soporte a hilo: se

pueden aprovechar todos los beneficios de programar orientado
utilizando threads. Adems se puede portar la aplicacin a un sistema
operativo que carezca de la nocin de varios hilos de ejecucin.
Cambio de contexto: el cambio de contexto entre threads de usuario
es ms simple ya que no consume el overhead que tendra en el
sistema operativo (guardar registros).
Planificacin independiente: se puede crear una nueva estrategia
de planificacin diferente a la que tenga el sistema operativo.
Ventajas de kernel threads sobre user threads:
Mejor aprovechamiento de un sistema multiprocesador: el

sistema operativo puede asignar threads del mismo proceso en
distintos procesadores. De esta forma, un proceso puede estar
consumiendo ms de un recurso procesador a la vez.
Ejecucin independiente: Al ser independientes los hilos de
ejecucin, si un thread se bloquea (debido a p.ej. una operacin de
E/S) los dems threads pueden seguir ejecutando.

Si en un S.O. la implementacin de los threads (hebras) se realiz a nivel de usuario, qu sucede
con las restantes hebras de un proceso cuando una se bloquea como consecuencia de la
invocacin de un servicio (system call) del S.O.?
Respuesta:
Se bloquean tambin el resto de las hebras del mismo proceso.
Examen julio 2003:
Describa las diferentes modalidades de implementacin hilos en un sistema operativo indicando
que ventajas y desventajas presenta cada uno.
Examen julio 2003:
En sistemas con hilos implementadas en el ncleo, un proceso multihilado, cuntas pilas debe
tener?
Describa brevemente dos limitaciones de los hilos a nivel de usuario sin soporte del ncleo.
Respuesta:
Un fallo de pgina de un hilo hace que se bloquee el proceso con todos los otros hilos. Idem con
E/S. Idem con llamadas al sistema.An si el sistema es multiprocesador y tiene CPUs ociosas,
todos los hilos competirn por un solo procesador, el del proceso que los contiene. En caso de ser
mltiples hilos de un proceso que ejerce como mquina virtual de ellos (por ejemplo
planificndolos), una vez que est ejecutando un hilo, no existe forma expropiarle el control para
drselo al proceso/mquina virtual. La nica forma es que los propios hilos lo cedan (por ejemplo
llamando algn servicio de la mquina virtual, en vez de hacer llamadas directas al sistema).
En un sistema monoprocesador, qu gran ventaja tiene, a nivel de procesos de usuario, un
sistema que soporte hilos (threads) a nivel de sistema, frente a uno que no lo haga.
Respuesta:
Aprovechar que ejecuten otros hilos del mismo procesos mientras alguno de ellos se haya
bloqueado en una operacin de entrada/salida. Esto es posible ya que el sistema operativo
reconoce los hilos como unidades de ejecucin independientes.
La mayora de los sistemas proveen threads tanto a nivel de usuario como de

sistema operativo.
De esta forma surgen varios modelos:
55
FINGUDELAR
Mx1 (Many-To-One): Varios threads de a nivel de usuario a un nico thread

a nivel de sistema.
1x1 (one-to-One): Cada thread de usuario se corresponde con un thread a
nivel del ncleo (kernel thread).
MxN (Many-To-Many): Varios threads a nivel de usuario se corresponde con
varios threads a nivel del ncleo.
Mx1 (Many-To-One)
Este caso se corresponde al de tener los threads
implementados a nivel de usuario.
El sistema solo reconoce un thread de control
para el proceso.
Los threads de usuario ejecutarn cuando estn
asignados al kernel thread del proceso (tarea
llevada a cabo por el planificador a nivel de usuario)
adems, a este le asigne la CPU el planificador del
sistema operativo.
y,
1x1 (One-To-One)
Cada thread que es creado a nivel de usuario se genera un nuevo thread a nivel
de sistema que estar asociado mientras exista.
El sistema reconoce todos los threads a nivel de usuario y son planificados
independientemente. En este caso no hay planificador a nivel de usuario.
MxN (Many-To-Many)
Cada proceso tiene asignado un conjunto
de kernel threads independiente de los
threads a nivel de usuario que el proceso haya
creado.
El planificador a nivel de usuario asigna los
threads en los kernel threads.
El Planificador de sistema Reconoce los
kernel threads.
Es comn ver los kernel threads como CPU
virtuales.
Examen marzo 2003:
a) Qu ventaja o desventaja tiene soportar threads a nivel de usuario en un multiprocesador?
b) D una desventaja de soportar threads a nivel de ncleo, en comparacin a hacerlo a nivel de
usuario.
Respuesta:
Para el cambio de contexto es necesario llamar al sistema, lo que lo hace ms lento que
la conmutacin entre hilos a nivel de usuario.
56
FINGUDELAR
c) Suponga que usted debe procesar una matriz de informacin, de N x N, donde N es muy
grande. Discuta la conveniencia de utilizar tareas multihiladas o procesos para realizar esta
accin.
Respuesta:
Es ms conveniente el uso de threads colocando la matriz en el espacio comn de
direcciones, como una variable global. Es razonable esperar que la aplicacin que
procesa la matriz no requiera proteger sus hilos entre s, y que en cambio cada thread
deba acceder a toda la matriz. Si se resuelve mediante procesos, debera emplearse un
mecanismo de comunicacin del sistema, con la prdida de desempeo que cada
llamada implica.
Examen julio 2004:
En la implementacin de qu tipo de programas resulta especialmente til el contar con un
servicio de hilos o procesos multihilados?
Respuesta:
En aplicaciones que son servidores de mltiples usuarios atendidos en paralelo, como servidores
de bases de datos, servidores de archivos, etc. Frecuentemente estos servidores mantienen un
pool de hilos, evitando el costo de crearlos bajo demanda. Hilos es especialmente til si en
memoria se mantiene informacin comn a todos los usuarios, por ejemplo informacin de
estado de la aplicacin.
Cul es la principal diferencia que hay entre implementar un servicio de comunicacin de
mensajes entre procesos de un mismo computador, respecto a hacerlo entre hilos de un mismo
proceso?
Respuesta:
El primero requiere un mecanismo gestionado por el sistema, como colas de memoria
compartida, mensajes, etc., con el costo de las llamadas correspondientes, y los cambios de
contexto. Con hilos es posible hacerlo sin intervencin del sistema, direccionando sobre el mismo
espacio virtual.
57
FINGUDELAR
6 Planificacin
6.1 Introduccin
La planificacin (scheduling) es la base para lograr la multiprogramacin.
Un sistema multiprogramado tendr varios procesos que requerirn el recurso
procesador a la vez.
Esto sucede cuando los procesos estn en estado ready (pronto).
Si existe un procesador disponible, se debe elegir el proceso que ser asignado al
recurso para ejecutar.
La parte del sistema operativo que realiza la eleccin del proceso es llamada
planificador (scheduler).
6.2 Clasesdeprocesos
Existen distintas polticas de planificacin que sern exitosas segn la clase de
procesos que ejecuten.
Los procesos consisten en ciclos de rfagas de ejecucin (CPUburst) y rfagas de
espera de operaciones de E/S (I/O burst).
En general, los procesos tienden a ser o ms intensivos en el uso de procesador, o
ms intensos en el uso de operaciones de E/S.
Procesos CPU-bound: Los procesos que contienen un alto uso de

procesador son llamados CPU-bound o compute-bound.
Procesos I/O-bound: Los procesos que realizan muchos accesos a
operaciones de E/S son llamados I/O-bound.
La prioridad que tenga un proceso frente a los dems para acceder al recurso ser
inversamente proporciona al uso que haga del recurso.
Qu quantum de CPU (mayor, menor o igual) le dara a los procesos que son catalogados como
consumidores intensivos de CPU (CPU-bound), con respecto a los procesos consumidores de
entrada-salida (IO-bound)?
Respuesta:
La prioridad sobre un recurso es inversamente proporcional al uso del mismo. Los procesos
intensivos en CPU (CPU-bound) debern tener una prioridad baja sobre el recurso procesador, por
lo que se les asignar un quantum de tiempo menor con respecto a los procesos intensivos en
entrada-salida (I/O bound). De esta forma, los procesos que no hacen un uso desmedido del
procesador podrn acceder con mayores posibilidades.
6.3 Esquemasdeplanificacin
La momentos en que el planificador es invocado son:
1. Cuando un proceso se bloquea en una operacin de E/S, o un
semforo, etc..
2. Cuando un proceso cambia del estado ejecutando al estado pronto. Por
ejemplo al ocurrir una interrupcin o al crearse un nuevo proceso.
3. Cuando ocurre una interrupcin de E/S y un proceso pasa del estado
bloqueado a pronto.
4. Cuando un proceso finaliza su ejecucin.
58
FINGUDELAR
Cuando ocurre 1 4, el planificador es invocado debido a que el

proceso en ejecucin libera el procesador.
Cuando ocurre 2 3, si el planificador es invocado, se dice que este es
expropiador (preemptive), ya que puede quitar el procesador al
proceso que estaba en ejecucin.
Planificadores no expropiadores (non-preemptive)

Son los planificadores que asignan el recurso procesador a un proceso y hasta que
este no lo libere, ya sea porque finaliza su ejecucin o se bloquea, no son ejecutados
nuevamente.
Examen marzo 2003:
Discuta sobre la adecuacin de un planificador no-preemptivo cuando se consideran aplicaciones
con restricciones de tiempo real.
Respuesta:
Un planificador no-preemptivo no es adecuado cuando se consideran aplicaciones de tiempo real,
porque stas requieren garantas de tiempo de servicio, lo cual slo es posible si se usa un
planificador preemptivo.
Planificadores expropiadores (preemptive)

Son los planificadores que pueden expropiar el recurso procesador a un proceso
cuando otro proceso entra en estado pronto (ya sea porque es nuevo o porque se
desbloque) o porque se le impone una limitante de tiempo para ejecutar.
En el diseo de un planificador, explique la diferencia entre apropiativo y no apropiativo
Examen marzo 2003:
Qu es un planificador preemptivo?
Respuesta:
Es un planificador que asegura que el proceso en ejecucin es el de mayor prioridad en el
sistema. Esto implica que cuando un proceso A con prioridad p1 est listo para ejecutar, y un
proceso B con prioridad p2 ( con p1 > p2 ) est siendo ejecutado, el planificador debe quitarle el
procesador a B y despachar A.
Cundo se dice que un despachador es apropiativo?
Respuesta:
Cuando asegura que en todo momento se est ejecutando el proceso de mayor prioridad, segn
el esquema de prioridad, explcito o implcito, que se maneje. Para esto se hace necesario poder
quitar el procesador a un proceso que actualmente est en ejecucin.
Qu entiende por planificador expropiativo?
Qu entiende por planificador expropiativo (preemptive scheduling)?
Los esquemas de planificacin son tiles segn el ambiente donde sean

aplicados.
Sistemas por lotes: Como no existe interaccin con usuarios, los

planificadores no expropiadores son ideales.
Sistemas interactivos: Debido a que existen procesos de usuarios
ejecutando a la vez, los planificadores expropiadores son ideales para
mantener un buen tiempo de respuesta para los usuarios.
Sistemas de tiempo real: No es necesario planificadores
expropiadores ya que los procesos puede que no ejecuten por un buen
tiempo, pero cuando lo hacen es por un perodo muy corto.
59
FINGUDELAR
Examen julio 2007:
Clasifique el tipo de planificador (expropiativos o no expropiativos) a utilizar en cuanto a sistemas
por lotes, interactivos y de tiempo real.
6.4 Criteriosdeplanificacin
Los algoritmos de planificacin tendrn distintas propiedades y favorecern cierta
clase de procesos.
Es necesario definir criterios para poder evaluar los algoritmos de
planificacin:
Utilizacin de CPU (CPU utilization): es el porcentaje de uso (en
cuanto a ejecucin de tareas de usuario o del sistema que son
consideradas tiles) que tiene un procesador.
Rendimiento (Throughput): es el nmero de procesos que
ejecutaron completamente por unidad de tiempo (una hora p.ej.).
Tiempo de retorno (Turnaround time): es el intervalo de tiempo
desde que un proceso es cargado hasta que este finaliza su ejecucin.
Tiempo de espera (Waiting time): es la suma de los intervalos de
tiempo que un proceso estuvo en la cola de procesos listos (ready
queue).
Tiempo de respuesta (Response time): es el intervalo de tiempo
desde que un proceso es cargado hasta que brinda su primera
respuesta. Es til en sistemas interactivos.
Examen marzo 2006:
Defina los siguientes conceptos: a) Utilizacin de procesador. b) Tiempo de retorno. c) Tiempo de
espera.
Examen marzo 2007:
Qu es el tiempo de retorno (turnaround time)?Qu se entiende por rendimiento (throughput)
de un algoritmo de planificacin?
6.5 Algoritmosdeplanificacin
6.5.1 FirstComeFirstServed(FCFS)
El procesos son ejecutados en el orden que llegan a la cola de procesos listos.
La implementacin es fcil a travs de una cola FIFO.
Es adecuado para sistemas por lotes (batch).
Es un algoritmo no expropiador. Una vez que el procesador le es asignado a un
proceso este la mantiene hasta que termina o genera un pedido de E/S.
El tiempo de espera promedio por lo general es alto.
6.5.2 ShortestJobFirst(SJF)
El algoritmo asocia a los procesos el largo del prximo CPUburst.
60
FINGUDELAR
Cuando el procesador queda disponible se le asigna el proceso que tenga el
menor CPU-burst. Si dos procesos tiene el mismo CPU-burst se desempata por FCFS.
Su funcionamiento depende de conocer los tiempos de ejecucin, que en la
mayora de los casos no se conoce.
Es adecuado para sistemas por lotes (batch).
Dos esquemas:
No expropiador: una vez que se le asigna el procesador a un proceso no se

le podr quitar.
Expropiador: Si un nuevo proceso aparece en la lista de procesos listos con
menor CPU-burst, se le quita la CPU para asignarla al nuevo proceso.
Este algoritmo es ptimo para el tiempo de espera, pero requiere que todos los
procesos participantes estn al comienzo.
6.5.3 BasadosenPrioridad
A cada proceso se le asigna una nmero entero que representa u prioridad.
El planificador asigna el procesador al proceso con la ms alta prioridad.
Se utiliza en general un esquema expropiador ya que si un proceso con mayor
prioridad que el que esta ejecutando arriba a lista de procesos listos (ready queue),
ser asignado al procesador.
SJF se puede ver como un algoritmo de prioridad donde la prioridad esta dada por
el prximo CPU-burst.
Es adecuado para sistemas interactivos.
61
FINGUDELAR
Sufre de posposicin-indefinida ya que un proceso de baja prioridad quizs no
pueda ejecutar nunca.
La solucin es utilizar prioridades dinmicas de envejecimiento.
Incrementar la prioridad segn pasa el tiempo sin ejecutar.
La prioridad de un proceso para el uso del recurso procesador deber ser inversa
al uso que el proceso haga del mismo.
Un proceso I/O-bound deber tener mayor prioridad que uno CPU-bound.
6.5.4 RoundRobin(RR)
A cada proceso se le brinda un intervalo de tiempo para el uso del procesador
(time quantum). Al finalizar el tiempo, el procesador le es expropiado y vuelve al
estado pronto (ready) al final de la cola.
Es fcil de implementar ya que solamente es necesaria una cola de procesos
listos. Cuando un proceso consume su quantum es puesto al final de la cola.
El quantum debe ser bastante mayor a lo que lleva realizar un cambio de
contexto, sino se tendr mucho overhead. A su vez, el tiempo de quantum incide en
los tiempos de retorno.
Es ideal para sistemas de tiempo compartido.
Por lo general, tiene un mayor tiempo de retorno que el SJF, pero mejora el tiempo
de respuesta.
Es necesario asignar un ajustado tiempo de quantum.
Si es muy chico generar muchos cambios de contexto.
Si es muy grande, el sistema tender a un FCFS.
El promedio del tiempo de retorno vara segn el quantum.
62
FINGUDELAR

Calcule el tiempo de espera promedio para los siguientes procesos:
Proceso Burst Time
P1
5
P2
6
P3
2
P4
3
Utilizando:
a) Un planificador Shortest Job First (SJF).
b) Un planificador Round-Robin con tiempo de quantum 1.
Respuesta:
a) (0 + 2 + 5 + 10) / 4 = 4.25
b) (9 + 10 + 5 + 8) / 4 = 8 (Se tomo el orden P1, P2, P3 y P4).
Se tiene un computador con 2 procesadores y con un sistema operativo de procesamiento
simtrico, cuyo planificador tiene una poltica Round-Robin de quantum 1. Cul ser el tiempo
de espera promedio total de los siguientes procesos?
Respuesta:
Ejecutarn de la siguiente forma:
Procesador
Cola listos
(P1,P2)
(P3,P4)
(P3,P4)
(P1,P2)
(P1,P2)
(P3,P4)
(P3,P4)
(P1,P2)
(P1,P2)
(P4)
(P1,P4)
(P2)
(P1,P2)
()
(P2)
()
(P2)
()
(TE(P1) + TE(P2) + TE(P3) + TE(P4)) / 4 = (2 + 3 + 2 + 3) / 4 = 2.5.
63
FINGUDELAR
6.5.5 Colasmultinivel(MultilevelQueue)
Si los procesos se pueden clasificar segn sus cualidades, es posible dividir la lista
de procesos listos (ready queue) en varias colas (una para cada clasificacin).
Los procesos son asignados permanentemente a una de las colas.
Cada cola tendr su propio algoritmo de planificacin.
Adems, se debe tener una estrategia de planificacin entre las diferentes colas.
Por ejemplo, una cola tendr prioridad sobre otra.
Examen julio 2003:

Describa un sistema de planificacin de procesos basado en colas multinivel. Indique que
ventajas y desventajas presenta.
En un sistema con planificador de colas multinivel, en donde a cada nivel se le asigna un
algoritmo de planificacin round-robin con diferente quantum y teniendo mayor prioridad las
colas con quantum ms chico, qu tipos de procesos (alto consumo CPU o alto consumo de
operaciones de E/S) clasificaran para colas con quantum ms bajo y cules otros para colas con
quantum ms alto?.
Respuesta:
La prioridad para el uso de un recurso es inversamente proporcional al uso que se hace del
mismo. Por lo tanto, los proceso que tengan un alto consumo de CPU debern ir a colas de menor
prioridad (segn la letra, quantum mayor), mientras que los procesos que hagan mayor uso de E/
S tendrn mayor prioridad de acceso al procesador (colas con quatum menor). Cuando el
planificador seleccione un proceso de alto consumo de CPU (una cola de baja prioridad), este
ejecutar hasta que no aparezca un proceso de alto consumo de E/S (que seguramente demore
poco en la CPU). De esta forma, se logra que los procesos que requieran poca CPU ejecuten lo
antes posible y liberen el recurso CPU rpidamente de forma de tener un mayor desempeo
general del sistema.
6.5.6 MultilevelFeedbackQueue
Se diferencia con el anterior en que procesos pueden cambiar de cola (nivel).
Se basa en categorizar los procesos segn el uso de CPU (CPUburst) que tengan.
La cola de mayor prioridad ser la de los procesos I/O-bound y la de menor la de
procesos con alto CPU-bound.
De esta forma, se garantiza que los procesos con poco uso de procesador tengan
mayor prioridad, y los que consumen mucho procesador tendrn baja prioridad.
Los procesos, segn el consumo de CPU que hagan, sern promovidos a una cola
de mayor prioridad o rebajados a una de menor prioridad.
Un planificador Multilevel-Feedback-Queue es definido por:
64
FINGUDELAR
El nmero de colas.
El algoritmo de planificacin para cada cola.
El mtodo utilizado para promover a un proceso a una cola de mayor
prioridad.
El mtodo utilizado para bajar a un proceso a una cola de menor
prioridad.
El mtodo utilizado para determinar a qu cola ser asignado un
proceso cuando est pronto.
Examen marzo 2007:

Describa el planificador de colas multinivel con feedback (Multilevel-Feedback-Queue).
6.5.7 Sistemasmultiprocesadores
En un sistema simtrico cualquier procesador podr ejecutar procesos de usuario.
Es posible asignar una cola de procesos listos para cada procesador. Es
conveniente para aprovechar los datos que estn el la memoria cache del
procesador.
Un problema posible es que un procesador no tenga procesos para ejecutar, pero
otro s. En este caso se migrarn procesos de cola.
Examen marzo 2003:
Describa el funcionamiento de los planificadores a corto, mediano y largo plazo.
Respuesta:
Planificador a largo plazo:
o Comn en un sistema por lotes, donde no es posible ejecutar
inmediatamente todos los trabajos pendientes.
o Elige entre los procesos almacenados en un dispositivo de
almacenamiento para pasarlo a la ready queue.
o Controla el nivel de multiprogramacin.
Planificador a corto plazo:
o Escoge entre los procesos listos uno para asignarle CPU.
o Ejecuta con frecuencia mucho mayor a la del planificador a
largo plazo.
Planificador a mediano plazo:
o Comn en los sistemas de tiempo compartido.
o Toma las decisiones de swapping.
Describa tres de los algoritmos vistos en el curso de planificacin de corto plazo
Respuesta:
Se presentan 4 algoritmos :
1.First-Come, First-Served
Primero en llegar a la ready-queue, primero en asignarle la CPU.
2.Shortest Job First
Dada una lista de procesos se le asigna la CPU al trabajo que le reste menor tiempo de
ejecucin.
Para la ejecucin de este algoritmo es necesario que reporten el tiempo que le resta en alguna
unidad comn a todos.
3.Priority
65
FINGUDELAR
A los procesos se les asigna una prioridad (p.ej: un numero natural). Se define una relacin de
orden de estas prioridades y segn ella los procesos que tengan mayor prioridad tendrn acceso
al CPU antes.
4.Round Robin
Se define un quantum de tiempo global a todos los procesos. Se asignan los procesos a la CPU y
se les quita cuando termine el tiempo (quantum).
Muestre a travs de un diagrama de Gantt como sera la ejecucin para el siguiente ejemplo:
Proceso Tiempo de ejecucin
P1
10
P2
5
P3
2
P4
4
Defina (especificando) a gusto datos adicionales que su algoritmo requiera (time slice, prioridad,
etc. )
Respuesta:
.First-Come, First-Served
Suponiendo un orden de llegada: P1, P2, P3 y P4
P1
P2 P3 P4
|----------|-----|--|----|
2.Shortest Job First
P3
P4 P2 P1
|--|----|-----|----------|
3.Priority
Asumiendo las siguientes prioridades:
P1 -> 4
P2 -> 3
P3 -> 2
P2 -> 1
Donde a mayor nmero mayor prioridad.
P1
P2 P3 P4
|----------|--------|----|----|
3.Round-Robin
Asumiendo un quantum de tiempo igual a 4 y tomando los procesos en el orden
P1, P2, P3 y P4
P1 P2 P3 P4 P1 P2 P1
|----|-----|--|-----|----|-|--|
Considere el siguiente conjunto de procesos, donde la duracin de la rfaga de CPU se mide en
milisegundos:
Se dispone de un equipo monoprocesador y se supone que los procesos llegaron en el orden P1,
P2, P3, P4, P5, todos en el instante 0. a. Dibuje un diagrama que ilustre la ejecucin de estos
procesos utilizando planificacin: FCFS, SJF, una tcnica por prioridad no expropiativa (a menor
nmero, mayor prioridad), y RR con cuanto = 1.
b. Calcule el tiempo de retorno y espera de los procesos para el algoritmo RR de la parte a.
Respuesta:
66
FINGUDELAR
RR (Cuanto=1)
Cs = cuantos de espera
Ce = cuantos de ejecucin
tiempo de P1 = 14 Cs + 8 Ce (espera = 14ms)
Tiempo de espera: Tiempo total en la cola de listos.
Tiempo de espera total = 14 + 1 + 10 + 6 + 14 = 45ms
Tiempo de espera promedio = ( 14 + 1 + 10 + 6 + 14) / 5 = 9 ms
Tiempo de retorno: Tiempo transcurrido desde que se envi el proceso hasta que termina.
Tiempo de retorno total = 22 + 2 + 14 + 8 + 21 = 67ms
Tiempo de retorno promedio = ( 22 + 2 + 14 + 8 + 21 ) / 5 = 13,4 ms
6.6 Despachador
Una vez que el planificador ejecuta y elige el proceso para asignar al procesador,
se invoca al despachador (dispatcher) que es el encargado de asignar el proceso al
procesador.
La tarea que realiza es:
Cambiar el contexto: salvar registros del procesador en PCB del
proceso saliente. Cargar los registros con los datos del PCB del registro
entrante.
Cambiar el bit de modo a usuario.
Saltar a la instruccin adecuada que haba quedado el proceso que se
asign a la CPU (PC).
Examen marzo 2008:
Qu funciones desarrolla el despachador (dispatcher)?
Indique la diferencia entre planificacin a corto, mediano y largo plazo.
Respuesta:
Planificador a largo plazo: Selecciona un proceso pendiente de ejecucin (en un spooler, en
almacenamiento secundario) para que pase a estado listo y empiece a competir con los dems
procesos por CPU y memoria.
Planificador a corto plazo: Selecciona un proceso de la cola de proceso listos para asignarle CPU.
Planificador a mediano plazo: Sirve para reducir una excesiva contienda por CPU, para eliminar
temporalmente procesos de memoria hacia almacenamiento secundario. Cuando hay ms
recursos disponibles, los retorna a donde qued. Nota: Es incorrecto definir cada planificador por
la frecuencia con que ejecuta. La frecuencia es una caracterstica, pero no una definicin.
67
FINGUDELAR
7 ProcesosyRecursos
7.1 Bloquedescriptordeprocesos(PCB)
Los procesos tendrn un bloque descriptor (PCB) que contiene los siguientes
campos:
Identificacin de proceso (idExt: Externo, pid: Interno).
Vector de estado:
Estado del CPU: Ser un registro con registros y condiciones etc..
Procesador: [1..#CPU].
Memoria: Describe el espacio virtual y/o real de direccionamiento
segn la arquitectura del sistema.
Recursos: Lista encadenada de los recursos asignados. Cada
entrada contiene:
Puntero al bloque descriptor del recurso (RCB) de la clase del
recurso de la disponibilidad.
Detalle de asignacin que incluye o coincide con la clase
disponibilidad.
Estado: Pronto, Ejecutando o Bloqueado (espera por algn recurso,

apuntado por datos de estado).
Datos de estado: Si est bloqueado, apunta al recurso por el cual se
espera. Si est pronto, apunta a la lista de procesos activos (ready
list).
Ancestro: indica quin cre este proceso.
Descendientes: lista de punteros a PCBs de los hijos de este proceso.
Prioridad.
Informacin contable: IOs, Page faults, consumo procesador, memoria
en uso etc..

Cul es el motivo de que en el PCB (Process Control Block) se reserve lugar para los registros de
la CPU?
Respuesta:
El lugar es reservado debido a que cuando un proceso se le quita el recurso procesador, es
necesario guardar su estado de ejecucin. De esta forma, cuando es elegido nuevamente para
hacer uso del procesador los registros son copiados del PCB a los registros del procesador.
7.2 BloquedescriptorderecursosRCB
Toda clase de recurso R se describe mediante su RCB, que incluye:
ID: Ser su nombre externo.
SR: Indicar si es utilizable en forma serial.
Disponibilidad: Lista de disponibilidad de R.
Espera: Lista de procesos en espera del recurso R. Cada nodo de esta
clase contendr:
Puntero al PCB del proceso bloqueado.
Pedido que indica que se desea y ser de la clase 'pedido de R'.
Detalle de la asignacin del recurso R.
Administrador: Ser un puntero que describa el cdigo del
administrador con la siguiente definicin de funcin:
AdministradorClaseR( RCB * r, lstEspR L).
68
FINGUDELAR
Operacionesdealtasybajasdelaslistas
7.3 Transicionesdeestados

a) Mencione y realice un diagrama con los estados y transiciones de los procesos.
b) Discuta, segn las transiciones, si un ncleo (kernel) es expropiativo (preemptivo) o no .
Respuesta:
Si el planificador es invocado solamente cuando un proceso finaliza su ejecucin o cuando se
bloquea, el ncleo no es expropiativo. Si, adems, el planificador es invocado cuando un proceso
pasa de estado bloqueado a listo o de ejecutando a listo, el ncleo se dice que es expropiativo.
7.4 Operacionessobreprocesos
typedef struct PCB {
char name[MAX_STRNAME];
unsigned int pid;
Memory * memoria;
Resources * recursos;
CPUState * registros;
Priority prioridad;
State estado;
listPCB * datosEstados;
PCB * ancestro;
listPCB * descendientes;
};
PCB * CreateProcess(char * id, Memory m0, Priority p0) {
PCB * p = new PCB;
strcpy(p->idExt,id);
p->pid = getNewId(); // Obtener id. interno.
p->memoria = m0; // Descriptores de memoria.
p->recursos = NULL; // Recursos vaco.
p->prioridad = p0; // Setear prioridad.
p->estado = pronto; // Estado pronto.
p->datosEstado = RL; // En la ready list.
p->ancestro = this; // Padre el proceso creador.
p->descendientes = NULL; // Ningn descendiente.
Insert(this->descendientes,p); // Ins. Descendientes padre.
Insert(RL,p); // Ins. En la ready list.
return p;
}
void DestroyProcess(char * idExt) {
PCB * p = getPointer(idExt); // Obtiene el PCB del idExt.
bool despachar = false;
if (p->estado == ejecutando) {
69
FINGUDELAR
Procesador[p->procesador] = NULL;
despachar = true;
} else if (p->estado == bloqueado) {
Delete(p->datosEstado->espera,P); // Sacar de cola recurso.
} else
Delete(RL,P); // Sacar de la Ready list.
for all q in p->descendientes do q->ancestro = getPCB(init);
for all rec in p->recursos do Release(rec);
FreeMemory(p->memoria);
delete p;
if (despachar) schedule();
7.5 OperacionessobreRecursos
La operacin Crear Clase de Recurso implica adquirir una instancia del RCB y
posteriormente inicializar el inventario, la lista de espera, operaciones de altas y
bajas en estas listas, as como la especificacin del administrador.
typedef Waiters_R * (*Allocator)();
typedef struct RCB {
char name[MAX_STRRSCNAME];
Avail_R * disponibilidad;
Waiters_R * espera;
Allocator administrador;
};
7.5.1 RequerirRecurso
void Request(char * recurso, Request_R * pedido, Assign_R * detalleAsig){
RCB * R = getPointer(recurso);
Waiters_R * lstPCB = NULL;
bool meAsignaron = false;
bool despachador = false;
R->InsertWaiters(new Waiters_R(this,pedido,detalleAsig));
lstPCB = *(R->administrador)();
while (lstPCB != NULL) {
if (lstPCB->p != this) {
Insert(RL,lstPCB->p);
lstPCB->estado = pronto;
lstPCB->datosEstado = RL;
despachador = true;
} else
meAsignaron = true;
lstPCB = lstPCB->next; // Falta liberar memoria.
}
if (!meAsignaron) { // Debo bloquearme
this->estado = bloqueado;
this->datosEstado = R;
Procesador[this->procesador] = NULL;
} else if (despachador) {
this->estado = pronto;
this->datosEstado = RL;
Procesador[this->procesador] = NULL;
}
if (this->estado != ejecutando)
schedule();
}
7.5.2 LiberarRecurso
void Release(char * recurso, Assign_R * asignado) {
listPCB * lst;
RCB * R = getPointer(recurso);
R->InsertAvail(asignado);
lst = *(R->administrador)();
while (lst != NULL) {
Insert(RL,lst->p);
70
FINGUDELAR
lst->p->estado = pronto;
lst->p->datosEstado = RL;
lst = lst->next;
}
schedule();
7.6 Planificador
void Swap(PCB * P, PCB * Q) {
int pros = P->procesador;
if (P != this)
Interrupt(pros);
SalvarEstado(pros,P->registros);
if (P == this)
AjustarPC(this->registros); // Poner #dir retorno.
CargarEstado(pros,Q->registros);
}
void schedule() {
PCB * diferido;
PCB * p;
PCB * Q_Min;
Priority prioridad = MAX_PRIORIDAD;
bool encontre = false;
while (true) {
p = buscoMayor(prioridad);
if (p == NULL) {
Finalizo(diferido); break;
}
AsignoCPULibre(p,&encontre,&Q_Min,&diferido);
if (!encontre) && (Q_Min->prioridad < p->prioridad)
Preempt(Q_Min,p,&diferido);
else {
Finalizo(diferido); break;
}
}
}
void AsignoCPULibre(PCB * p, bool * encontre, PCB ** Q_Min, PCB **
diferido) {
int pros = 0;
*encontre = false;
*Q_Min = p;
while (!(*encontre) && pros < #CPUs) {
if (Procesador[pros] == NULL) {
*encontre = true;
Procesador[pros] = p;
p->procesador = pros;
p->estado = running;
if (pros == this->procesador)
*diferido = p;
else
cargoEstado(pros,p->registros);
}
else
if (Procesador[pros]->prioridad < *Q_Min->prioridad)
*Q_Min = Procesador[pros];
pros = pros + 1;
}
}
void Preempt(PCB * Q_Min, PCB * P, PCB ** diferido){
Q_Min->estado = pronto;
P->estado = ejecutando;
P->procesador = Q_Min->procesador;
if (Q_Min == this)
*diferido = P;
71
FINGUDELAR
else
Swap(Q_Min,P);
}
void Finalizo(PCB * diferido) {
if (this->estado != ejecutando)
Swap(this,diferido);
Exit Schedule; % return;
}
7.7 Ejemplo(semforobinario)
typedef Request_R void;
typedef Assign_R void;
typedef Avail_R int;
Waiters_R * Administrador() {
Waiters_R * lst = NULL;
if ((*(this->disponibilidad) == 1) && (!IsEmpty(this->espera))) {
lst = head(this->espera);
this->espera = tail(this->espera);
*(this->disponibilidad) = 0;
}
return lst;
}
Avail_R * createAvail(){
return new int(1); // Crea una disponibilidad de 1.
}
// Insert en disponibilidad
void InsertAvail(Assign_R * asignado) {
*(this->disponibilidad) = 1;
}
void P(char * semid) {
Request(semid, NULL, NULL);
}
void V(char * semid) {
Release(semid, NULL);
}
typedef struct Waiters_R {
PCB * p;
Request_R * pedido;
Assign_R asignado;
Waiters_R * next;
}
Waiters_R * createWaiter(){
return NULL; // Crea la cola vaca de espera.
}
// Insert en la cola de espera del recurso (FIFO en este caso).
void InsertWaiters(struct elemWait_R * e) {
Waiters_R * ptr;
if (this->espera == NULL) {
this->espera = new Waiters_R;
this->espera->element = e;
this->espera->next = NULL;
} else {
ptr = this->espera;
while (ptr->next != NULL) ptr = ptr->next;
ptr->next = new Waiters_R;
ptr->next->element = e;
ptr->next->next = NULL;
}
}
72
FINGUDELAR
8 Administracindememoria
8.1 Introduccin
La administracin de la memoria es una de las ms importantes tareas del
sistema operativo.
En los sistemas operativos multiprogramados es necesario mantener varios
programas en memoria al mismo tiempo.
Existen varios esquemas para la administracin de la memoria y requieren distinto
soporte del hardware.
El sistema operativo es responsable de las siguientes tareas:
Mantener qu partes de la memoria estn siendo utilizadas y por

quin.
Decidir cules procesos sern cargados a memoria cuando exista
espacio de memoria disponible.
Asignar y quitar espacio de memoria segn sea necesario.
8.2 Conceptosbsicos
Preparacin de un programa para ejecutar
Los programas son escritos, por lo general, en lenguajes de alto nivel y deben
pasar por distintas etapas antes de ser ejecutados:
Compilacin (compile):
traduccin del cdigo fuente del
programa a un cdigo objeto.
Ensamblaje (linker):
ensamblaje de varios cdigos
objetos en un archivo ejecutable.
Carga (load): asignacin del
archivo ejecutable a la memoria
principal del sistema.
Examen marzo 2005:
Cules son las etapas previas por las
que debi pasar un proceso que se
encuentra en la lista de procesos listos, a
partir de un archivo que contiene un
cdigo fuente escrito en lenguaje C?
Respuesta:
Se debe primero compilar (compile),
luego ensamblar (link) con los dems
cdigos objetos para crear un archivo
ejecutable. Finalmente, el cargador del
sistema lo debe cargar (loader).
Examen mazo 2008:
Por cules etapas debe pasar un cdigo
fuente escrito en un lenguaje de
programacin de alto nivel antes de
poder ser ejecutado en un sistema operativo?
Un programa ejecutable consta de secciones de instrucciones y de datos.
73
FINGUDELAR
El linker surge ante la necesidad de modularizar y reutilizar cdigo. Se resuelven
las referencias externas, as como las posiciones relativas de los smbolos en los
diferentes mdulos, formando uno consolidado.
La necesidad de ejecutar programas que requeran ms memoria de que se
dispona en el sistema gener la tcnica de memoria virtual propuesta por
Fotheringham en 1961.
La idea es mantener en memoria fsica solamente la memoria que el proceso est
utilizando y en resto en disco.
De esta forma, el programador se despreocupaba de la limitacin de memoria que
impona el sistema.
La tcnica de memoria virtual abstrae la memoria principal en un gran arreglo
uniforme de bytes.
Si bien es una tcnica muy potente, el uso descuidado puede generar una
degradacin importante del sistema.
Qu permite la memoria virtual?
Respuesta:
Es una tcnica que permite que la ejecucin de un proceso aunque ste no est completamente
cargado en memoria. Esto hace que los procesos puedan ser ms grandes que la memoria fsica
(o real) del equipo.
Examen marzo 2006:
Qu beneficios brinda el concepto de memoria virtual?
Respuesta:
Independiza la direccin de carga y ejecucin de la dir. de memoria real. - Que el tamao de
memoria que un proceso puede utilizar sea mayor a la memoria fsica del equipo. - Abstrae el
concepto de memoria a un largo y uniforme espacio independiente de la disponibilidad real. Separa la vista del usuario de la memoria virtual (o lgica) de la memoria fsica.
Cada proceso tiene un espacio de direccionamiento virtual (virtual address space)

Las direcciones de memoria que genera el proceso son absolutas en el espacio de
direccionamiento.
Describa lo que es una direccin virtual (logical address) y una direccin real (physical address)
Respuesta:
Direccin virtual (lgica): Direccin generada por los programas a nivel de CPU.
Direccin real (fsica): Es una direccin sobre la memoria real (fsica).
74
FINGUDELAR
Qu se entiende por direccionamiento virtual? Explique que es una direccin lgica o virtual y
qu es una direccin fsica.
Respuesta:
En un sistema que maneje memoria virtual, a cada proceso se le asigna un espacio virtual (o
lgico) de direccionamiento. Este espacio virtual permite abstraerse del direccionamiento fsico
(real). Por lo general el direccionamiento esta restringido por los bits de la arquitectura. Por
ejemplo, en una arquitectura de 32 bits, un proceso puede generar direcciones de hasta 232 =
4GB. Por lo que podra acceder a una memoria virtual de 4GB. Una direccin lgica o virtual es la
direcciones generadas por el proceso (se puede decir que son las que se utilizan a nivel de CPU),
mientras que una direccin fsica es una direccin real de la memoria principal del sistema. En la
mayora de los sistemas actuales la unidad de administracin de memoria (MMU- dispositivo de
hardware) es la encargada de hacer la conversin de direcciones lgicas a fsicas.
Examen julio 2007:
Qu entiende por direccionamiento virtual de un proceso?
Ej.: en un sistema de 32 bits, un proceso y realizando un mapeo directo de

direcciones, un proceso tiene un espacio de direccionamiento virtual de 232 = 4Gb.
La unidad de administracin de memoria (MMU - Memory Management Unit) es la
encargada de realizar la traduccin de direcciones virtuales a fsicas.
Examen marzo 2005:
El espacio de direcciones virtuales de un proceso depende de la arquitectura (hardware) o del
sistema operativo?
Respuesta:
De los dos. La arquitectura le impone una cota mxima, pero el software puede ejecutar en
niveles menores.
Segn su respuesta anterior: Si tenemos una arquitectura de 64 bits con un sistema operativo en
32 bits. Cul es el tamao mximo de direccionamiento posible para un proceso?
Respuesta:
32 bits.
8.3 AsociacindeDirecciones(AddressBinding)
La asignacin de la ubicacin de un programa en memoria principal puede
ser realizada en varios tiempos:
Examen mazo 2008:
qu entiende por asociacin de direcciones?
Tiempo de compilacin (compile time): el programa ser asignado

a un lugar especfio y conocido de la memoria fsica. Las direcciones de
memoria son referenciadas en forma absoluta (static relocation).
75
FINGUDELAR
Tiempo de carga (load time): la asignacin del lugar de memoria

donde ser cargado el programa es hecho al momento de la carga. Las
direcciones de memoria deben ser referenciadas en forma relativa
(dynamic relocation).
Tiempo de ejecucin (execution time): un programa puede variar

su ubicacin en memoria fsica en el transcurso de la ejecucin.

Describa el mtodo de asignacin de direcciones (address binding) en tiempo de ejecucin
(execution time).
Respuesta:
El mtodo de asignacin en tiempo de ejecucin permite a la memoria de un proceso ser
reubicada del lugar fsico mientras el proceso est activo (ejecutando, listo, bloqueado) en el
sistema.
8.4 Tiposdedireccionamiento
Se definen varios tipos de direccionamiento:
Direccionamiento lgico (logical address): es el generado por el

procesador
Direccionamiento fsico (physical address): la unidad de memoria
manipula las direcciones fsicas.
Direccionamiento virtual (virtual address): son las direcciones
lgicas que se generan cuando existe asociacin de
redireccionamiento en tiempo de ejecucin.
Para la asociacin de direccionamiento en tiempo de compilacin o carga, las

direcciones lgicas o fsicas coinciden. No es as para la asociacin en tiempo de
ejecucin.
Las traducciones de direcciones lgicas a fsicas son hechas por la MMU. Los
proceso solamente manipulan direcciones lgicas y no visualizan las fsicas, que
solamente son vistas por la MMU.
76
FINGUDELAR
8.5 Cargadinmica(dynamicloading):
El tamao de un proceso en memoria est limitado por la cantidad de memoria
fsica del sistema.
Con el fin de lograr mayor aprovechamiento de la memoria se puede utilizar la
carga dinmica.
La carga dinmica dispone que una rutina no es cargada en memoria fsica hasta
que no sea invocada.
La ventaja de la carga dinmica es que las rutinas no utilizadas nunca son
cargadas en memoria fsica, por lo tanto no consumen recursos de forma
innecesaria.
Examen:
Qu entiende por carga dinmica (dynamic loading)? Explique el concepto y sus beneficios.
Respuesta:
El dynamic loading permite que una rutina no sea cargada en memoria principal hasta tanto no
se utilice. Entre los beneficios se puede mencionar que no se cargan innecesariamente rutinas
que no son invocadas. A su vez, los binarios en el sistema ocupan menos espacio ya que se
pueden crear bibliotecas dinmicas que varios programas referencien.
8.6 Ensamblajedinmico(dynamiclinking)
En la etapa de ensamblaje de un programa las bibliotecas compartidas pueden
incorporarse al archivo ejecutable generado (ensamblaje esttico - static linking).
Ej. en Linux: /usr/lib/libc.a
Otra opcin es que las bibliotecas compartidas sean cargadas en tiempo de
ejecucin (ensamblaje dinmico, dynamic linking).
Ej. en Linux /usr/libc.so, en windows system.dll
En los archivos ejecutables las bibliotecas estticas son incorporadas, mientras
que para las dinmicas se mantiene una referencia.
Ej. en Linux comando ls:
$ ldd /bin/ls
librt.so.1 => /lib/librt.so.1 (0x4001c000)
libc.so.6 => /lib/libc.so.6 (0x40030000)
libpthread.so.0 => /lib/libpthread.so.0 (0x40149000)
/lib/ld-linux.so.2 (0x40000000)
Esto permite, junto con la carga dinmica, hacer un uso ms eficiente de la
memoria, ya que las bibliotecas dinmicas se cargan una nica vez en memoria
principal.
Examen marzo 2005:
Enumere dos ventajas de utilizar libreras dinmicas en vez de libreras estticas.
Respuesta:
a. Se aprovecha mejor el espacio en disco.
b. Es ms fcil cambiar una versin de una biblioteca que mantenga los cabezales (headers) ya
que no es necesario re-compilar los cdigos fuentes de los programas.
c. Mejor utilizacin de la memoria voltil (RAM). El sistema operativo carga una nica copia de la
biblioteca dinmica. Los procesos que la utilizan hacen referencia sin necesidad de cargarla para
cada uno.
77
FINGUDELAR
8.7 Overlays
En la carga dinmica las rutinas eran cargadas a demanda segn su invocacin.
Para lograr un mejor uso del recurso memoria se mantiene solo las instrucciones y
datos que son necesarios en un momento dado.
Ej.: two-pass assembler
Pass1
70Kb.
Pass2
80Kb.
Symbol Table 20Kb.
Common routines 30 Kb.
8.8 Swapping
En sistemas multiprogramados ms de un proceso est cargado en la memoria
principal. Para obtener un mayor nivel de multiprogramacin, los procesos que no
estn ejecutando pueden ser llevados a disco temporalmente.
El disco (backing store) es un espacion donde se dispondrn las imgenes de
memoria de los procesos.
Al mecanismo de llevar un proceso desde memoria principal a disco se le
denomina swap-out. Al inverso se le denomina swap-in.
El mayor tiempo considerado en el swapping es el tiempo de transferencia
El lugar de memoria donde ser asignado un proceso en el momento de swap-in
depende del mtodo de asociacin de direccionamiento (address binding) utilizado.
En la asociacin en tiempo de compilacin o de carga (compile, load time) debe
ser el mismo lugar, mientras que si la asociacin es en tiempo de ejecucin la
asignacin del lugar es libre.
78
FINGUDELAR

Describa brevemente en que consiste la tcnica de swapping as como su oportunidad de uso.
Respuesta:
Consiste en retirar a almacenamiento secundario casi la totalidad de las pginas de un proceso
de forma de generar una gran disponibilidad de memoria real. Esto es necesario, en situaciones
de Thrashing o sobrecarga del sistema de memoria virtual.
8.9 Asignacindememoria
La memoria, por lo general, se divide en dos particiones:
Sistema operativo residente.

Procesos de usuarios.
Es necesario un mecanismo de
proteccin de memoria entre procesos
entre s y el sistema operativo.
El registro de ubicacin (relocation
register) y el registro lmite se utilizan
para realizar la verificacin de accesos
vlidos a la memoria.
Toda direccin lgica debe ser menor
al valor del registro lmite.
8.10 Multiprogramacinconparticionesfijas
El sistema es inicializado con un nmero de particiones fijas, limitando el nmero
de procesos concurrentes.
Los procesos son asignados a memoria en el momento de carga a particiones
libres.
79
FINGUDELAR
A medida que terminan nuevos procesos son cargados en las particiones que
quedan libres.
Un ejemplo fue el sistema OS390/MFT (Multiprogramming with a Fixed number of
Tasks).
8.11 Multiprogramacinconparticionesvariables
Los procesos son asignados a memoria en forma contigua. A medida que terminan
van generando "agujeros" en la
memoria principal en donde los
nuevos procesos son cargados.
8.12 Estructurasparaasignacin
El sistema operativo debe llevar cuenta de las particiones ocupadas y libres.
Los mtodos ms comunes utilizados son a travs de:
Mapa de bits
Lista encadenada
Diccionarios
8.13 Estrategiadeasignacin
En la asignacin de memoria a un proceso existen varias estrategias:
First fit: asigna el primer "agujero" de memoria libre que satisfaga la
necesidad
Best fit: asigna el mejor "agujero" de memoria libre que exista en la
memoria principal
Worst fit: asigna el requerimiento en el "agujero" ms grande que
exista en la memoria principal
Estudios de simulacin han mostrado que first-fit y best-fit lograron mejores
rendimientos en tiempo de asignacin y utilizacin de la memoria que la estrategia
worst-fit.
80
FINGUDELAR

En la gestin de memoria, qu problemas plantea el algoritmo de bsqueda de bloques libres
Best Fit?
Respuesta:
Incrementa el consumo de CPU en ocasin de la bsqueda y tiende a generar bloques
libres extremadamente pequeos y escasamente reusables.
En un sistema con segmentacin de 4096 bytes de memoria fsica, se tienen asignados los
siguientes segmentos:
Base
Largo (bytes)
100
150
300
1024
40
20
2600
512
1358
128
Cul sera la asignacin en memoria fsica de los tamaos de segmentos que aparecen en la
lista de abajo, segn las estrategias de asignacin First-fit, Best-fit y Worst-fit? Asuma que los
pedidos de segmentos llegan en orden de izquierda a derecha, la memoria empieza en la
direccin 0 y los segmentos que no pueda ubicar son descartados. Lista de segmentos nuevos:
128, 40, 1024, 32, 40, 45.
Respuesta:
(base, largo)
First Fit: (1486,128), (0,40), descartado 1024, (60,32), (250,40), (1614, 45)
Best Fit: (3112,128), (0,40), (1486,1024), (1324,32), (60,40), (250, 45)
Worst Fit: (1486, 128), (1614, 40), descartado 1024, (3112,32), (3144,40), (1654, 45)
Examen abril 2003:
Describa brevemente las siguientes tcnicas de asignacin de memoria: First Fit, Best Fit, Worst
Fit.
Indique las ventajas y desventajas de cada una de ellas
Respuesta:
First Fit
Asigna el primer espacio que tenga tamao suficiente. La bsqueda puede comenzar en el inicio
de la lista de espacios, o donde termin la bsqueda anterior. La bsqueda termina al encontrar
el primero de tamao suficiente. Es el ms rpido de los 3, si bien en la utilizacin de
almacenamiento es comparable a Best Fit.
Best Fit
Asigna el menor espacio de tamao suficiente. Hay un mayor costo en la bsqueda o en la
insercin segn se mantenga o no una lista ordenada de espacios libres. Produce el fragmento
sobrante ms pequeo, que tendr una escasa probabilidad de volver a ser reusado.
Worst Fit
Asigna el hueco ms grande, a fin de evitar el problema anterior. Sin embargo sigue siendo
ineficiente como Best Fit.
8.14 Fragmentacin
Las estrategias de asignacin presentadas muestran problemas de fragmentacin
externa.
81
FINGUDELAR
En la memoria van quedando una cantidad de "agujeros" chicos, que no son
asignados. La memoria libre est fragmentada en una gran cantidad de "agujeros"
chicos.
La fragmentacin externa existe cuando existe suficiente memoria libre en el
sistema para satisfacer un requerimiento de memoria, pero no es posible asignarlo
debido a que no es contiguo.
8.15 Paginacin
La paginacin es una tcnica que divide a la memoria fsica en particiones de
tamao fijo llamados frames.
A su vez, el espacion de direccionamiento virtual es dividido en unidades fijas del
mismo tamao que los frames (page size) denominadas pginas (pages).
Las pginas tienen un tamao que es potencia de 2 y, en general, son desde 512
bytes a 16 Mb.
En los sistemas que brindan paginacin, la transferencia entre memoria principal y
el disco es siempre en unidad de pgina.
Cuando un proceso ejecuta, sus pginas son cargadas en los frames de memoria
principal y en disco (seccin de swap).
Los frames en el swap tienen el mismo tamao que los frames de memoria
principal.
8.16 Direccionamientoenpaginacin
Las direcciones virtuales en paginacin se componen de un nmero de pgina (page
number) y un desplazamiento (offset).
El nmero de pgina es un ndice sobre una tabla de pginas (page table) y el
desplazamiento es la referencia dentro del frame
La tabla de pgina contiene el mapeo del
frame correspondiente.
El tamao de la pgina es 2n
82
FINGUDELAR

Dado un sistema con paginacin, donde la memoria tiene un ciclo de acceso de 200ns y hay una
probabilidad del 50% de hallar en el cache del procesador la entrada correspondiente en la tabla
de traduccin de pginas. Indique la velocidad promedio de acceso a memoria.
Respuesta:
La velocidad promedio de acceso a memoria ser de 300 n/s.
Si hallamos el descriptor en el TLB => un acceso a memoria aplicable al 50% de los casos.
Si no hallamos el descriptor en el TLB => 2 accesos a memoria aplicable al 50% de los casos.
Como la probabilidad de hallar en el TLB el descriptor es del 50 %, entonces T = 0.5 * 200 + 0.5 *
400 = 300
En qu consiste el modelo de paginacin simple (de un nivel)? Muestre cmo las direcciones
virtuales se mapean a direcciones reales. Mencione todos los elementos involucrados.
Respuesta:
Paginacin simple: La memoria real es dividida en bloques (frames) de tamao fijo. La memoria
virtual es tambin divida en bloques del mismo tamao que son llamados pginas.
El tamao de pgina esta dado por el hardware.
La traduccin de una direccin virtual a real se hace as:
Las direcciones virtuales se dividen en 2 partes: un nmero de pgina y un offset:
+-----------+------------+
| p
|
d
|
+-----------+------------+
Direccin virtual
p es un ndice de la tabla de paginacin (que en general la prove el hardware).
Con p se va a la tabla y se obtiene f (frame de la memoria real), que junto con d forman la
direccin real:
+-----------+------------+
| f
|
d
|
+-----------+------------+
Direccin real
Examen julio 2004:
Se tiene un sistema de gestin de memoria paginada. El espacio de direccionamiento virtual es
de 10 pginas de 1024 palabras, la palabra es 2 bytes de tamao. La memoria fsica esta dividida
en 32 marcos.
a. Cuntos bits componen una direccin virtual? Justifique brevemente.
b. Cuntos bits componen una direccin fsica? Justifique brevemente.
Respuesta:
En memoria paginada las direcciones virtuales se componen de un nmero de pgina y del
desplazamiento dentro de la pgina. El nmero de pginas totales es 10, por lo que se precisan 4
bits para distiguir entre ellas. Mientras que cada pgina tiene 1024 palabras, si se referncia por
palabra se debern utilizar 10 bits, si es por byte es de 11.
Entonces con referenciamiento por palabra seran: 14 bits (4 + 10).
Entonces con referenciamiento por byte seran: 15 bits (4 + 11).
b)Para direccionar una direccin fsica, es necesario indicar su nmero de marco de pgina y su
desplazamiento:
El nmero de marcos de pginas totales es 32, por lo tanto, para distinguir entre estos 32 marcos
hacen falta 5 bits. El desplazamiento corresponde al tamao del marco de pgina, igual al de la
83
FINGUDELAR
pgina, por lo tanto de 1024 palabras, luego es necesario 10 bits para distinguir entre las
palabras u 11 bits si el desplazamiento se expresa en bytes. En total para representar la direccin
fsica son necesarios 15 bits si se expresa el desplazamiento en palabras o 16 bits si se expresa
en bytes.
a) Para qu se utiliza la tabla de pginas? Respuesta: Su funcin principal es para poder realizar
la traduccin de pgina virtual a frame fsico.
b) A qu nivel se mantiene en memoria (memoria del sistema operativo o del proceso)?
Respuesta: La estructura es guardada a nivel del sistema operativo. De otra forma, el proceso
podra modificarla. Tambin se puede mencionar que el proceso la puede acceder, pero solo en
formato lectura.
c) El Translation Look-aside Buffer para qu sirve?
8.17 Soporteaniveldehardware
La mayora de los sistemas operativos asignan una tabla de pgina por proceso.
Un puntero al comienzo de la tabla de pgina es agregado al PCB del proceso.
El uso de registros para alojar la tabla tiene la ventaja del acceso rpido, pero la
cantidad de entradas es muy limitada
Ej. DEC PDP-11
Contaba con direcciones de 16 bits y por lo tanto, su espacio de direccionamiento
era de 64Kb.
El tamao de pgina era de 8Kb, por lo que la tabla contaba con solamente 8
entradas (dispuestas en los registros del procesador).
En los sistemas actuales no es posible guardar todas las entradas en registros de
rpido acceso.
La tabla se mantiene en memoria principal y se asigna a un registro que apunta a
la direccin base de la tabla (PTBR - Page Table Base Register).
La opcin del PTBR mejora el cambio de contexto entre procesos ya que solo es
necesario cambiar un registro para acceder a la tabla de pgina.
Sin embargo, el acceso a memoria se duplica debido a que es necesario primero
acceder a la tabla para obtener el umero de frame y posteriormente al lugar de
memoria solicitado.
La solucin es utilizar una pequea cache de la tabla de pgina: TLB - Translation
Look-aside Buffer.
El cache TLB es asociativa y de rpido acceso.
Cada entrada consiste en dos partes: una clave (tag) y un valor (el nmero de
frame).
La bsqueda de una clave en la cache TLB es simultnea entre todas las tags.
Si la clave es encontrada (TLB hit), inmediatamente se genera la direccin
buscada a partir del valor asociado .En caso contrario (TLB miss), es necesario
realizar el acceso a memoria para obtener la entrada. Posteriormente, se guarda el
valor obtenido en la cache TLB para posteriores accesos (principio de localidad).
84
FINGUDELAR
Los TLB por lo general tienen pocas entradas (64 a 1024).

Algunas caches TLB agregan a cada entrada un identificador de espacio de
direccionamiento (ASID - Address Space IDentifier).
En la bsqueda de una clave solo sern tenidas en cuenta las entradas cuyo ASID
coincida con el del proceso que se est ejecutando en el procesador.
El uso del identificador permite que en la cache TLB contengan entradas para
varios procesos de forma simultnea.
Si no se utiliza el ASID, en cada cambio de contexto es necesario "limpiar" las
entradas en la TLB, si no se realizaran accesos equivocados a memoria.
Examen marzo 2003:
a) Qu es y para que sirve la TLB y que optimizacin podra utilizarse a nivel de hardware para
optimizar su utilizacin?
Respuesta:
La TLB ( Translation Look-aside Buffer ) es un conjunto de registros construidos con memoria de
alta velocidad que, dado un nmero de pgina se compara simultneamente con todas las
entradas que contiene y si se encuentra el nmero de marco correspondiente, entonces se
devuelve. Es usado a modo de cache para mantener algunas de las entradas de la tabla de
pginas. A diferencia de la tabla de pginas tradicional, en gral. se evita tener dos accesos a
memoria ( el acceso a la tabla y el acceso efectivo ) para acceder a una localidad. A nivel de
hardware se puede optimizar haciendo que la MMU cargue en la TLB una entrada, luego de
resolverla ( ej: SPARC, 80x86 ), en vez de delegarlo al sistema para que lo haga a nivel de
software ( ej: MIPS ).
b)
1. Explique los requerimientos de hardware y software necesarios para soportar un mecanismo
de segmentacin. Por qu seria bueno utilizar este mecanismo?
Respuesta:
Se requiere una tabla de segmentos o descriptores usada para mapear las direcciones virtuales
( segmento, offset ) en direcciones fsicas. La tabla debe mapear en s nmeros de segmento en
el lmite y base de cada uno. Si se mantiene en memoria, debe mantenerse registros base y
lmite de la tabla. Debe verificarse que el offset est entre ambos, o generar una trap. Este
mecanismo es bueno porque permite la proteccin de segmentos, si se utilizan bits de proteccin
asociados a cada entrada de la tabla. El hardware los consultar para evitar accesos ilegales a
memoria ( ej: escribir en un segmento de slo lectura ). Habitualmente en el segmento se
agrega un puntero inverso hacia la tabla.
2. Cmo resolvera ud., utilizando el entorno de (1), la necesidad de compartir segmentos entre
procesos?
Respuesta:
La segmentacin permite el compartimiento de cdigo o datos entre distintos procesos. Para los
segmentos de cdigo se comparte el diccionario, para los segmentos de datos las alternativas
son:
i. Slo un descriptor apunta la segmento y otros procesos
85
FINGUDELAR
cuentan con copias que apuntan al principal ( dando un
nivel de indireccin )
ii. Que hayan descriptores adicionales que apunten al
original.
3. Cmo implementara la reorganizacin de la memoria contemplando (2) y en un ambiente de
multiprocesadores?
Respuesta:
Ante la necesidad de reorganizar memoria, con la alternativa (i), se debe bloquear el descriptor
original, se desplaza el segmento y luego se actualiza el descriptor, pues en el momento de
hacerlo puede haber otro proceso ejecutndose. Con la alternativa (ii) se debe hacer lo mismo,
pero para todo descriptor, debiendo realizar un scan de los diccionarios que potencialmente lo
referencien, buscando las copias.
En un sistema con memoria virtual, cul es la funcin del dispositivo de hardware MMU
(memory-management unit)?
Respuesta:
Realizar la traduccin de direcciones de memoria virtuales a fsicas.
En un sistema que soporta memoria virtual. Quin realiza las traducciones de memoria virtual a
fsica? Describa cmo se hace la traduccin de virtual a fsica en paginacin.
Respuesta:
La traduccin es realizada por el dispositivo MMU (Memory Management Unit). En el cambio de
contexto, cuando un proceso es asignado a un procesador, se carga el registro PTBR (Pointer
Table Base Register) de la MMU con la direccin base de la tabla de pgina. Cada acceso a
memoria (virtual) generado por un proceso es traducido a memoria fsica por la MMU. En
paginacin la direccin virtual se compone de una seccin que indica la entrada de la tabla de
pginas que se accede (para obtener el nmero de marco) y de otra seccin que indica el
desplazamiento dentro del marco.
Qu funcin cumple la TLB?
Respuesta:
Cumple la funcin de memoria cache de las entradas de la tabla de pginas. Esto permite mejor
velocidad de acceso, ya que si se logra un hit en la cache no es necesario acceder a memoria
fsica a buscar la entrada correspondiente de la tabla de pginas.
a. Para qu es utilizada la TLB (Translation Look-aside Buffer)? b. La TLB es un dispositivo de
hardware o software?
8.18 Tiempoefectivodeacceso(EffectiveAccessTime)
El porcentaje de veces que un nmero de pgina es encontrado en la cache TLB
es denominado hit ratio.
El tiempo efectivo de acceso se define mediante la siguiente frmula
EAT: hit ratio * (tiempo de bsqueda en TLB + tiempo de acceso a memoria)
+ ( 1 - hit ratio ) * (2 * tiempo de acceso a memoria)
La medida nos permite saber la ganancia de la utilizacin de la cache TLB
8.19 Proteccindememoria
La tabla de pgina tiene una entrada por cada pgina posible que tenga el
proceso.
Es necesario identificar cules son entradas vlidas y cules no.
La utilizacin de un bit de proteccin en cada entrada determina si la pgina es
vlida o invlida (valid-invalid bit).
86
FINGUDELAR
El acceso a una pgina cuyo bit marca que es invlida, genera un trap a nivel del
sistema operativo.
8.20 Estructuradelatabladepgina
En un sistema de 32 bits que utilice pginas de 4Kb se necesitaran cerca de 1
milln de entradas en la tabla de pgina.
Es necesario buscar alguna estructura ms eficiente en cuanto al tamao ocupado
por la tabla de pgina.
Se proponen las siguiente estructuras.
Jerrquica
Diccionarios
Invertida
8.20.1 Jerrquica
La estructura se basa en paginar la tabla de pgina. De esta forma, existir una
jerarqua de pginas.
La idea es dividir el componente indexado en la tabla de pgina, de la direccin
virtual, en varios niveles.
Este esquema se puede aplicar varias veces y lograr varios niveles de indexacin.
en el grfico se ven 2 niveles.
87
FINGUDELAR
8.20.2 Diccionarios
Una opcin es implementar una tabla de hash abierto con el valor de la
componente de nmero de pgina.
Esta estructura es conveniente para arquitecturas de ms de 32 bits.
88
FINGUDELAR
8.20.3 Invertida
Se dispone de una nica tabla de pgina global del sistema. A diferencia de los
anteriores que existe una tabla por proceso. Se aumentan los tiempos de bsqueda,
en favor de la reduccin del espacio utilizado en memoria principal.
8.21 Compartimiento
Los procesos se componen de una parte de cdigos y datos privados y de otra
que puede ser compartida.
La posibilidad de dividir el espacio de direccionamiento en pginas, permite a
las procesos compartir en forma eficiente las pginas comunes en memoria.
89
FINGUDELAR
Ejemplo:
La seccin de cdigo de un mismo proceso.

El cdigo de una biblioteca dinmica.
Memoria compartida.
Esto permite un uso ms eficiente de la memoria.
8.22 Segmentacin
La segmentacin es una tcnica que asigna segmentos contiguos de memoria

para las reas de memoria de un proceso.
De esta forma, logra acomodarse ms a la visin de la memoria por parte del
usuario.
Un proceso se compone de una seccin de cdigo, una pila (stack), un espacio
para la memoria dinmica (heap), la tabla de smbolos, etc.
Cada componente se agrupa en un semento del tamao necesario.
90
FINGUDELAR
8.22.1 Soporteaniveldehardware
Cada segmento tendr un nombre (o nmero) y un largo asociado.
Las direcciones virtuales se componen de un nmero de segmento y el
desplazamiento dentro del
segmento.
El desplazamiento debe ser menor que el largo asociado al segmento.

La tabla de segmentos tendr una entrada por cada segmento, en donde estar la
direccin fsica base del segmento (base register) y el largo del mismo (limit
register).
En la traduccin de direccin virtual a fsica se controlan el nmero de segmento
con el mximo que tenga el proceso (el registro STLR - Segment Table length
Register - define el nmero mximo de segmento utilizado por el proceso) y el
desplazamiento contra el registro lmite.
La tabla de sementos es mantenida en memoria principal y se asigna un registro
que apunta a la direccin base de la misma (STBR - Segment Table Base Register).

Especifique los requerimientos de hardware para soportar eficientemente y en modo protegido un
esquema de segmentacin de memoria.
Respuesta:
91
FINGUDELAR
El procesador deber contar con:
diferentes niveles de ejecucin de instrucciones segn el esquema
habitual.
instrucciones privilegiadas y protegidas que entre otros cometidos
permitan asegurar la integridad de los descriptores.
El direccionamiento del espacio de memoria deber ser a travs del uso de
descriptores protegidos. Los mismos debern contar tambin con la
indicacin del largo del segmento, debindose producir una excepcin en
ocasin de indexar un descriptor con un valor superior a ste.
Describa el modelo de segmentacin. Muestre como las direcciones virtuales se mapean a
direcciones reales. Mencione todas las estructuras y elementos involucrados.
Respuesta:
Segmentacin es un esquema que soporta la perspectiva de la vista del usuario de lo que es la
memoria. La memoria se divide en segmentos de diferentes tamaos. Los segmentos estn
dados por la memoria usada por los programas. El espacio de las direcciones lgicas de un
proceso es un conjunto de los segmentos. Un ejemplo de un proceso:
Se tiene un segmento para las variables globales, otro para el stack, otro para el cdigo del
programa, otro para cada variable local de los procedimientos y funciones. La traduccin de una
direccin virtual a real se hace as: Las direcciones virtuales se dividen en 2 partes: un nmero de
segmento y un offset:
+-----------+------------+
| s
|
d
|
+-----------+------------+
Direccin virtual
s es un ndice sobre la tabla de segmentacin (que en general la provee el hardware).
Cada entrada de la tabla de segmentacin tiene 2 campos: lmite y base. El lmite es el tamao
del segmento y la base es la direccin real de donde comienza el segmento en memoria real.
Por un lado se verifica que: d < lmite, sino es as entonces se produce un trap de error. Por otro
lado se hace la suma:
base + d para obtener la direccin real
+------------------------+
| base +
d
|
+------------------------+
Direccin real
En un sistema con manejo de memoria a travs se segmentacin, se tiene el siguiente acceso a
memoria en el ambiente.
+---------------+
| 10 | 1324 |
Acceso a memoria del proceso P.
+---------------+
+-----------------------+
10 | 1112 | 32122 |
+------------------------+ Tabla de Segmento para el proceso P.
11 | 10121 | 32235 |
+--------------------- -+
...
El acceso a memoria es vlido? Justifique.
Respuesta:
No es vlido. Si bien se accede a un lugar de memoria del proceso, este est fuera del rango del
segmento, por lo que ocurre un trap.
Ilustre y explique brevemente como se implementa la correspondencia entre direcciones
virtuales y fsicas en un esquema de segmentacin.
Respuesta:
La direccin lgica est dada por un nmero de segmento (s) y un desplazamiento (d) dentro del
mismo. Con s se indiza la tabla de segmentos, que tiene la base y el lmite del segmento en
memoria fsica. Si d < 0 d lmite, es un intento de acceso errneo o no vlido, si no, se suma
el desplazamiento a la base y se obtiene la direccin real.
92
FINGUDELAR
8.22.2 Proteccindememoria
Al dividir la memoria en segmentos se permite que cada uno tenga asociado un
conjunto de permisos sobre l.
93
FINGUDELAR
Un segmento de cdigo es normal que tenga permisos de lectura y ejecucin y no
de escritura.
Un segmento de datos tendr permisos de lectura y escritura.
Se define un conjunto de bits de proteccin (bit protection) que el hardware
controla.
8.22.3 Compartimiento
Los segmentos permiten una forma clara y sencilla para ser compartidos entre
varios procesos.
8.23 ComparacinPaginacinSegmentacin
La paginacin genera fragmentacin interna. Dado que la granularidad es a
nivel de pgina, se generar espacio de memoria dentro de las pginas que quedar
sin uso.
La segmentacin sufre de fragmentacin externa. Los segmentos son
asignados de forma continua, pero a medida que son liberados generan huecos que
luego, al no ser completados totalmente, generan huecos ms chicos que quedan
inutilizados. Para solucionar esto es necesario una reorganizacin de la memoria
(tarea no menor).
La segmentacin logra implementar la visin que el usuario tiene de la memoria.
En paginacin el espacio de direccionamiento de un proceso se distribuye de forma
no contigua.
94
FINGUDELAR
La segmentacin logra compartir y proteger memoria entre procesos de forma
ms directa. Por ejemplo, en paginacin compartir un espacio de direccionamiento
de un proceso implica mantener una gran cantidad de referencias de pginas
compartidas, mientras que en segmentacin se comparte el segmento.
En paginacin, la asignacin de una pgina de memoria es ms rpida. Utilizando
un vector de bits se obtiene de forma sencilla un frame libre de memoria donde
puede ser asignada la pgina. En segmentacin es necesario mantener una lista y la
bsqueda se hace ms costosa.
Examen marzo 2004:
De tres ventajas de la segmentacin que no tenga la paginacin.
De tres ventajas de la segmentacin frente a la paginacin.
Respuesta:
Perspectiva de memoria del usuario:
Cada segmento representa una porcin de un programa definida semnticamente,
haciendo que todos los registros del mismo se utilicen de la misma forma. El usuario no
ve la memoria como un arreglo lineal de palabras (el enfoque de la paginacin), sino que
identifica estructuras de datos como tablas, pilas, mdulos, etc. Cada uno se puede
indentificar individualmente y tiene un tamao variable.
Proteccin:
Con segmentacin es posible definir el nivel de acceso a cada segmento. Agregando bits
en las entradas de la tabla de segmentos, por hardware se pueden evitar acceso
ilegales, p. ej. escribir en un segmento de slo lectura.
Compartimiento:
Cada proceso tiene una tabla de segmentos asociada a su PCB. El despachador la copia
a la tabla de segmentos nica del hardware cuando pasa un proceso a ejecucin, y la
respalda desde all cuando pierde el procesador. Como un segmento se corresponde a
un objeto de programa particular, se puede compartir este objeto haciendo que las
respectivas entradas en las tablas de segmentos apunten a la misma localidad fsica.
Examen julio 2005:
En una arquitectuera multiprocesador con segmentacin, describa los pasos y dificultades en
ocasin de cambiar un segmento de lugar como resultado de reorganizar la memoria.
Respuesta:
Localizar espacio libre contiguo de tamao suficiente para ubicar el segmento a mover.
Bloquear los procesos que referencial al segmento fsico a reubicar.
Mover el segmento.
Modificar las tablas de segmento de los procesos antes mencionados (colocando en la entrada
correspondiente el nuevo valor base y lmite).
Desbloquear los procesos.
Examen julio 2005:
Mencione las caractersticas principales de la proteccin y el compartimiento de segmentos en
una arquitectura con manejo de memoria a travs de segmentacin.
Respuesta:
Dado que existen segmentos de instrucciones de cdigo y de datos, a cada uno de ellos se les
puede asociar un modo de acceso (lectura/escritura). De esta forma, se pueden generar controles
a travs de hardware que permitan garantizar el acceso a los mismos por parte de los programas
Compartir segmentos de cdigos (que son segmentos de lectura), permite maximizar el uso de la
memoria principal. Los procesos que comparten un segmento de cdigo, solo manejan la
referencia al segmento compartido por ambos, y no hay necesidad de tener varias copias de un
mismo segmento.
Examen marzo 2006:
Describa ventajas y desventajas de manejo de memoria a travs de segmentacin.
Respuesta:
Ventajas:
- Simple compartir y proteger objetos, linking dinmico, reubicacin etc. - Podran haber 2
diccionarios (cdigo y datos), permitiendo por ej. reusar cdigo automticamente.
Desventajas:
- Complejas polticas de ubicacin y reemplazo. - Fragmentacin externa.
95
FINGUDELAR
Cules son las ventajas de utilizar segmentacin con respecto a paginacin?
8.24 Segmentacinconpaginacin
La paginacin y la segmentacin se pueden combinar para potenciar las ventajas
de cada tcnica.
Ejemplo de una arquitectura de este tipo es Intel.
La memoria es segmentada, y los segmentos se conforman de pginas.
Las direcciones virtuales contienen un identificador de segmento y un
desplazamiento, a partir de ellos se genera un direccin lineal de 32 bits (en el caso
de arquitectura de 32 bits). Luego, la direccin es traducida a una direccin fsica.
96
FINGUDELAR
9 MemoriaVirtual
9.1 Introduccin
La necesidad de ejecutar programas que requeran ms memoria de la que se
dispona en el sistema gener la tcnica de memoria virtual propuesta por
Fotheringham en 1961.
La idea es mantener en memoria fsica solamente la memoria que el proceso est
utilizando y el resto en disco.
La tcnica de memoria vitual abstrae la memoria principal en un gran arreglo
uniforme de bytes.
Si bien es una tcnica muy potente, el uso descuidado puede generar una
degradacin importante del sistema.
Ej.: estructura del espacio de direccionamiento en SunOS SPARC (32 y 64 bits)
Esquema de implementacin de memoria virtual
97
FINGUDELAR
Examen julio 2005:

Si se dispone de un sistema operativo que no implementa el concepto de memoria virtual, qu
problemas identifica en la ejecucin de los procesos? Podra existir la multiprogramacin en ese
sistema?
Respuesta:
No podran existir procesos de tamao mayor que la memoria fsica disponible ya que los
procesos deben cargarse completamente en memoria para ejecutar. S puede existir
multiprogramacin, limitada por la cantidad de procesos que puedan cargarse completos
simultneamente.
9.2 Implementacin
La implementacin de memoria vitual es realizada a travs de la tcnica de
paginacin bajo demanda.
Los sistemas en general brindan un esquema de segmentacin, en donde los
segmentos estn divididos en pginas.
En la paginacin bajo demanda los procesos residen en un dispositivo de disco y
son puestos en memoria principal
cuando es necesario cargarlos para
ejecutar.
La carga del proceso en memoria
no es total, sino que implementa un
cargador "perezoso" (lazy swapper),
que cargar las pginas segn se
vayan necesitando.
A su vez, los sistemas utilizan una
memoria denominada swap, que
permite mantener en el sistema ms
memoria utilizada que la fsica
disponible.
98
FINGUDELAR
Utilizar un esquema de este tipo requiere conocimiento de las pginas que estn
activas en memoria. Para esto se puede utilizar el valid-invalid bit.
En la tabla de pgina se tienen las pginas que estn cargadas en memoria principal,
conteniendo el nmero de frame y el valid-invalid bit.
Al principio todas las entradas tienen el bit de validez marcado como i.
Qu entiende por paginacin bajo demanda (Demand Paging)?
Examen marzo 2004:
En un sistema de paginacin por demanda, si el hardware lo permite qu utilidad tiene el bit
sucio (dirty bit)?
A la porcin de memoria que est cargada en memoria principal de un proceso se

le denomina memoria residente2 (resident memory).
El acceso a memoria residente por parte de un proceso es tomado como un
acceso normal, pero el acceso a memoria no residente genera un fallo de pgina
(page fault).
El fallo de pgina genera un trap a nivel de sistema operativo que activa una
rutina de atencin para cargar la pgina en memoria principal.
El acceso a la memoria genera la siguiente secuencia de pasos:
1. Verificar que el proceso referencia una pgina correcta dentro del
espacio de direccionamiento. El proceso puede generar cualquier
direccin de memoria dentro de su espacio de direccionamiento, pero
no todas son vlidas ya que existen huecos en el espacio virtual que
pueden no haber sido asignados. Por ejemplo, un acceso fuera de un
arreglo puede generar un acceso a una pgina virtual que no fue
asignada al proceso. Esto genera un page fault o segmentation
fault y el proceso es finalizado.
2. Si el acceso fue correcto dentro del espacio virtual, se busca en la
tabla de pgina el frame correspondiente, verificando que el estado del
bit de validez.
2
Examen julio 2007: Qu es la memoria residente de un proceso?
99
FINGUDELAR
3. Si el bit de validez est encendido, se accede al frame correspondiente
realizando la traduccin dando por finalizado el acceso.
4. Si el bit de validez est apagado se genera el trap de fallo de pgina.
Examen abril 2003:
Cundo ocurre un fallo de pagina?. Explique las acciones del sistema operativo frente a un fallo.
Respuesta:
En el contexto de un sistema de paginacin por demanda, sucede cuando un proceso intenta
referenciar una pgina que no se incorpor a memoria. El hardware de paginacin, al traducir la
direccin, observa que la entrada correspondiente de la tabla tiene indicada esa pgina como
invlida, y genera una trap para el sistema operativo (la instruccin que hizo la referencia no se
completa).
Entonces el sistema
1. determina si la referencia memoria fue vlida o invlida (por ejemplo por indizar mal
un vector)
2. si fue una referencia vlida, en vez de abortar el proceso, localizar en disco la pgina
buscada
3. buscar un marco libre
a. si lo hay, lo selecciona
b. sino, aplica algoritmo de reemplazo para seleccionar un pgina a quitar, la
guarda en disco y refleja el cambio en tabla de pginas.
4. mover la pgina deseada al nuevo marco libre, reflejar cambio en
tabla de pginas
5. reejecutar la instruccin que provoc el fallo (el proceso no necesariamente cambio
de estado).
9.2.1 Rutinadeatencindelfallodepgina:
1. Se busca un frame libre en memoria principal, sino hay ejecuta un
algoritmo de reemplazo (se ver ms adelante).
2. Se realiza un operacin de lectura sobre el disco que guarda la pgina.
La pgina se carga en el frame obtenido en el paso anterior.
3. Se actualiza la tabla de pgina e informacin en las estructuras del
PCB del proceso para marcar que la pgina est disponible en
memoria principal.
4. Finalmente, se retoma el control a la instruccin que fue interrumpida
debido al fallo de pgina.
Enumere los pasos que sigue la rutina de fallo de pgina (page-fault)
Respuesta:
1. Encontrar en que lugar del disco esta la pgina que fall.
2. Encontrar un marco (pgina) libre en memoria principal:
A. Si existe un marco libre, entonces pasar al punto 3.
B. Si no existe un marco libre, entonces usar el algoritmo de remplazo de pgina del sistema
para seleccionar a la vctima.
C. Escribir en disco la pgina victima y actualizar la tabla de paginacin.
3. Leer la pgina de fallo desde el disco y ponerla en el marco obtenido en el punto 2. Actualizar
la tabla de paginacin.
4. Volver al proceso del usuario.
Examen marzo 2004:
Explique qu desventaja particular tienen los hilos implementados a nivel de usuario (sin soporte
del ncleo) en un sistema de memoria virtual con paginacin por demanda.
Examen febrero 2005.
Describa brevemente los pasos para el manejo de un fallo de pginas (una vez que se determin
que este ocurri) en un modelo de paginacin por demanda.
Respuesta:
Como ya se determin que ocurri el fallo de pgina, sabemos que no es un acceso invlido, ni
que la pgina est en memoria.
100
FINGUDELAR
a. Encontrar un marco libre. Si no se encuentra, utilizar un algoritmo de reemplazo para
seleccionar un marco, y moverlo a disco. (Esto incluye dejar el proceso que provoc el fallo en
estado bloqueado, mientras espera en la cola del dispositivo primero, y luego la transferencia).
b. Planificar una operacin para leer de disco la pgina hacia el marco elegido.
Misma aclaracin que en (a). Durante ambas transferencias ejecutan otros procesos que estaban
en la cola de listos
c. Cuando finalice la transferencia (por una interrupcin de fin de E/S), el sistema modificar la
tabla de pginas para indicar que ahora se encuentra en memoria, y cambiar el estado del
proceso que provoc el fallo a listo.
d. Cuando la CPU se asigne al proceso, se reiniciar en la instruccin que provoc el fallo.
Si este mtodo es aplicado en forma rigurosa se tendr un sistema puro de

paginacin por demanda (pure demand paging). El hardware necesario para la
implementacin es:
Tabla de pgina.
Espacio denominado swap del disco
9.3 Estudiodelaperformance
La tcnica de paginacin por demanda puede generar un alto impacto en el
rendimiento del sistema. Una medida utilizada para ver el efecto que produce es el
tiempo de acceso efectivo (effective access time). Se define mediante la frmula:
EAT = (1 - p) * ma + p * TRPF
donde TRPF es el tiempo de resolucin del page fault, p la probabilidad de que
ocurra un fallo de pgina y ma el tiempo de acceso a memoria.
Examen julio 2007:
Describa la frmula del Tiempo Efectivo de Acceso (Effective Access Time EAT) a memoria.
Qu nos brinda est frmula?
El tiempo de resolucin involucra, entre otras cosas, salvar el estado del proceso,
solicitud de lectura de la pgina de disco, ejecucin del planificador, atencin de
rutina de completitud de la operacin de E/S de parte del disco, correcin de tablas
necesarias, espera de asignacin del procesador y restaurar el estado al proceso.
Ej.: tomando como TRPF = 25 milisegundos y ma = 100 milisegundos,
tenemos que:
EAT = (1 - p ) * (100) * p * (2500000)
EAT = 100 + 24999900 * p
El tiempo de acceso efectivo es directamente proporcional a la probabilidad del
fallo de pgina.
Si queremos un 10% de degradacin del sistema:
> 100 + 25000000 * p
10 > 25000000 * p
p < 0,0000004
Esto da 1 acceso fallido cada 2500000 accesos.
101
FINGUDELAR
9.4 Algoritmosdereemplazo
En un sistema cargado, el uso de la memoria principal por parte de los procesos
puede agotar el recurso.
La necesidad de traer a memoria principal una pgina en una memoria principal
llena, genera la bsqueda de un frame a reemplazar. El mal algoritmo de reemplazo
genera un impacto significativo de degradacin del sistema.
El frame reemplazado (vctima) ser puesto en memoria swap, y ante un eventual
uso en el futuro volver a memoria principal (a travs de un page fault).
Examen mazo 2008:
Para qu son tiles los algoritmos de reemplazo de marcos (frames)?
La rutina de page fault debe incorporar el reemplazo:
Elegir la vctima mediante un algoritmo de reemplazo

Escribir la vctima en memoria swap y ajustar la tabla de pgina
correspondiente (swap out).
Cargar la pgina en el frame correspondiente.
Ajustar la tabla de pgina del proceso.
9.4.1 FIFO(FirstInFirstOut)
El algoritmo reemplaza la pgina que hace ms tiempo que est en memoria
principal.
Es un algoritmo fcil de implementar ya que requiere nicamente de una
estructura tipo cola.
Sin embargo este algoritmo sufre de la anomala de Belady:
102
FINGUDELAR
"Los fallos de pgina se incrementan al asignar ms frames"
Examen julio 2004:
Un sistema que implementa memoria virtual con paginacin utiliza el algoritmo FIFO para la
sustitucin de pginas. Un proceso genera la siguiente secuencia de referencias a pginas de
memoria:
12345341678978965
a. Determinar cuantos fallos de pgina se producen segn se disponga de 4 5 marcos de
pgina para el proceso. Justifique brevemente.
b. Aumentando a 6 o ms el nmero de marcos. Se mejorara la tasa de fallos de pgina?
Justifique brevemente.
Respuesta:
a. Con 4 marcos. 11 fallos. Se los representa con *
1*
2* 3* 4* 5* 5 5 1* 6* 7* 8* 9* 9 9 9 9 5*
X
1 2 3 4 4 4 5 1 6 7 8 8 8 8 8 9
X
X 1 2 3 3 3 4 5 1 6 7 7 7 7 7 8
X
X X 1 2 2 2 3 4 5 1 6 6 6 6 6 7
Con 5 marcos. 9 fallos. Se los representa con *
1*
2* 3* 4* 5* 5 5 5 6* 7* 8* 9* 9 9 9 9 5
X
1 2 3 4 4 4 5 5 6 7 8 8 8 8 8 9
XX 1 2 3 3 3 4 4 5 6 7 7 7 7 7 8
XX X 1 2 2 2 2 3 4 5 6 6 6 6 6 7
xx x x 1 1 1 1 2 3 4 5 5 5 5 5 5
b. En esta secuencia hay 9 pginas distintas, luego como mnimo se tiene que producir 9 fallos de
pgina. Con 5 marcos se producen 9, luego si mantenemos el nmero de marcos no se va a
reducir el nmero de fallos de pgina.
Examen marzo 2004:
Dado el algoritmo de reemplazo de pginas FIFO, diga qu sucede al incrementarse el nmero de
marcos asignados.
9.4.1.1 AnomaladeBeladyparaFIFO
Para la siguiente secuencia de acceso a pgina:
1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
En 3 frames se tienen 9 fallos de pgina.
En 4 frames se tienen 10 fallos de pgina.
103
FINGUDELAR
9.4.2 Segundachance(Secondchance)
En el algoritmo FIFO una pgina es reemplazada sin tener en cuenta las
referencias que tuvo.
Una alternativa es que cada pgina tenga una marca si fue referenciada (bit de
referencia) luego de ser cargada en memoria.
En el momento de reemplazo, se verifica el bit de referencias. Si est prendido, a
la pgina se le da una segunda chance y es puesta al final de la cola. Luego se
contina con la siguiente pgina que est al principio de la cola. Si est apagado, es
seleccionada para ser reemplazada.
Es un algoritmo un poco ineficiente, pero mejora la reduccin de cantidad de fallos
de pgina con respecto a FIFO.
En un sistema con memoria virtual, describa el algoritmo de reemplazo de segunda chance
(Second-chance algorithm).
Respuesta:
El algoritmo de segunda chance conserva una cola circular con los frames segn el orden de
carga. Cada vez que se carga un frame se lo pone al final de la cola y se marca el bit de
referencia en 0. A su vez, cada vez que el frame es accedido se marca el bit de referencia en 1.
Posteriormente, al ejecutarse el algoritmo de reemplazo, se hace una recorrida desde el
comienzo de la cola buscando el frame a reemplazar. Para cada frame se tienen dos
posibilidades: 1) Si el frame tiene el bit de referencia en 1, entonces se le da una segunda
oportunidad movindolo hacia el final de la cola y marcando su bit de referencia en 0. 2) Si el
frame tiene el bit de referencia en 0, es el elegido para ser reemplazado y el algoritmo finaliza.
9.4.3 ptimo(OptimalPageReplacement)
Un algoritmo que no sufre de la anomala de Belady es el algoritmo ptimo.
En este se reemplaza la pgina que no va a ser usada por el mayor perodo de
tiempo.
Este algoritmo es el que genera menos fallos de pgina de todos los posibles, pero
es imposible de implementar ya que es necesario saber a qu pginas acceder un
proceso.
Examen mazo 2008:
Describa el algoritmo de reemplazo ptimo (Optimal Page Replacement). Muestre sus beneficios
y sus limitaciones.
9.4.4 Norecientementeusada(NotRecentlyUsedNRU)
A los frames se le asocia dos bits: uno de referencia y otro de modificacin.
El bit de referencia se actualiza cada vez que se realiza una operacin sobre el
mismo (lectura o escritura), mientras que el bit de modificacin se prende cada vez
que escribe.
Cada tanto se genera una interrupcin de reloj que limpia el bit de referencia.
Al ocurrir un fallo de pgina los frames se dividen en 4 clases:
Clase
Clase
Clase
Clase
0: no referenciada, no modificada.
1: no referenciada, modificada.
2: referenciada, no modificada.
3: referenciada, modificada.
Se reemplaza un frame al azar de la clase ms baja que no est vaca.

Es un algoritmo sencillo de implementar y para ser eficiente deber tener soporte
de hardware ya que en cada referencia a memoria se deben actualizar los bits (de
referencia y de modificacin).
104
FINGUDELAR
9.4.5 Recientementemenosusada(LeastRecentlyUsedLRU)
Uno de los algoritmos que ms se aproxima al ptimo es el LRU.
A cada pgina se le asocia el tiempo en que fue referenciada. La pgina elegida
por el algoritmo de reemplazo ser la que fue accedida hace ms tiempo.
Es un algoritmo que es ptimo en cuanto al uso hacia atrs de las pginas y es
bastante utilizado por los sistemas operativos actuales.
Para la implementacin de este algoritmo es necesario soporte a nivel de
hardware.
Examen abril 2003:
Describa brevemente los siguientes algoritmos de reemplazo de paginas en el contexto de
memoria virtual paginada: FIFO, LRU, Segunda-Oportunidad y el algoritmo optimo. Indique
justificando adecuadamente en cada caso, si su uso es o no frecuente.
Respuesta:
FIFO
Asocia (en forma explcita o no) a cada pgina el instante en que se trajo a
memoria, eligiendo la ms antigua cuando hay que hacer un reemplazo. Es fcil de
implementar, pero su rendimiento no siempre es bueno. Un ejemplo es cuando se
reemplaza una pgina trada hace mucho tiempo, pero de uso intensivo. Tambin
presenta la anomala de Belady: con ciertos patrones de referencias, la tasa de
fallos de pgina puede aumentar al incrementarse el nmero de marcos asignados,
en contra de lo esperado.
OPTIMO
Busca reemplazar la pgina que no se usar durante el mayor perodo de tiempo,
garantizando la menor tasa de fallas de pginas posible, para un nmero fijo de
marcos. Es difcil de implementar, pues se requiere un conocimiento futuro de
las referencias a pginas. Se utiliza (ms precisamente sus resultados
esperados) para estudios comparativos con otros algoritmos no ptimos.
LRU
Reemplaza la pgina que no se ha usado durante el mayor periodo de tiempo,
basndose en el pasado reciente para suponer cul ser la pgina que no se
usuar en el futuro cercano. Es utilizado con frecuencia, y existen 2
implementaciones:
a. Con un contador, que es incrementado con cada referencia a alguna
pgina de memoria. cada vez que se referencia una pgina en particular,
el contador se copia a un registro asociado a la misma.
Debe tratarse el desbordamiento del contador.
Este esquema requiere una bsqueda en toda la tabla de pginas, a
fin de encontrar la que tiene el menor valor.
Observar que requiere apoyo de hardware.
b. Mantener una lista doblemente encadenada, extrayendo la pgina ms
recientemente utilizada.
LRU no presenta la anomala de Belady. (Pertenece a una clase llamada algoritmos
de pila: las pginas residentes en memoria para un sistema con N marcos son
siempre un subconjunto de las que habra con N + 1)
SEGUNDA OPORTUNIDAD
Es una variante del algoritmo FIFO, que evita que una pgina muy utilizada sea
eliminada por llevar mucho tiempo en memoria. Se mantiene un bit por pgina, que
es seteado en 1 con cada referencia, y actualizado por el sistema a intervalos
regulares. Se recorre la lista de pginas examinando estos bits de referencia.
Si el bit de una pgina est en 1 se le da una segunda oportunidad, ponindolo
en 0 y envindolo al final de la lista (como si recin hubiera llegado a
memoria). La bsqueda termina cuando se encuentra el primer bit en 0, en cuyo
caso se reemplaza la pgina.
a) Describa los algoritmos de reemplazo:
i. FIFO
ii. ptimo
iii. LRU
b) b) Para cada uno de ellos muestre la secuencia de reemplazo para los siguientes pedidos de
pgina:
7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1
105
FINGUDELAR
Asumiendo que el tamao de la memoria principal es de 3 pginas.
Respuesta:
a) FIFO - Se reemplaza la pgina que hace ms tiempo esta cargada en memoria principal.
ptimo - Reemplazar la pgina que no ser usada por el mayor perodo de tiempo. Para este
algoritmo es necesario tener informacin de los pedidos de pgina futuros.
LRU - Reemplazar la pgina que hace ms tiempo que no es accedida. (Least recently used)
b)
En todos los casos las primeras tres pginas entran a la memoria sin reemplazos. Los reemplazos
se muestran en notacin (pgina original, reemplazo).
FIFO: (7,2) (0,3) (1,0) (2,4) (3,2) (0,3) (4,0) (2,1) (3,2) (0,7) (1,0) (2,1)
ptimo: (7,2) (1,3) (0,4) (4,0) (3,1) (2,7)
LRU: (7,2) (1,3) (2,4) (3,2) (0,3) (4,0) (0,1) (3,0) (2,7)
Describa brevemente los algoritmos de reemplazo de pgina siguientes: FIFO, ptimo y LRU.
Respuesta:
FIFO (First In First Out): Para reemplazar una pgina, se elige la que estuvo en memoria ms
tiempo. Es fcil de programar, pero no siempre es bueno pues no toma en cuenta el uso que se le
est dando a la pgina seleccionada. Podra haber una pgina que se carg hace mucho y tiene
un uso frecuente, y otra cargada hace menos tiempo pero que se us slo esa vez. FIFO elegir la
primera y no la segunda.
ptimo: Tiene la menor tasa de fallos de pgina pues reemplaza la pgina que no se utilizar
durante el mayor perodo de tiempo. Es dficil de implementar sin un conocimiento futuro de la
serie de referencias.
LRU (Least Recently Used): Remplaza la pgina que no se ha utlizado en ms tiempo, suponiendo
el pasado reciente como una aproximacin de las prximas referencias. Requiere ayuda de
hardware.
Examen julio 2007:
Describa el algoritmo de reemplazo LRU.
Examen agosto 1995:
Para un sistema de memoria virtual, comentar aquellas tcnicas de reemplazo que considere
mejor y justificar la eleccin.
9.5 Estrategiadeasignacindeframes
La multiprogramacin permite la ejecucin concurrente de varios procesos.
Los procesos realizarn sus pedidos de memoria y el sistema operativo tratar de
resolver las solicitudes de forma de lograr un uso adecuado del recurso.
Si el sistema operativo no implementa una estrategia de asignacin de memoria,
un proceso que requiera mucha memoria puede dejar al sistema colapsado.
Es por eso necesario definir una estrategia de asignacin adecuada para todos los
procesos que comparten los recursos.
Una estrategia podra dividir la cantidad de frames segn la cantidad de procesos
que existan en el sistema. Esta estrategia no es muy eficiente ya que los procesos no
tienen la misma necesidad de este recurso.
Una opcin es ponderar la cantidad de frames asignados segn el uso de memoria
que tengan.
Sea si la cantidad de memoria virtual del proceso pi
La memoria virtual de todo el sistema es:
S = S si
Si la cantidad de frames del sistema es m, definimos una estrategia de asignacin
ponderada donde al proceso pi se le asignan fi frames: fi = (si / S) * m
106
FINGUDELAR
En la ejecucin de un algoritmo de reemplazo existen dos opciones de pginas a
reemplazar:
Reemplazo Global (Global Replacement): un proceso puede

reemplazar un frame utilizado por otro.
Asignacin Local (Local Remplacement): Un proceso reemplaza
nicamente los frames que tienen asignado.
A diferencia del global, en el reemplazo local la cantidad de frames asignado a un

proceso no vara.
Un problema de la estrategia global es que los fallos de pgina de un proceso
afectan la eficiencia de ejecucin de otro.
La estrategia local independiza los fallos de pgina por proceso, pero ocupa
frames de memoria que quizs sean poco usados y no son reemplazados. Es por eso
que el reemplazo global es ms utilizado.
Examen marzo 2007:
Compare la asignacin de frames global vs. local
9.6 Hiperpaginacin
La estrategia de asignacin de frames limita a los procesos en la cantidad de
frames que pueden tener en memoria.
Si un proceso tiene un uso activo de un mayor nmero de frames que los
asignados por el sistema, el proceso tendr un alto porcentaje de page fault.
El proceso estar continuamente realizando page fault debido a que sus frames
estn activos.
Si un proceso pasa ms tiempo paginando que ejecutando, se dice que el proceso
sufre de hiperpaginacin (Trashing).
La hiperpaginacin degrada significativamente la performance.
9.6.1 Causasdelahiperpaginacin
La multiprogramacin genera un mayor uso del procesador, pero puede llevar al
sistema a un estado de degradacin por la hiperpaginacin.

Explique brevemente porqu se produce hiperpaginacin (no la defina, ejemplarice).
Respuesta:
Se produce cuando un proceso tiene ms pginas activas que marcos asignados, lo que hace que
pase ms tiempo paginando que ejecutando. Nota: No es vlido definirlo como exceso de
paginacin. Se pide la causa, no el efecto que produce.
107
FINGUDELAR
9.6.2 ElmodeloWorkingSet
Es necesario atacar el potencial problema de la hiperpaginacin.
Denning (1970) propuso el modelo del Working-Set (conjunto de trabajo), que se
basa en el principio de localidad: "A medida que un proceso ejecuta va utilizando
un conjunto de pginas llamadas activas". El conjunto de pginas activas va
cambiando a medida que ejecuta el proceso.
Se define un conjunto de pginas (A), que son las ms recientemente
referenciadas. Este conjunto de pginas se denomina working-set.
Se analiza un sistema de paginacin por demanda y se observa que, con cierta carga de trabajo,
de la CPU se emplea un 15% y el disco de intercambio (swap) est ocupado un 92% del tiempo.
Qu accin tomara para aumentar el rendimiento del sistema para esta misma carga de
trabajo?
Respuesta:
La situacin descripta se ajusta a la de sobrecarga del sistema de memoria virtual o Thrashing,
resultado de que la suma de los Working Set de los procesos activos es sensiblemente mayor
que la memoria real. La nica accin posible sin variar la carga de trabajo es agregar ms
memoria real.
Describa el modelo de Working-set. Mencione los conceptos en que se basa, las propiedades que
cumple y el fin que persigue . Respuesta: El modelo de working-set es una estrategia que permite
defenderse ante el problema de hiperpaginacin (trashing). Se basa en el principio de localidad:
Un proceso al ejecutar utiliza un conjunto limitado de pginas a la vez. A este conjunto de
pginas se les denomina pginas activas. Al tamao del conjunto se le denomina ventana.
El modelo utiliza un parmetro (A) que define el tamao de la ventana del working-set. Si una
pgina est siendo usada en el momento, entonces pertenece al working-set. Cuando una pgina
hace un tiempo, mayor que la ventana definida, no es accedida deja de pertenecer del workingset. La efectividad del modelo se logra con una buena seleccin del parmetro A. La propiedad
ms importante del working-set es el tamao de la ventana para cada proceso. La propiedad que
se debe cumplir es que la suma del tamao de todas las ventanas del sistema debe ser a lo sumo
igual a la cantidad de pginas disponibles en el sistema.
Examen mazo 2008:
Para qu es til el modelo del Working-Set? Describa el modelo del Working-Set
Si el conjunto A es muy pequeo, no se lograr representar bien la localidad, y, si

es muy grande, se tendr una localidad muy grande.
Sea WSSi la cantidad de frames que estn en el working-set del proceso i. Se
define:
D = S WSS
D es la cantidad total de frames demandada por los procesos del sistema. Si D es

mayor que la cantidad de frames disponibles en el sistema, se tendr
hiperpaginacin.
Mantener el working-set mediante las ltimas referencias que realiza un proceso
es bastante costoso, ya que tendremos inserciones y bajas continuamente, cada vez
que haya una referencia tenemos que ver si ya est en el working-set.
Es comn adoptar la estrategia de elegir el working-set segn las pginas
accedidas en un tiempo t fijo (ej.: 100 milisegundos). El tiempo es de ejecucin real
del proceso.
Se utiliza un timer que interrumpe con un t fijo. Un bit que marca si fue usado el
frame desde la interrupcin del timer anterior. Adems, un campo que marca el
tiempo de la ltima vez que fue referenciada.
108
FINGUDELAR
Cuando ocurre una interrupcin del timer, se verifican todas las pginas del
sistema para armar los working-set de los procesos.
En la interrupcin se verifica el bit de uso
Si est prendido, entonces el frame pertenece al working-set del proceso, se
actualiza el campo de tiempo de uso con la hora actual del sistema y se apaga el bit
para la verificacin en la prxima interrupcin.
Si est apagado, se verifica el campo de tiempo de uso con la hora actual del
sistema. Si este tiempo es mayor que el tdel proceso, entonces el frame no
pertenece al working-setdel proceso.
Examen marzo 2005
: Qu estrategia evita la hiperpaginacin multiprogramacin lo ms alto posible?
En un sistema que cuenta con el esquema de memoria virtual con paginacin, cmo se asegura
que no se acceda a la memoria de otro proceso?
respuesta no encontrada en las transparencias. Respuesta sacada del Operating System Concepts 7th
Edition:
We check an internal table (usually kept with the process control block) for this process to
determine whether the reference was a valid or an invalid memory access.
109
FINGUDELAR
10 SistemadeArchivos
10.1 Archivos
Los dispositivos masivos (discos duros, cintas, etc.) permiten guardar informacin
de forma no voltil.
El sistema operativo se abstrae de las propiedades fsicas de los dispositivos para
definir una unidad lgica de almacenamiento: el archivo.
Los archivos son "mapeados" por el sistema a los distintos dipositivos.
Un archivo es una agrupacin de informacin que se guarda en algn dispositivo
no voltil.
Desde la perspectiva del usuario, es la unidad mnima de almacenamiento que el
sistema le provee.
Los archivos poseen atributos:
Nombre: un nombre simblico que permite identificar el archivo a los

usuarios. Pueden existir ms de un archivo con el mismo nombre en un
sistema de archivos jerrquico (directorios).
Identificador: smbolo que lo identifica de forma nica a nivel global
del sistema de archivos. Usualmente es un nmero.
Tipo: programa ejecutable, archivo de datos, etc.
Ubicacin: puntero al dispositivo y lugar donde reside el archivo.
Tamao: el tamao del proceso (en bytes, palabras o bloques)
Proteccin: informacin de control para el acceso al archivo. Ej.:
usuarios que pueden acceder, en qu forma, etc.
Informacin de conteo: fecha de creacin, ltimo acceso, etc.

Qu es un archivo?, Y un sistema de archivos?
Enumere al menos cinco atributos que deban conservarse para describir un archivo.
10.2 Operacionessobrelosarchivos
El sistema operativo brinda servicios para la manipulacin de archivos:
Crear y abrir: provee la creacin de un archivo en el sistema de

archivos. Se debe proveer un nombre del nuevo archivo. Adems, se
provee la apertura de un archivo ya existente para acceder o modificar
la informacin.
Escribir: poder escribir informacin en un archivo previamente
abierto.
Leer: poder leer informacin en un archivo previamente abierto.
Reposicionar dentro de un archivo: lograr acceder a cualquier
parte del archivo.
Eliminar: destruir el archivo a nivel del sistema de archivo.
Truncar: eliminar la informacin que est dentro del archivo, pero sin
eliminar el archivo.
Por lo general, los sistemas tienen una tabla de archivos abierto por proceso.
Estos archivos se abren a travs de un llamado al sistema y, de esa forma, se puede
110
FINGUDELAR
operar con ellos (leer, escribir, etc.). Finalmente, el archivo es cerrado antes que
finalice la ejecucin del proceso.
Tener un archivo abierto para el sistema implica mantener una estructura que
tenga por lo menos:
puntero de archivo (file pointer) para operaciones de lectura y escritura, contador
de archivos abiertos, ubicacin del archivo en el dispositivo, derechos de acceso.
Algunos sistemas proveen sistema de acceso nico a un archivo (lock) por parte
de los procesos.
A su vez, varios sistemas implementan el mapeo de archivos al espacio de usuario
del proceso. De esta forma, no es necesario realizar read y write para operar sobre el
archivo, sino accederlo directamente. Esto trae el beneficio de no hacer el llamado a
sistema para operar sobre el archivo.
10.3 Mtodosdeacceso
Examen marzo 2006:
Describa dos mtodos de acceso a un archivo.
Examen marzo 2007:
Describa dos mtodos de acceso a un archivo.
Examen julio 2007:
Describa dos mtodos de acceso a un archivo del sistema.
Existen varios mtodos de acceso a los archivos:

Secuencial: la informacin es accedida en orden, registro a registro.
El registro depende del tipo de archivo (texto plano sera byte). Las
operaciones de lectura accedern a la informacin en forma secuencial
incrementando el puntero de archivo file pointer. El acceso secuencial
se basa en el model de cinta (tape), en donde los archivos son
accedidos de a uno por vez y en forma secuencial.
Directo: la informacin es accedida en cualquier orden. No existen
restricciones sobre el orden de escritura y lectura en un archivo. Se
basa en el modelo de disco de un archivo, que est estructurado en
bloques.
10.4 Directorios
El sistema de archivos es estructura por lo general en directorios que contienen
archivos.
Los directorios permiten a los usuarios del sistema tener una organizacin lgica
del sistema de archivo.
111
FINGUDELAR
10.4.1 Operacionessobredirectorios
Bsqueda: es necesario poder buscar un archivo en un directorio.

Crear un archivo: archivos nuevos deben ser creados e incorporados al
directorio.
Eliminar: borrar un archivo del directorio.
Listar: visualizar los archivos que estn en un directorio.
Renombrar un archivo: cambiar el nombre de un archivo dentro del
directorio.
Permitir la navegacin: lograr acceder a todos los directorios de
sistema de archivos.
10.4.2 Estructuradedirectorios
10.4.2.1 Nivelnico
El esquema ms sencillo es tener un nico nivel de directorios en el sistema de
archivos.
A medida que el sistema crece trae limitaciones. Por ejemplo, no permite archivos
con el mismo nombre en un mismo directorio.
10.4.2.2 rbol
Es ideal permitir varios niveles de directorios. Esto se logra permitiendo tener
archivos de tipo directorio dentro de los directorios.
112
FINGUDELAR
Se genera una estructura jerrquica de directorios en forma de rbol.

Se denomina ruta (path) absoluta de un archivo, al camino desde la raz hasta el
archivo.
10.4.3 Grafo
Para potenciar la estructura anterior de rbol sera deseable tener caminos de
acceso directo a otros directorios.
Estos caminos se logran a travs de archivos de tipo enlace simblicos (soft links).
A su vez, se permite que un archivo est en ms de un directorio (hard link).
10.4.4 Montajededirectorios
Dada la estructura de grafo, los sistemas de archivos se pueden solapar en un
nico sistema de archivos.
113
FINGUDELAR
10.5 Seguridadenarchivos
Debido a que el sistema es multiusuario es necesario proteger la informacin de
cada usuario.
En muchos casos los usuarios se agrupan segn el uso que tienen sobre un
sistema.
Se definen permisos sobre los archivos tanto a nivel de usuario como de grupo.
Los permisos m comunes son de escritura, lectura, ejecucin, elminacin, listado.
10.6 Implementacin
El diseo de un sistema de archivos enfrenta dos
problemas:
Cmo se ver para el usuario. Implica definir los
atributos, las operaciones vlidas sobre los archivos y
la estructura de directorios para la organizacin de los
archivos.
La creacin de algoritmos y estructuras de datos
para hacer corresponder el sistema de archivos lgico
con los dispositivos fsicos de datos.
El sistema de archivos est compuesto de varias
capas. Cada una de las cuales utiliza la funcionalidad
de la capa inferior.
Los dispositivos fsicos (discos) contienen la siguiente estructura: Bloque de
control para el boot (boot control block): es necesario para lograr inciar el sistema
operativo.
Bloque de control de particin (partition control block): contiene la informacin de
las particiones que existen en el disco, bloques utilizados y libres, cantidad de
archivos, etc.
Estructura de directorios: para la organizacin de los archivos.
Bloque de control del archivo (File Control Block): los bloques de control de los
archivos que estn en el sistema de archivos.
El sistema operativo en memoria mantiene las siguientes estructuras:
La tabla de particin con los sistemas de archivos cargados.
114
FINGUDELAR
La estructura de directorio de los accedidos ltimamente.

Tabla de descriptores de archivos abiertos a nivel global del sistema.
Tabla de descriptores de archivos abiertos por proceso del sistema.
Por cada archivo en el sistema se tendr un bloque de control (File Control Block).
El bloque de control contiene varios atributos de conteo, permisos y dnde estn
los datos del mismo:
Permisos del archivo.
Fechas (creacin, acceso, modificacin).
Propietario, grupo propietario, lista de acceso (access control list ACL).
Tamao del archivo.
Bloques de datos del archivo.
Defina brevemente que es la ACL (Access Control List).
Respuesta:
Una lista de control de acceso (ACL) es una lista de entradas asociadas a un archivo o carpeta
que especifica qu usuarios y grupos tienen acceso a esa carpeta o archivo. Cada entrada de una
ACL asigna a un usuario o grupo uno o varios tipos de niveles de acceso al objeto en cuestin.
Estos pueden ser los bsicos de lectura, escritura, ejecucin, o tambin cambio de permisos,
borrar y otros tipos de permisos que pueda implementar el sistema operativo Mediante las ACLs
es posible implementar un mecanismo de acceso discrecional que especifica permisos en una
manera mas selectiva que lo que permiten, por ejemplo, los mecanismos tradicionales de Unix.
10.6.1 Sistemadearchivosvirtual
Es comn que un sistema operativo acceda a ms de una implementacin de
sistema de archivos (ufs, ext2, ext3, jfs, jfs2, ntfs, etc.).
Se utilizan tcnicas de orientacin a objetos para lograr mantener una estructura
independiente del sistema de archivos que se utilice.
Se genera una estructura en tres capas:
Interfaz del sistema de archivo (open, read, etc.).

Sistema de archivos virtual (Virtual File Server).
Implementacin especfica del sistema de archivos.
El sistema de archivos virtual provee de

dos funcionalidades importantes:
Propone una interfaz genrica de sistema
de archivo que es independiente del tipo de
sistema de archivo. De esta forma, se logra un
acceso transparente al sistema de archivos.
Propone un bloque de control de archivo
virtual que puede representar tanto archivos
locales como remotos.
Examen marzo 2004:
Qu inconveniente tienen los sistemas que
apoyan distintos tipos de archivos en forma
nativa?
10.6.2 Estructuradelosdirectorios
Los directorios contienen la informacin de los archivos que pertenecen a l. Para
organizar la informacin existen varias opciones:
115
FINGUDELAR
Lista encadenada: los nombres de los archivos y un puntero al

bloque de control son dispuestos en una lista encadenada. En la
bsqueda, insercin y borrado es necesario un acceso lineal. Es usual
el uso de caches en memoria principal para acelerar el acceso.
Tabla de hash abierto: con el nombre del archivo se genera la clave
utilizada.
10.6.3 Mtodosdeasignacin
Para la disposicin de los datos de los archivos en disco se tienen, en general, tres
mtodos:
Asignacin contigua (Contiguos Allocation): los datos se
disponene en forma contigua. Para mantener la informacin es
necesario saber en qu bloque comienza y la cantidad de bloques que
tiene el archivo.
Asignacin en forma de lista (Linked Allocation): los bloques de
datos forman una lista encadenada. Es necesario una referencia al
primer y ltimo bloque de datos en el bloque de control de archivo.
Asignacin indexada (Indexed Allocation): Se mantiene una tabla
en donde cada entrada referencia a un bloque de datos.
10.6.3.1 Asignacincontigua(Contiguos
Allocation)
Sufre de fragmentacin externa.
Es necesario reubicar constantemente los
archivos si crecen en tamao.
Se utilizan tcnicas de asignacin de
tamaos ms grandes para prever el
crecimiento futuro de los archivos.
10.6.3.2 Asignacinenformadelista(Linked
Allocation)
Soluciona el problema de la fragementacin. El
acceso a los bloques es lineal. Los punteros ocupan
espacio en los bloques. La prdida de una
referencia genera la prdida de gran parte de
informacin del archivo.
10.6.3.2.1
Ej.FAT
Al comienzo de cada particin existe una tabla de asignacin de archivos (File

Allocation Table), que contiene la lista de bloques.
116
FINGUDELAR
La tabla tiene una entrada por cada bloque de disco, y es indexada por el nmero
de bloque.
10.6.3.3 Asignacinindexada(IndexedAllocation)
Los bloques son accedidos
directamente a travs del bloque de
indexacin (index block).
El bloque de indexacin ocupa lugar.
Se trata de que sea lo ms pequeo
posible, pero limita la cantidad de
bloques.
Una posible opcin es indexacin en
varios niveles. Algunos ndices hacen
referencia a bloques directos y otros a
bloques de indexacin.
En UNIX los bloques de control de
archivos tienen bloques de indexacin directa, de
uno, dos y hasta tres niveles de indexacin.
Esto permite representar archivos muy grandes.
117
FINGUDELAR
10.6.4 Administracindelespaciolibre
En el sistema de archivos es necesario mantener qu bloques estn ocupados y
cules estn libres.
Opciones posibles para la administracin de los bloques:
Vector de bits (Bit Vector, Bit Map): se dispone de un bit para cada
bloque de datos del sistema, que representa si est ocupado o libre.
Lista de bloques libres (Linked list): se mantiene una lista
encadenada de los bloques libres a travs de los bloques. Es necesario
una referencia al primer bloque.
Agrupacin (Grouping): es una variacin de la lista encadenada. En
cada bloque de la lista se contiene un gruo de bloques libres.
Conteo (Counting): se mantiene una lista en donde cada bloque
contiene informacin de cuantos bloques contiguos, a partir de l,
estn libres.
Examen marzo 2003:

En el contexto de la administracin del espacio libre de disco, comente que ventajas y
desventajas tienen los mapas de bits.
Respuesta:
Ventaja:
- resulta sencillo y eficiente encontrar n bloques libres
consecutivos en el disco, sobretodo en computadoras que
tienen
instrucciones de manipulacin de bits, que pueden usarse
eficazmente para este fin: por ejemplo una instruccin que dado un
registro devuelva la posicin del primer bit que tenga 1.
Desventaja:
- no son eficientes si para la mayora de los accesos no se conserva
todo el mapa en memoria real. Esto es razonable slo si el disco no
es de gran tamao.
Examen marzo 2004:
Presente brevemente tres alternativas para gestin de espacio libre en almacenamiento
secundario.
Describa 3 (tres) mtodos utilizados para tener cuenta que bloques de discos estn libres.
Respuesta:
Bit Vector: Se mantiene una arreglo de bits que indican si el bloque est siendo usado o no.
Lista encadenada: Se mantiene una lista entre los bloques libres. Existe una referencia al primer
bloque libre, el cual apunta al siguiente bloque libre, y asi hasta el ltimo que apunta a un bloque
invlido.
Lista encadenada agrupada: Igual que la anterior, pero se mantiene un conjunto de bloques libres
por bloque y el puntero al siguiente. Tambin es necesario la referencia al primer bloque libre.
Conteo: Se mantiene una lista con referencias a bloques contiguos libres. Cada entrada de la lista
apunta a un bloque libre y tiene un contador que indica cuntos bloques ms libres contiguos
existen.
Describa dos implementaciones posibles para saber el espacio libre en disco. Comprelos
mencionando sus ventajas y desventajas entre ellos.
Respuesta:
Mapa de bits: Es un arreglo de bits en donde cada entrada se mapea a un bloque del sistema de
archivo. Si el bloque est libre, el bit est indicado con un 1; si el bloque est asignado, el bits
indica 0 (puede ser al revs).
Lista encadenada: Los bloques libres estn en una lista encadenada. Existe un puntero al primer
bloque libre y cada bloque libre tiene una referencia al siguiente bloque.
Agrupamiento: Es igual que la lista encadenada, pero adems de tener el puntero al siguiente
(dado que sobra mucho espacio) se tiene un grupo de bloques libres.
118
FINGUDELAR
Contador: Al igual que los dos ltimos se tiene una lista encadenada de bloques libres. Pero como
a veces se tienen varios bloques libres que estn contiguos, se hace un agrupamiento en el
primer bloque libre de los contiguos agregando un contador que informa cuantos bloques libres
contiguos ah.
Describa dos tcnicas utilizadas para administrar el espacio libre (bloques libres) que hay en los
discos.
10.6.4.1 EjemploUNIX
Cada particin contiene un bloque descriptor del sistema de archivo llamado
super-block.
El super-block contiene:
Nombre del volumen
Cantidad mxima de archivos (inodos).
Cantidad de archivos utilizados y libres.
Cantidad de bloques de datos, cantidad de bloques utilizados y libres.
Referencia a comienzo de bloques de datos, de indexacin y de vector
de bits.
Informacin de conteo.
Etc.
La administracin del espacio libre se realiza a travs de mapa de bits (bit vector).
Se disponen varios bloques al comienzo de la particin.
El bloque de control de archivo es a la estructura inode. Los inodos son
identificados por un nmero, que es nico a nivel del sistema de archivos. Los inodos
poseen un tipo: archivo comn, directorio, enlace simblico, pipes, sockets. Utiliza un
mtodo de asignacin por indexacin.
Los directorios son representados como un archivo (inodo), en donde los datos son
entradas que tienen los nombres de los archivos y el nmero de inodo
correspondiente.
Si es un soft link, se tiene la ruta (path) del archivo al cual referencia. Los hard
links son tratados en forma natural, ya que la pertenencia de un archivo a un
directorio est en los datos del directorio y se referencia al nmero de inodo.
Qu es un i-nodo?
Examen marzo 2005:
Con la estructura Inodo utilizada en sistemas de archivos tipo UNIX Qu tipos de archivos se
pueden representar?
a. Archivo (de texto, ejecutables, datos, etc).
b. Directorios.
c. Archivos y directorios.
d. Archivos, directorios y enlaces dbiles (soft link).
e. Archivos, directorios, enlaces dbiles y fuertes (hard link).
Especifique la mejor opcin y justifique brevemente.
Respuesta:
d. Los enlaces fuertes son referencias a nivel de la estructura de nombrado
del sistema de archivos y no a nivel de Inodo.
Examen marzo 2005:
Mencione los atributos ms importantes de un inodo.
Respuesta:
a. Punteros a los bloques de datos directos e indirectos.
b. Tamao del Inodo.
119
FINGUDELAR
Examen julio 2005:
En el diseo de un sistema de archivos tipo Unix, ud. Pondra el nombre de archivo dentro del inodo? Justifique.
Respuesta:
No, en unix los inodos contienen un nmero nico que identifica el archivo. El nombre se maneja
en la estructura del sistema de archivos de manera de poder referenciar al mismo archivo con
distinto nombre.
120
FINGUDELAR
11 Estructuradedispositivosmasivosde
datos
11.1 Planificacindedisco
El sistema operativo es responsable de usar el hardware de forma eficiente. Desde
la perspectiva del disco, esto significa obtener un rpido acceso a los datos y
aprovechar al mximo el ancho de banda al disco.
Es por eso que el planificador de disco es uno de los ms importantes.
El acceso a disco tiene dos grandes componentes:
Tiempo de posicionamiento (seek time): es el tiempo que el brazo

del disco necesita para posicionar la cabeza en el cilindro que contiene
el sector.
Latencia de rotacin (rotational latency): es el tiempo que
demora rotar el plato al sector correcto.
El ancho de banda (bandwidth) de un disco es la cantidad de bytes transferidos,

dividido por tiempo total de la transferencia (desde el comienzo del pedido hasta la
ltima transferencia).
Para mejorar el acceso a los datos se debe minimizar el tiempo de bsqueda. De
esa forma, surgen varios mtodos de planificacin de disco:
FCFS.
SSTF.
SCAN.
C-SCAN.
LOOK.
C-LOOK.
11.1.1 FCFSFirstCome,FirstServed
En este caso la planificacin es realizar los pedidos como vayan llegando.
En un disco con 200 cilindros (numerados del 0 al 199), la cabeza posicionada en
el cilindro 53 y una lista de pedidos:
98, 183, 37, 122, 14, 124, 65, 67
Genera un movimiento de la cabeza sobre 640 cilindros.
121
FINGUDELAR
11.1.2 SSTFShortestSeekTimeFirst
Se elige como prximo pedido a realizar el que genere menos tiempo de bsqueda
(seek time).
Esto puede generar que pedidos nunca sean ejecutados o demorados por mucho
tiempo.
Para el ejemplo anterior tenemos que la cabeza recorrer un total de 236 cilindros.
11.1.3 SCAN
El brazo posiciona la cabeza al comienzo del disco y la mueve hacia el otro
extremo, resolviendo los pedidos mientras pasa por los cilindros. Al llegar al final,
hace el camino inverso resolviendo las solicitudes.
Es tambin llamado el algoritmo del elevador.
En este caso se recorre un total de 208 cilindros.
Examen marzo 2005:

Describa el algoritmo SCAN.
122
FINGUDELAR
11.1.4 CSCAN
Es igual que el SCAN, pero al llegar al final del disco en la recorrida, vuelve al
principio inmediatamente sin resolver ningn pedido.
11.1.5 CLOOK
Es parecido al C-SCAN, pero el brazo va hasta donde haya pedidos y retorna hacia
el otro sentido.

Enumere y describa brevemente tres mtodos de planificacin de disco.
Respuesta:
Se listan todas las posibles (slo se piden 3):
FCFS (First Come First Served): Atender las solicitudes en orden de llegada. Es fcil de
programar pero no ofrece el mejor tiempo de servicio, pues se invierte mucho tiempo en
cambios de direccin de la cabeza de lectura.
SSTF (Shortest Seek Time First): Atiende la solicitud de menor tiempo de
posicionamiento, respecto a la posicin actual. Debe estudiarse como evitar posposicin
indefinida.
SCAN: La cabeza de lectura comienza en un extremo y se desplaza al otro, sirviendo las
solicitudes al llegar a cada pista, hasta alcanzar el extremo opuesto, y as
sucesivamente.
C-SCAN: Como SCAN, pero cuando llega al extremo opuesto del disco retorna de
inmediato al inicio, donde hay ms solicitudes pendientes, sin atender solicitudes
intermedias.
LOOK: Como SCAN, pero el algoritmo mira si hay ms solicitudes pendientes en la
direccin en que actualmente se est moviendo, y si no hay, cambia de direccin.
C-LOOK es el equivalente para C-SCAN. En general son la forma en que se implanta
SCAN y C-SCAN, por razones de eficiencia.
123
FINGUDELAR
Examen marzo 2005:
Sea un disco con 32 cilindros numerados del 0 al 31, y la siguiente cola de pedidos:
12, 18, 1, 15, 2, 13, 17, 6, 22 y 16.
Haga una tabla que muestre la secuencia de planificacin de atencin de los pedidos para los
algoritmos First Come First Served, Shortest Seek Time First, SCAN, C-SCAN, LOOK y C-LOOK.
Suponga que la cabeza del disco est ubicada sobre el cilindro 30.
Nota: En los algoritmos que pueda haber ms de una opcin, elija una y aclare el criterio.
Respuesta:
En los casos SCAN, C-SCAN, LOOK y C-LOOK supondremos que la cabeza se viene moviendo de
izquierda a derecha.
FCFS: 30-12-18-1-15-2-13-17-6-22-16.
SSTF: 30-22-18-17-16-15-13-12-6-2-1.
SCAN: 30-31-22-18-17-16-15-13-12-6-2-1.
CSCAN: 30-31-0-1-2-6-12-13-15-16-17-18-22.
LOOK: 30-22-18-17-16-15-13-12-6-2-1.
CLOOK: 30-0-1-2-6-12-13-15-16-17-18-22.
11.1.6 Comparacindelosalgoritmosdeplanificacin
SSTF y LOOK son los ms utilizados.
SCAN y C-SCAN han demostrado ser mejores ante sistemas que tienen una alta
carga en disco.
El servicio de disco es muy dependiente del mtodo de asignacin de archivos.
Examen marzo 2003:
Comente y explique diferencias entre las formas de planificacin de disco siguientes: FCFS, SSTF,
SCAN y C-SCAN.
Respuesta:
FCFS ( First Come First Served )
o servicio por orden de llegada
o hay un mayor movimiento total de la cabeza que da menor
desempeo.
SSTF ( Shortest Seek Time First )
o se busca aquel que implique un tiempo ms corto dada la posicin
actual de la cabeza.
o hay que tomar alguna poltica adicional para evitar posposicin
indefinida.
o mejor tiempo que FCFS, pero no es ptimo.
SCAN
o el brazo del disco parte de un extremo del disco, y se mueve
hacia el otro, atendiendo las solicitudes correspondientes a cada
cilindro. Cuando llega al otro extremo del disco, invierte la
bsqueda
o desventaja: cuando la cabeza da la vuelta tiene pocas
solicitudes para atender, pues sigue su recorrida en los
cilindros que visit ms recientemente. La mayora de las
solicitudes pendientes estarn en los timos cilindros a
recorrer.
o Redunda en un tiempo de espera no uniforme.
C-SCAN
o Variante del anterior. Soluciona el problema de posicionamiento
de ste, movindose siempre al cilindro inicial luego de
visitarlos a todos.
Examen marzo 2003:
Utilizara el mtodo de asignacin enlazada en un sistema donde la mayora de los accesos no
son secuenciales? Justifique su respuesta.
Respuesta:
No, el acceso al i-simo bloque de un archivo puede requerir i lecturas de disco, siguiendo los
punteros hasta llegar al bloque destino.
Examen marzo 2005:
Qu desventaja presenta el algoritmo SCAN? D una alternativa.
124
FINGUDELAR
11.2 EstructurasRAID
Es comn tener una gran cantidad de discos adjuntados a un sistema. Esto
permite implementar tcnicas orientadas a mejorar el servicio.
Las mejoras vienen dadas por:
Confiabilidad: casos de fallo de discos.

Lograr mejorar los tiempos de transferencia: acceso ms eficiente.
Examen julio 2007:

Qu tipo de mejoras brindan los sistemas RAID (redundant array of inexpensive disk)?
Examen mazo 2008:
Los sistemas RAID (Redundant Arrays of Inexpensive Disk), a qu mejoras apuntan?
Existen tcnicas llamadas RAID (Redundant Arrays of Inexpensive Disks).

La confiabilidad se logra a travs de redundancia de la informacin.
La redundancia puede darse duplicando discos (mirror), o travs de bits de
control.
La mejora de los tiempos de respuesta se logra a travs de la disposicin de la
informacin en los diferentes discos.
Tcnicas de stripping son utilizadas a nivel de bit, byte, sectores, bloque de
sectores y bloque.
Diferente niveles de RAID
RAID (0 + 1)
125
FINGUDELAR
Examen julio 2005:

Explique como es un sistema RAID 0+1 y describa sus ventajas.
Respuesta:
El nivel de RAID 0+1 fracciona los datos (stripping) para mejorar el rendimiento, pero tambin
utiliza un conjunto de discos duplicados para conseguir redundancia de datos de manera de
aumentar la tolerancia ante fallas. Al ser una variedad de RAID hbrida, RAID 0+1 combina las
ventajas de rendimiento de RAID 0 con la redundancia que aporta RAID 1.
Las estructuras RAID (Redundant Arrays of Inexpensive Disks) brindan servicios de mejora en la
confiabilidad y en los tiempos de transferencias. Haga una tabla que clasifique los RAID tipo 0, 1 y
5, mencionando que servicio(s) mejoran.
Respuesta:
RAID
Confiabilidad
Tiempo acceso
0
No
S
1
S
S y No.*
5
S
S
* Depende de la implementacin. Se toma como vlida cualquier respuesta
126
FINGUDELAR
12 SubsistemadeEntradaSalida
12.1 Introduccin
Uno de las principales funciones de un sistema operativo es controlar todos los
dispositivos de Entrada/Salida que estn conectados al mismo: teclado, ratn,
impresora, monitor, red, etc.
Para encapsular los detalles de los diferentes dispositivos, el ncleo del sistema
operativo se estructura con el uso de mdulos de dispositivos.
Los manejadores de dispositivos (device drivers) presentan un acceso uniforme al
subsistema de Entrada/Salido.
Los dispositivos se comunican con la computadora a travs de seales sobre un
puerto.
Si varios dispositivos utilizan el mismo medio de comunicacin, la conexin es
llamada bus.
Un bus es un conjunto de lneas (wires) y un protocolo que especifica un conjunto
de mensajes que son enviados a travs de l.
Los buses son comnmente usados en los sistemas de computacin para
interconectar los dispositivos.
Un controlador (o adaptador) es un chip electrnico que puede operar en un

puerto, bus, o dispositivo.
Por ejemplo, un controlador de puerto serial es un dispositivo que controla las
seales sobre un puerto serial.
Un controlador de bus SCSI es ms complejo debido al protocolo SCSI.
Muchos dispositivos tienen implementado su propio controlador que est
incorporado al dispositivo (ej.: discos).
La comunicacin con el controlador por parte del procesador se realiza a travs de
regsitros de datos y seales de control. El procesador se comunica con el controlador
escribiendo y leyendo informacin en los registros de controlador.
127
FINGUDELAR
Una va de comunicacin es a travs de instruccciones de E/S especiales que
especifican una transferencia de un byte, o palabra hacia una direccin de puerto de
E/S (I/O port address).
La instruccin de E/S genera adecuadas seales sobre las lneas del bus para
lograr la comunicacin con el dispositivo adecuado y mover bits hacia y fuera de los
registros del dispositivo.
Otra opcin es utilizar mapeo de memoria del dispositivo de E/S (memory-mapped
I/O). Los registros del dispositivo son "mapeados" a memoria principal.
Un ejemplo de este tipo de coumuncicacin es el controlador de una tarjeta de
video.
Un puerto de E/S consiste, generalmente, en cuatro registros:
Estado (status): estos registros pueden ser ledos por el equipo.

Informan del estado del dispositivo (completitud de una operacin,
disponibilidad de leer del registro de datos de entrada, existencia de
un error en el dispositivo.
Control (control): pueden ser escritos por el equipo para generar un
pedido, cambiar de mode el dispositivo.
Datos de entrada (data-in): son ledos por el equipo para obtener la
entrada
Datos de salida (data-out): son escritos por el equipo para enviar
una salida.
12.2 MtodosparaefectuarunaE/S
12.2.1 E/Sprogramada(ProgrammedI/O)
El procesador le comunica un pedido a la controladora del dispositivo y queda en
un "busy waiting" consultando a la controladora para verificar el estado del pedido.
El procesador genera una solicitud de E/S y luego se encarga de controlar la
completitud de la misma controlando algn registro del controlador de dispositivo. La
consulta la realiza en una iteracin continua denominada polling3 o busy waiting. La
tcnica de busy waiting consume ciclos de procesador en forma innecesaria.
copy_from_user(buffer,p,count);
for (i=0; i < count; i++) {
while(*print_status_reg != READY) ;
}
return_to_user();
Si bien esto permite una programacin simple, tiene como gran desventaja el
desperdicio de ciclos de procesador que podran ser utilizados para otra tarea.
Examen mazo 2008:
Describa el mtodo de Entrada/Salida Programada (Programmed IO). Discuta sus ventajas y
desventajas.
Examen marzo 2007: Qu entiende por el mtodo polling?
128
FINGUDELAR
12.2.2 Interrupciones(InterruptDriven)
El procesador le comunica el pedido a la controladora y se libera para realizar
otras tareas. Cuando el dispositivo termina el pedido, la controladora genera una
interrupcin al procesador.
El proceso que est ejecutando realiza la solicitud de E/S, se agrega a la cola de
espera del dispositivo, y finalmente, invoca al planificador (scheduler) para que
asigne el procesador a otro proceso. El controlador de dispositivo notificar la
completitudo de la solicitud a travs de una interrupcin. Una rutina de atencin de
la interrupcin ser invocada interrumpiendo la ejecucin del proceso asignado al
procesador. Es necesario salvar el estado del proceso que estaba ejecutando. Una
vez que la completitud de la E/S es registrada por el manejador de la interrupcin
(interrrupt handler), el proceso que gener la solicitud es desbloqueado y se lo
asigna a la lista de procesos listos.
copy_from_user(buffer,p,cuenta);
habilitar_interrupciones();
While (*printer_status_reg != READY) ;
*printer_data_register = p[0];
add_to_queue(current);
scheduler();
remove_from_queue(current);
...
La rutina scheduler asignar el procesador a otro proceso. Cuando este proceso
vuelva a ejecutar, lo har luego de la instruccion scheduler.
129
FINGUDELAR
if (count == 0)
unblock_user();
else {
*printer_data_register = p[i];
count--;
i++;
}
acknowledge_interrupt();
return_from interrupt();
La gran ventaja es que el procesador queda disponible para otro proceso que
requiera el recurso. Es necesario soporte de hardware, adems, se deben codificar
los manejadores de interrupciones (interrupts handlers).
12.2.3 Accesodirectoamemoria(DMADirectMemoryAccess)
Se utiliza un chip especial que permite transferir datos desde alguna controladora
a memoria sin que el procesador tenga que intervenir en forma continua.
Qu ventaja se tiene en un sistema que utiliza DMA (Direct Memory Access)?
Explique los
pasos que son llevados a cabo para la transferencia.
Respuesta:
El uso de DMA permite que la CPU pueda realizar otras tareas mientras se realiza una
transferencia de E/S.Para la transferencia se debe primero escribir un bloque de comando DMA
en memoria. El bloque contiene un puntero al origen de los datos, un puntero al destino y la
cantidad de bytes a transferir. La CPU escribe la direccin de este bloque en el dispositivo DMA y
se libera para realizar otras tareas. El controlador DMA se encarga, sin interrumpir al procesador,
transferencia operando directamente sobre el bus.
Examen marzo 2007:
describa el mtodo de acceso directo (Direct Memory Access)
Examen julio 2007:
Qu gran ventaja tiene el mtodo de entrada/salida DMA frente al de entrada/salida
programada (Programmed IO). Describa los 6 pasos de una entrada/salida a travs de un DMA.
130
FINGUDELAR
Examen julio 2004:
Describa los diferentes componentes involucrados en una operacin de entrada-salida incluyendo
el propsito especfico de cada uno de ellos.
Respuesta:
*
Hardware de E/S: Dispositivos diversos que generalmente comparten un medio comn o bus,
a donde reportan siguiendo un protocolo especfico. Para cada dispositivo o puerto hay, en
hardware, un controlador que implementa la parte del protocolo que corresponde a aqul.
*
Manejador de interrupciones: Luego de cada instruccin, la CPU verifica una linea de solicitud
de interrupciones, y en caso de que ocurra, salva el estado y llama a una rutina manejadora. Esta
determina
el origen de la interrupcin, la procesa y retorna a la CPU, a la instruccin previa a la interrupcin.
*
DMA: Un controlador especializado que evita ocupar el procesador comn como pasamanos
para transferir informacin del dispositivo a memoria, o viceversa. Para eso accede directamente
al BUS.
Un problema que presenta en el manejo por interrupciones es que, por ejemplo,

los dispositivos orientados a caracteres interrumpen en cada transferencia. Esto
puede generar una degradacin importante del sistema.
Se dispone de un dispositivo especializado que permite realizar transferencias desde
ciertos dispositivos a memoria. La transferencia se hace en paralelo mientras el
procesador realiza otras tareas.
El procesador carga ciertos registros en el controlador DMA para realizar el pedido. El
controlador DMA se encarga de la tarea de transferencia, interrumpiendo al
procesador cuando finaliz.
p = copy_from_user(buffer, p, count);
set_up_DMA_controller();
add_queue_dma(current);
scheduler();
remove_queue_dma(current);
Rutina de interrupcin:
unblock_user();
131
FINGUDELAR
12.2.3.1
Interfaz de aplicacin de E/S
El sistema operativo propone estructuras e interfaces para lograr manipular

dispositivos de E/S de forma estndar y uniforme.
Esta aproximacin genera abstraccin, encapsulamiento y utilizacin de capas en
el software.
Se abstraer los dispositivos identificando sus caractersticas y proponiendo una
forma uniforme de acceso a los dispositivos del mismo tipo.
Cada dispositivo (si bien pueden pertenecer a un mismo tipo) encapsularn la
comunicacin con la controladora en mdulos llamados device drivers
independientes.
Lograr independizar el subsistema de E/S del hardware simplifica el trabajo a los
desarrolladores de un sistema operativo.
Dispositivos de Bloques
132
FINGUDELAR
Son dispositivos que su granularidad de informacin es a nivel de bloques. Se
especializan en transferir grandes volmenes de datos.
Ej. Discos.
Dispositivos de caracteres (Char devices)
La granularidad es de caracteres: Ej. teclados, ratn, puerto serial.
Operaciones bloqueantes (Blocking)
Cuando un proceso requiere de un servicio de E/S a travs de una rutina
bloqueante, el proceso se suspende hasta que la operacin haya finalizado. Es fcil
de utiliar y entender.
Operaciones no bloqueantes (Nonblocking)
El llamado al servicio de E/S es devuelto tan pronto como sea posible.
Operaciones asincrnicas (asynchronous)
La operacin es ejecutada en paralelo. Cuando finaliza le avisa a travs de una
seal. Son difciles de utilizar.
Operaciones sincrnicas (synchronous)
Los procesos que realizan pedidos de E/S se bloquean hasta que el pedido finalice.
El ncleo del sistema operativo brinda varios servicios para el manejo de E/S, que
estn desarrollados en la infraestructura de hardware y device drivers.
Planificacin de E/S (I/O Scheduling)

Buffering
Caching
Spooling
Manejo de errores (Error handling)
Planificacin de E/S (I/O Scheduling)
133
FINGUDELAR
La planificacin de requerimientos de E/S debe ser hecha para lograr un buen
rendimiento del dispositivo.
Seguramente los pedidos generados a travs de llamados a sistema por parte de
los procesos, no generan una buena secuencia de planificacin para el dispositivo.
Cuando un proceso genera una E/S bloqueante, es puesto en la cola del
dispositivo correspondiente y el subsistema de E/S reorganiza los pedidos para lograr
un mayor rendimiento.
Buffering
Es un lugar de memoria que guarda informacin (datos) mientras son transferidos
entre dos dispositivos o un dispositivo y una aplicacin.
Existen 3 razones para realizar buffering:
Normalizar las velocidades entre diferentes dispositivos.

Adaptarse entre dispositivos que difieren en los tamaos de
transferencia
Mantener la semntica de aplicaciones que realizan las E/S: en una
operacin write el buffer de usuario es copiado a un buffer del sistema
operativo. De esa forma, el sistema logra independizarse de la
aplicacin.
Caching
La cache es una regin de memoria ms rpida que contiene copias a datos.
Su utilizad es acelerar el acceso a la informacin.
En buffering se tiene los datos originales, mientras que caching se tiene una o
varias copias en un medio de memoria ms rpido.
El caching introduce problemas de consistencia de la informacin.
Spooling
134
FINGUDELAR
Es un buffer que mantiene salida para un dispositivo que no se pueda intercalar.
El sistema captura la salida para el dispositivo y la va guardando para brindarla en el
orden correcto.
El spooling es un forma que el sistema operativo tiene para coordinar salida
concurrente para dispositivos.
Tiene la ventaja que libera al proceso, permitiendo continuar su ejecucin. Su
trabajo es guardado y ser enviado al dispositivo cuando el subsistema lo crea
conveniente.
Ej.: Impresora.
Manejo de errores (Error handling)
Cada llamado a sistema retorna un bit que informa el xito o fracaso de la
operacin sobre una E/S. EN UNIX se utiliza una variable errno que es utilizada para
codificar el error.
135
FINGUDELAR
13 Concurrencia
Un proceso cooperativo puede afectar o ser afectado por los dems. Podran
compartir un espacio de direcciones lgicas (cdigo y datos), o solo datos a travs de
archivos. En el primer caso, es a travs de hilos, lo que puede dar pie a
inconsistencias.
Ejemplo de concurrencia
FACTORIAL(N:Integer)
BEGIN
COBEGIN
a=Semifact(N,)
b=Semifact(N/(21),1)
COEND
fact=a*b
END
Todo lo que est entre

COBEGIN y COEND se puede
ejecutar de forma simultnea.
Multiplicoporseparado
1n/2yn/2n
Ejemplo de no concurrencia
J=10
COBEGIN
COEND
printj
printj
j=1000
La primera impresin, no s si es 10 o 1000, todo depende de

que instruccin se ejecute primero.
La segunda impresin siempre es 1000, porque hasta que no
se ejecute todo lo que est entre el COBEGIN y COEND no se sigue.
13.1 Antecedentes
Cuando compartimos a travs de un buffer, hay que controlar si se vaca o llena.
Podemos aadir un contador que indica la cantidad de elementos del buffer.
El problema es que como los procesos que leen y escriben son concurrentes,
pueden aparecer problemas al actualizar el valor de esa variable, dependiendo de
cmo se ejecuten las instrucciones de mquina. Debemos lograr que solo un proceso
a la vez trabaje con el contador.
Ejemplo:
1 Reg1=cont
2 Reg1=Reg1+1
3 cont=Reg1
4 Reg2=cont
5 Reg2=Reg21
6 cont=Reg2
La variable contador puede guardar distintos

valores. Si el contador al comienzo es 6, y ejecuto
las instrucciones:
1 4 2 5 3 6: El contador queda en 5
1 2 3 4 5 6: El contador queda en 6
Grafo de precedencia
Es un grafo acclico, dirigido, cuyos nodos corresponden a las sentencias, y las
flechas a la precedencia.
136
FINGUDELAR
Ejemplo:
Grafo:
Cdigo1:
INI
S2
S3
INI
COBEGIN
COEND
FIN
S4
P:
BEGIN
S5
S6
FIN
END
Cdigo2:
INI
COBEGIN
P
S3
S2
S4
COBEGIN
COEND
S5
S6
COEND
FIN
BEGIN
END
S3
S2
S4
COBEGIN
COEND
S5
S6
Ejemplo:
Grafo:
INI
S2
S3
S4
S5
S6
FIN
En este caso no hay forma de representar el grafo con COBEGIN y COEND, sin
incorporar otras primitivas.
13.2 Elproblemadelaseccincrtica
Consideramos el sistema con n procesos {P0, , Pn}, donde cada cual tiene
un segmento de cdigo, llamado seccin crtica, en el que el proceso podra estar
modificando variables comunes, etc.
La idea es que mientras un proceso se est ejecutando en
Secciningreso
seccin crtica, ningn otro puede estar en otra seccin crtica;
solo ejecutando otras secciones.
Seccincrtica
As la ejecucin de secciones crticas, es mutuamente
exclusiva.
Cada proceso debe solicitar permiso para ingresar en
Seccinegreso
su seccin crtica y debe indicar cuando sali de ella.
Tres requisitos que cumple una seccin crtica
Mutua exclusin: Si el proceso Pi se ejecuta en su seccin crtica,
ningn otro proceso puede estarse ejecutando en su seccin crtica.
Espera limitada: Hay un lmite, para el nmero de veces que se
permite a otros procesos entrar en sus secciones crticas, luego de que
137
FINGUDELAR
un proceso pidi autorizacin de ingreso. No se permite la posposicin

indefinida.
Progreso: Se deben cumplir las siguientes condiciones:
No alternacin: No puedo obligar a que se ejecuten, primero uno,
luego el otro, vuelvo al primero, etc.
Sin puntos muertos (Deadlock): A espera a B, y B espera a A, y
los dos estn bloqueados simultneamente.

Demuestre la verdad o falsedad de cada uno de los siguientes enunciados:
1) las cuatro condiciones necesarias para el bloqueo mutuo son tambin suficientes si
existe solo un recurso de cada uno de los tipos implicados en la espera circular.
Respuesta:
Verdadera: Dada la definicin de grafo de asignacin de recursos, puede
mostrarse fcilmente que si el grafo contiene un ciclo y cada tipo de recursos
tiene exactamente una instancia, entonces un ciclo implica que se ha producido
un bloqueo mutuo. En otras palabras, si todos tienen recursos asignados y
estn esperando por otros en una cola circular, (no pudiendo ni compartir los
recursos ni quitrsele la asignacin a ningn proceso), entonces no van a poder
liberar sus recursos hasta tanto no obtengan el recurso que esperan, que no
ser liberado hasta que alguien de la cadena desista o libere su recurso. Como
esto no suceder (porque no puede quitrsele el recurso) entonces quedarn
esperando eternamente.
2) las cuatro condiciones necesarias para un bloqueo mutuo son tambin suficientes si
existen varios recursos de cada uno de los tipos implicados en la espera circular.
Respuesta:
Falsa: Esto puede verse fcilmente con el siguiente contraejemplo:
Aunque aqu hay un ciclo y se cumplen las 4 condiciones necesarias, cuando P3 libere
una de las instancias de R1, dejar de existir el ciclo y all se ver claramente que no
hay bloqueo mutuo, pues ahora se le puede asignar a P2 una instancia de R1.
Examen marzo 2004:
Mencione los tres requisitos que debe cumplir una solucin al problema de la seccin crtica.
Enumere y explique cuales son los tres requisitos que debe cumplir una solucin al problema de
la seccin crtica.
Respuesta:
exclusin mutua: A lo mximo un proceso puede estar ejecutando en su seccin crtica. Progreso:
La decisin de cul ser el prximo proceso a entrar en su seccin crtica debe ser tomada solo
por aquellos que no estn ejecutando en su seccin restante, y esta decisin no puede
postergarse indefinidamente. Espera limitada: Desde el momento en que un proceso particular
intent entrar a su seccin crtica, debe haber un lmite en la cantidad de veces que otros
procesos logran entrar antes que l.
13.2.1 Solucionesparadosprocesos
Para explicarlo mejor vamos a usar el problema de:
Alicia y Bernardo, son vecinos, y tienen un patio en comn. En ese patio quieren
pasear sus perros, pero los dos juntos se pelean, as que tienen que turnarse
Algoritmo 1
138
FINGUDELAR
PROCEDUREAlicia
whiletruedo
{
whileturno<>1do;
PASEO_PERRO
turno=2;
OTRAS_TAREAS
}
END
BEGIN
END
PROCEDUREBernardo
whiletruedo
{
whileturno<>2do;
PASEO_PERRO
turno=1;
OTRAS_TAREAS
}
END
turno=1;
COBEGIN
COEND
Alicia
Bernardo
Los dos comparten una variable global turno, y dependiendo del valor de la
variable, pasean al perro.
Se cumple la mutua exclusin, pero no la no alternacin (progreso), ya que hasta
que Bernardo no pasee el perro, Alicia no puede hacerlo.
Algoritmo 2-a
PROCEDUREAlicia
whiletruedo
{
1whileflag_bdo;
2flag_a=true;
3PASEO_PERRO
4flag_a=false;
OTRAS_TAREAS
}
END
BEGIN
END
PROCEDUREBernardo
whiletruedo
{
1whileflag_ado;
2flag_b=true;
3PASEO_PERRO
4flag_b=false;
OTRAS_TAREAS
}
END
flag_a=false;
flag_b=false;
COBEGIN
Alicia
Bernardo
COEND
Otra solucin es colocar banderas al salir. Miro si el otro tiene la bandera colocada,
y si no la tiene, salgo.
Surge un problema, y es que puede suceder, que los dos evalen las flags al
mismo tiempo, dando true, y salgan los dos a pasear el perro.
No se satisface la condicin de mutua exclusin.
Para analizar la situacin, se utiliza el mtodo de entrelazado, que representa el
estado de las banderas en cada una de las instrucciones.
139
FINGUDELAR
ALICIA
1
B
E
R
N
A
R
D
O
FF
FF
TF
TF
FF
FF
FF
FT
FT
FF
FT
FT
TT
TT
FT
FT
FT
TT
TT
FT
FF
FF
TF
TF
FF
1
2
3
4
Algoritmo 2-b
PROCEDUREAlicia
whiletruedo
{
1flag_a=true;
2whileflag_bdo;
3PASEO_PERRO
4flag_a=false;
OTRAS_TAREAS
}
END
BEGIN
END
PROCEDUREBernardo
whiletruedo
{
1flag_b=true;
2whileflag_ado;
3PASEO_PERRO
4flag_b=false;
OTRAS_TAREAS
}
END
flag_a=false;
flag_b=false;
COBEGIN
Alicia
Bernardo
COEND
Otra forma de hacerlo, es antes mirar la bandera del otro, levantar la de uno,
mostrando la intencin de pasear al perro, y luego miro si puedo.
Resuelvo el problema de mutua exclusin, pero puedo llegar a DEADLOCK
Algoritmo 3
Si combinamos los dos primeros algoritmos, llegamos a la solucin definitiva,
llamada Algoritmo de Dekker
140
FINGUDELAR
ALICIA
1
B
E
R
N
A
R
D
O
3
TF
FF
TF
TF
FF
FT
TT
TT
FT
FT
TT
FT
FT
TT
FT
FF
FT
1
2
3
4
TF
TF
FF
PROCEDUREAlicia
whiletruedo
{
flag_a=true;
whileflag_bdo
{
if(turno==2)then
{
flag_a=false
while(turno==2)do;
flag_a=true;
}
}
PASEO_PERRO
turno=2;
flag_a=false;
OTRAS_TAREAS
}
END
BEGIN
END
PROCEDUREBernardo
whiletruedo
{
flag_b=true;
whileflag_ado
{
if(turno==1)then
{
flag_b=false
while(turno==1)do;
flag_b=true;
}
}
PASEO_PERRO
turno=1;
flag_b=false;
OTRAS_TAREAS
}
END
flag_a=false;
flag_b=false;
turno=1;
COBEGIN
Alicia
Bernardo
COEND
La solucin de Peterson soluciona igual que Dekker, pero es ms general, ya

que esta solucin es complicada para ms de dos personas.
Examen marzo 2005:
Escriba un algoritmo en lenguaje de alto nivel (C o PASCAL) que solucione el problema de la
seccin crtica para dos procesos en un sistema monoprocesador. Asuma que las sentencias son
ejecutadas de forma atmica. Solo se permitir el uso de variables globales a los dos procesos, y
es posible utilizar busy waiting. Que requerimientos debe satisfacer su solucin para que esta
sea correcta? Solo enuncielos, no los describa.
Respuesta:
-----------------------------------flag[i] := true;
turn := j;
while (flag[j] and turn=j) do no-op;
SECCION CRITICA
flag[i] := false;
-----------------------------------a. Mutuo Exclusin.
b. Progreso.
c. Espera limitada.
Examen marzo 2006:
a) Qu soluciona el algoritmo de Dekker? b) Escriba el algoritmo de Dekker.
141
FINGUDELAR
Respuesta:
Soluciona el problema de la seccin crtica para dos procesos.
Examen marzo 2003:

Qu problemas presenta el algoritmo de Dekker para mutuo exclusin de procesos?
Respuesta:
Satisface los requisitos para el problema de la seccin crtica, pero presenta un busy-wait, pues
espera el cambio de una flag que indica qu proceso puede acceder a su seccin crtica.
Slo es aplicable para 2 procesos y no es facilmente generalizable para N procesos.
FORK- JOIN
FORKET1
ET1
Sintaxis: FORK etiqueta
JOIN m,etiqueta
FORK
JOIN
Es como un GOTO, donde un proceso se ejecuta siguiente, y el otro despus de la

etiqueta.
En el caso del JOIN, decremento m en uno, y si m = 0, salto a la etiqueta. Estas
dos instrucciones, se ejecutan como instruccin nica, de corrido.
142
FINGUDELAR
Grafo:
INI
S2
S3
S4
S5
S6
FIN
Si hay n procesos concurrentes, el join mata uno a uno, y recin el ltimo, pasa a
ejecutar el proceso siguiente.
Ejemplo: El caso que no se poda solucionar con COBEGIN Y COEND
S1
cont1 = 2
cont2 = 2
FORK L1
S2
S4
FORK L2
S5
GOTO L7
L1 :
S3
L2:
JOIN cont1, L6
QUIT
L6:
S6
L7:
JOIN cont2, L8
QUIT
L8:
S7
FORK - WAIT
main ()
{
int pid_hijo;
pid_hijo = FORK();
if (pid_hijo < 0)
SIGNAL_ERROR
else
{
if (pid_hijo == 0)
// Soy el hijo
else
143
FINGUDELAR
// Soy el padre
}
Examen julio 2004:

A continuacin se propone una solucin al problema de la seccin crtica para dos procesos i y j
que ejecutan en un nico procesador. Las instrucciones son atmicas.
Proceso i
Proceso j
while (true) do begin
while (true) do begin
flagi := true;
flagj := true;
while ( flagj ) do begin
while ( flagi ) do begin
flagi := false;
flagj := false;
while ( flagj ) do
while ( flagi ) do
no-op;
no-op;
flagi := true;
flagj := true;
end;
end;
Seccin Crtica
Seccin Crtica
flagi := false;
flagj := false;
Seccin no crtica
Seccin no crtica
end;
end;
Determine si es correcta. Justifique brevemente.
Respuesta:
Para comprobar que el algoritmo es correcto, hay que demostrar que cumple las tres condiciones
de exclusin mutua, progreso y espera limitada. Para comprobar que no es correcto basta con un
contraejemplo. En este caso no se cumple ya que el siguiente ejemplo muestra un caso para el
cual no se cumple la condicin de progreso.
flagi := true;
flagj := true;
flagi := false;
flagj := false;
while ( flagj ) do
while ( flagi ) do
flagi := true;
flagj := true;
...
Si se mantiene esta secuencia de ejecucin nunca accedern a la seccin crtica, y por lo tanto el
esquema no progresa.
13.3 Hardware de sincronizacin

Las caractersticas de hardware pueden facilitar las tareas de programacin y
mejorar la eficiencia del sistema.
El problema de las seccin crtica se resolver fcilmente en un entorno
uniprocesador, prohibiendo las interrupciones mientras se modifica una variable,
pero esa solucin no es factible en un entorno multiprocesador, ya que es costoso
sincronizar todos los CPU con la prohibicin de interrupciones.
Muchas mquinas cuentan con instrucciones de hardware para modificar variables
en forma atmica.
La instruccin Evaluar_y_asignar (test_and_set) se ejecuta atmicamente como
unidad ininterrumpible, por lo tanto, si se ejecutan dos a la vez, lo van a hacer
secuencialmente y no concurrentemente.
function Evaluar_y_asignar (Var objetivo : boolean) : boolean
144
FINGUDELAR
begin
Evaluar_y_asignar:= objetivo;
objetivo:= true;
end
La forma de usarlo es:

while Evaluar_y_asignar (cerradura) do nada;
SECCIN CRTICA
cerradura:= false;
SECCIN RESTANTE
La instruccin intercambiar opera sobre dos palabras, ejecutndose

atmicamente.
procedure Intercambiar (var a, b: boolean);
var temp: boolean;
begin
temp := a;
a:= b;
b:= temp;
end;
y se usa de la forma:
repeat
llave:= true;
repeat
Intercambiar (cerradura, llave);
until llave = false;
SECCIN CRTICA
cerradura:= false;
SECCIN RESTANTE
until false;
Compare el uso directo de instrucciones tipo Test&Set con el uso de semforos
Respuesta:
Test&Set
Semforo
Requiere slo soporte de hardware
Requiere
soporte del Sistema
Operativo y Hardware
Se produce espera ocupada
Procesos esperan en estado bloqueado
Mecanismo de bajo nivel
Mecanismo de mayor nivel (llamada al
(instruccin de mquina)
sistema)
No permite priorizar las esperas
Procesos bloqueados pueden priorizarse
Dependiente de la arquitectura
Dependiente del sistema operativo (ms
del procesador
portable)
Examen marzo 2005:
En un sistema monoprocesador: Sn necesarias la operaciones Test and Set y Swap?
Justifique. Si considera que es necesario: Quin provee la operacin Test and set?
Respuesta:
S, son necesarias ya que la sincronizacin entre los procesos se debe proveer al igual que en un
sistema multiprocesador. La instruccin es provista por el hardware.
145
FINGUDELAR
A nivel del sistema operativo, qu permite la instruccin SWAP provista por el hardware?
Respuesta:
Poder implementar la sincronizacin entre procesos, debido a la atomicidad que presenta esta
instruccin.
13.4 Semforos
Las soluciones dadas anteriormente no son generalizables, para superar esa
dificultad, podemos usar una herramienta de sincronizacin llamada semforo.
Un semforo S, es una variable entera, que luego de asignarle un valor inicial, solo
se lo puede acceder con dos operaciones atmicas P (espera) y V (seal).
P(S):
while (s > 0);
s--;
V(S):
s++;
Semforo binario: Su valor vara entre 0 y 1.
13.4.1 Uso
Se puede usar semforos para resolver problemas de seccin crtica para n
procesos. Todos los procesos comparten un semforo de valor inicial 1. Adems
podemos sincronizar procesos, iniciando S con valor 0 y poniendo:
P1;
V(S);
Por lo tanto P2, va a ejecutarse despus de P1, porque tiene que esperar
V(S).
P(S);
P2;
13.4.2 Implementacin
Las desventajas del ejemplo anterior, es que requiere busy waiting, ya que
cualquier proceso que quiera ingresar a la seccin crtica, mientras otro est en ella,
debe ejecutar continuamente el ciclo de ingreso, generando un gasto innecesario del
CPU, aunque en sistemas multiprocesador puede ser una ventaja, porque no requiere
cambio de contexto.
Para no usar busy waiting, se pueden definir los semforos de otra forma,
bloqueando el proceso mientras espera. La operacin coloca al proceso en una cola
de espera asociada al semforo, y este proceso se inicia cuando otro proceso ejecute
V de ese semforo. El semforo se define como un arreglo:
type semaforo = record
valor: integer;
L: list of proceso;
end;
P(S):
Y las operaciones son de la forma:

if (s > 0) then
V(S): if (hay tarea en espera por S)
s--;
then
else
despierto una;
espero en S;
else
146
FINGUDELAR
endif
s++;
endif
P(S) = s--;
if (s < 0) wait;
V(S) = s++;
if (s > 0) despierto una;
Ejemplo:
VAR a, b, c, d, e, f, g SEMAFORO;
INIT (a, 0);
INIT (b, 0);
INIT (c, 0);
INIT (d, 0);
INIT (e, 0);
INIT (f, 0);
INIT (g, 0);
COBEGIN
S1
b
a
S2
S3
S4
c
BEGIN
BEGIN
BEGIN
BEGIN
BEGIN
BEGIN
S5
S6
f
S1; V(a); V(b); END

P(a); S2; S4; V(c); V(d); END
P(b); S3; V(e); END
P(c); S5; V(f); END
P(d); P(e); S6; V(g); END
P(f); P(g); S7; END
COEND
S7
Otra forma, es tratando de ahorrar semforos.

VAR d SEMAFORO;
INIT (d, 0);
S1;
COBEGIN
BEGIN S2; S4; V(d); S5; END
BEGIN S3; V(d); END
BEGIN P(d); P(d); S6; END
COEND
S7;
Se debe crear mutua exclusin entre P y V, para ello, se usa busy waiting, ya que
los cdigos de P y V son cortos, y la espera es muy pequea.
La lista de procesos en espera (cuando hago P), se puede implementar de
diferentes formas.
El semforo es un buen mecanismo para obtener la exclusin mutua entre dos procesos.
Explique brevemente porque si las operaciones P y V no se ejecutan en forma atmica puede no
proporcionarse la exclusin mutua.
Respuesta:
147
FINGUDELAR
wait(s)=
si (s > 0) entonces
s := s - 1;
sino
detener_tarea;
fin si;
signal(s)=
si (hay_tarea_detenida) entonces
reanudar_tarea;
sino
s := s + 1;
fin si;
Semforos no binarios:
1) Tenemos una variable comn s, en signal un incremento de s y en wait un
decremento de s. Hay problemas cuando una tarea incrementa concurrentemente
con otra tarea una variable comn. Entonces si el incremento o decremento son
divisibles hay problemas a que esa instruccin puede consistir de varias
instrucciones de mquina.
2) Si suponemos que el incremento y el decremento de s son indivisibles, pero
wait y signal divisibles tambin hay problemas pues puede darse a la vez la
pregunta del valor de s y el decremento/incremento de la variable. Entonces
puede darle que s es mayor que cero y a la vez estarse decrementando y quedar
menor que cero cuando va a ejecutar la opcin del if.
Otra forma de verlo es haciendo el entrelazado de wait con wait, wait con signal o signal con
signal.
Un proceso A recibe datos por la red y lo escribe en una zona de memoria. Un proceso B debe
imprimir por pantalla cada uno de los datos recibidos por A. Explique si el siguiente cdigo
resuelve el problema.
Semaphore ready = 0;
While(TRUE) {
Semaphore go
= 0;
P(go);
While(TRUE) {
Copiar_datos();
Leer_red();
V(ready);
v(go);
Imprimir();
poner_datos();
}
P(ready); }
Respuesta:
No lo resuelve
Podra ocurrir que Copiar_datos se ejecutara a la vez e incluso antes que poner_datos
Por ejemplo la primera vez podra darse esta secuencia de ejecucin:
V(go)
P(go)
Copiar_datos()
poner_datos
13.4.3 Bloqueos mutuos e inanicin

Se puede llegar a dar el caso en que dos o ms procesos esperen indefinidamente
la ocurrencia de un suceso. Estos procesos estn en bloqueo mutuo.
Ejemplo:
P1
Espera(S)
Espera(Q)
.
.
.
Seal(Q)
Seal(S)
P2
Espera(Q)
Espera(S)
.
.
.
Seal(S)
Seal(Q)
P1 ejecuta Espera(S), y P2 ejecuta Espera(Q), P2 no va a

poder continuar hasta que P1 no ejecute Seal(Q), y de la
misma forma, P1 no puede continuar hasta que P2 ejecute
Seal(S). Los dos procesos estn en bloqueo mutuo.
Otro problema es la inanicin que es cuando algunos
procesos esperan indefinidamente dentro del semforo.
Puede suceder si la lista de espera del semforo es LIFO.
148
FINGUDELAR
13.4.4 Semforos binarios
En el caso anterior, el semforo es llamado de conteo porque su valor puede
tomar cualquier valor entero. Los semforos binarios solo pueden tomar los valores 0
y 1.
Es posible implementar un semforo de conteo, utilizando semforos binarios. Se
hara de la forma:
Estructura (S):
Espera (S):
Seal(S):
var
Espera (S1);
C--;
if (C < 0)
{
Seal (S1);
Espera (S2);
}
Seal (S1);
Espera (S1);
C++;
if (C >= 0)
Seal (S2);
else
Seal (S1);
S1: SemBin;
S2: SemBin;
C: integer;

Qu son y para qu sirven los semforos binarios? Implemente semforos binarios con
monitores.
Respuesta:
type bin_semaforo: monitor;
var ocupado : boolean;
no_ocupado : condition;
procedure wait;
begin
if (ocupado) then
no_ocupado.wait;
ocupado := true;
end procedure;
procedure signal;
begin
ocupado := false;
no_ocupado.signal;
end procedure;
begin
ocupado := false;
end bin_semaforo;
Ver secuencia :
P1
Bin_semaforo.wait;
Bin_semaforo.signal;
P2
bin_semaforo.wait;
a. P1 hace wait, como no esta ocupado pone ocupado en true y sigue.

b. P2 hace wait, como esta ocupado hace wait sobre la variable
no_ocupado y queda esperando.
c. P1 hace signal, pone ocupado en false y hace un signal sobre
no_ocupado. Entonces P2 que estaba esperando en la condition
no_ocupado se despierta y pone ocupado en true y entra;
149
FINGUDELAR
13.5 Problemas clsicos de sincronizacin
13.5.1 Elproblemadelbuffer
Contamos con un proceso productor que almacena en un buffer, y con un proceso
consumidor, que consume del buffer.
Buffer infinito:
PROCEDURE Prod
REPEAT
P(s);
Agregar(Buffer.dato);
V(s);
V(n);
FOREVER
BEGIN
END
PROCEDURE Cons
REPEAT
P(n);
P(s);
Sacar (Buffer.dato);
V(s);
FOREVER
INIT (n, 0);

INIT (s, 1);
COBEGIN
Prod; Prod;
Cons; Cons;
COEND
Buffer finito:
PROCEDURE Prod
REPEAT
P(l);
P(s);
Agregar(Buffer.dato);
V(s);
V(n);
FOREVER
BEGIN
END
PROCEDURE Cons
REPEAT
P(n);
P(s);
Sacar (Buffer.dato);
V(s);
V(l);
FOREVER
INIT (n, 0);

INIT (s, 1);
INIT (l, tam_buff);
COBEGIN
Prod; Prod;
Cons; Cons;
COEND
13.5.2 Elproblemadeloslectoresyescritores
Un objeto de datos se comparte entre procesos, los cuales pueden leer o escribir.
Si dos lectores acceden simultneamente no pasa nada malo, sin embargo si un
150
FINGUDELAR
escritor y otro proceso (lector o escritor) acceden simultneamente, el resultado
puede ser errneo.
Hay dos planteos. El primero es el de no tener esperando a ningn lector a menos
que el escritor ya est escribiendo. El segundo quiere que apenas haya un escritor,
realice su escritura lo antes posible.
PROCEDURE Lector
REPEAT
P(mutex);
ContLeer++;
If ContLeer = 1 then P(esc);
V(mutex);
LEER
PROCEDURE Escritor
REPEAT
P(esc);
ESCRIBIR
V(esc);
FOREVER
ContLeer--;
if ContLeer = 0 then V(esc)
V(mutex);
FOREVER
BEGIN
END
INIT (esc, 1);

INIT (mutex, 1);
INIT (l, tam_buff);
COBEGIN
Lect; Lect;
Esc; Esc;
COEND
13.5.3 Elproblemadelosfilsofos
Hay cinco filsofos que se pasan la vida pensando y
comiendo. Comparten una mesa circular rodeada por
cinco sillas, con un plato con arroz para cada uno. Adems
hay cinco palillos chinos individuales.
Cuando el filsofo piensa, no interacta, pero cuando
siente hambre, trata de tomar dos palillos para comer, y
obviamente no puede tomar un palillo que est en manos
de sus colegas. Cuando termina de comer deja ambos
palillos sobre la mesa y comienza a pensar otra vez.
Una forma es representar cada palito con un semforo.
151
FINGUDELAR
PROCEDURE Filsofo (I : Integer)
izq = I;
der = (I + 1) mod 5;
REPEAT
PENSAR;
P(Tenedor(izq));
P(Tenedor(der));
COMER;
V(Tenedor(der));
V(Tenedor(izq));
FOREVER
END Filsofo
BEGIN
END
Tenedor::array(0..4) of SEMAFORO;
for (int I = 1, I < 4; i++)
init (Tenedor(i), 1);
COBEGIN
for (int j = 1, j < 4; i++)
Filsofo(j);
COEND
Esta posibilidad no permite que dos vecinos coman simultneamente, pero puede
generar bloqueos mutuos, por ejemplo si todos sienten hambre a la vez y toman su
palillo izquierdo. Algunas formas de solucionarlo son:
Permitiendo que solo cuatro filsofos se sienten a la vez
Solo permitir que tome los palillos, cuando los dos estn disponibles (tomndolos
dentro de una seccin crtica)
Solucin asimtrica, donde los filsofos pares toman primero el de la derecha, y
los impares primero el de la izquierda.
Solo cuatro filsofos a la vez:
PROCEDURE Filsofo (I : Integer)
izq = I;
der = (I + 1) mod 5;
REPEAT
PENSAR;
P(Comedor);
P(Tenedor(izq));
P(Tenedor(der));
COMER;
V(Tenedor(der));
V(Tenedor(izq));
V(Comedor);
FOREVER
END Filsofo
BEGIN
END
Tenedor::array(0..4) of SEMAFORO;
for (int I = 1, I < 4; i++)
init (Tenedor(i), 1);
init (Comedor, 4);
COBEGIN
for (int j = 1, j < 4; i++)
Filsofo(j);
COEND
152
FINGUDELAR
13.6 Regionescrticas
Los semforos pueden dar pie a errores de temporizacin que ocurren cuando se
dan ciertas secuencias de ejecucin especfica. Para reducir la posibilidad de
ocurrencia de estos errores se han introducido varias construcciones en los lenguajes
de alto nivel, la regin crtica.
Suponemos que un proceso consiste en algunos datos locales y un programa
secuencial que puede operar sobre esos datos. Solo el programa secuencial de un
proceso puede acceder a sus datos, o sea, que no puede acceder directamente a los
datos locales de otro proceso. Los procesos si pueden compartir datos globales.
La forma de hacer esto es: Si tengo una variable v, que puedo cambiar, debo
tener otra variable B global. Solo puede accederse a v, cumpliendo el enunciado
region v when B do S. Cuando el proceso intenta acceder a v, debe cumplir B para
lograr ingresar a la seccin crtica. Esta solucin de todas formas, no contempla
algunos problemas de sincronizacin, aunque reduce su nmero.
13.7 Monitores
Un monitor se caracteriza por un conjunto de operadores definidos por el
programador. Consiste en declaracin de variables cuyos valores definen el estado
de un ejemplar del tipo, as como los cuerpos de procedimientos o funciones que
implementan operaciones con el tipo.
La sintaxis es:
type nombre_monitor = monitor
declaracin de variables
procedure entry P1 (...)
begin end;
procedure entry P2 (...)
begin end;
procedure entry Pn (...)

begin end;
begin
cdigo de inicializacin
end.
Un procedimiento definido dentro de un monitor slo puede acceder a las

variables definidas dentro del monitor, por lo tanto el programador no necesita
codificar la restriccin de sincronizacin.
La construccin del monitor garantiza que slo un proceso a la vez puede estar
activo; sin embargo esta construccin todava no logra modelar algunos esquemas
de sincronizacin.
La construccin condicin proporciona dichos mecanismos
153
FINGUDELAR
var x, y : condicin;
y las nicas operaciones que puede invocar x, son x.espera y x.seal, donde
x.seal, reanuda uno y solo un proceso suspendido, y si no hay ninguno, no tiene
efecto.
Monitor
Monitor con variables de

condicin
coladeingreso
coladeingreso
datoscompartidos
datoscompartidos
x
y
operacio
nes
operacio
nes
colas
asociad
asax,y
condicio
nes
cdigodeinicializacin
cdigodeiniciacin
Si P y Q estn asociados a x, y P ejecuta x.seal, Q renuda su ejecucin, por lo

tanto P debe esperar.
Cuando P ejecuta x.seal, inmediatamente sale del monitor, por lo tanto Q
tambin reanuda de inmediato.
Filsofos comensales:
var estado : array[0..4] of (pensando, hambriento, comiendo);
donde un filsofo puede estar comiendo, solo si no lo hacen sus vecinos. Tambin
se necesita declarar:
var mismo : array[0..4] of condicin;
por la cual puedo retardar al filsofo i si tiene hambre, pero no puede obtener los
palillos.
type filsofos_comensales = monitor
var estado : array [0..4] of (pensando, hambriento, comiendo);
var mismo : array [0..4] of condicin;
procedure entry tomar (i : 0..4);
begin
estado[i] := hambriento;
probar(i);
if estado[i] <> comiendo then mismo[i].espera;
end;
154
FINGUDELAR
procedure entry dejar (i : 0..4);
begin
estado[i] := pensando;
probar(i + 4 mod 5);
probar(i + 1 mod 5);
end;
procedure entry probar (k : 0..4);
begin
if estado[k+4 mod 5] <> comiendo;
and estado[k] = hambriento;
and estado[k+1 mod 5] <> comiendo;
then begin
estado[k] := comiendo;
mismo[k].seal;
end;
end;
begin
for i:= 0 to 4
do estado[i] := pensando;
end.
Cada filsofo antes de comenzar a comer, debe invocar la operacin tomar. El
proceso se puede suspender, y una vez que la operacin tiene xito, el filsofo puede
comer. A continuacin el filsofo invoca dejar y puede comenzar a pensar.
Esto soluciona que dos vecinos no estn comiendo simultneamente, y que no
ocurren bloqueos mutuos, pero un filsofo podra morir de hambre.
Otro problema es el orden de reanudacin de procesos suspendidos por x, si
alguno ejecuta x.seal. Una forma de hacerlo es con FCFS.
Productor consumidor:
const tamao 184
Monitor buff_finito
var
b: array [0..tamao] of integer;
n, in, out: integer;
nolleno, novacio: condition;
procedure Agrego (v: integer)
begin
if (n == tamao + 1) then
nolleno.wait()
endif
b[in] = v;
in = (in + 1) mod (tamao + 1);
n++;
novacio.signal();
end
procedure Saco (v: integer)
begin
if (n == 0) then
novacio.wait()
155
FINGUDELAR
endif
v = b[out];
out = (out + 1) mod (tamao + 1);
n--;
nolleno.signal();
end
begin
n = 0; in = 0; out = 0;
end
Lector Escritor:
program Lector_Escritor
Monitor LE;
var
lect : integer;
esc : boolean;
okleer, okescribir : condition;
procedure com_lect
if (esc or NonEmpty (okescribir)) then
okleer.wait;
endif
lect++;
okleer.signal;
end
procedure fin_lect
lect--;
if (lect = 0) then
okescribir.signal;
endif
end
procedure com_esc
if (lect <> 0 or esc) then
okescribir.wait;
endif
esc = true;
end
procedure fin_esc
esc = false;
if (NonEmpty (okescribir)) then
okescribir.signal;
else
okleer.signal;
endif
end
156
FINGUDELAR
begin
lect = 0; esc = false;
end
procedure Lectura
com_leer
LEER
fin_leer
end
procedure Escribir
com_esc
ESCRIBIR
fin_esc
end
begin
cobegin
Escribir; Escribir;
Leer; Leer;
coend
end
Examen marzo 2004:
En el contexto de monitores, cuando un proceso ejecuta un signal sobre una condicin, y hay un
proceso esperndola, qu debe resolverse y qu polticas pueden tomarse para ello?
13.8 SincronizacinenSolaris2
Antes de Solaris 2, el sistema implementaba las secciones crticas estableciendo el
nivel de interrupcin, a un valor tanto o ms alto que cualquier interrupcin que
pudiera modificar los mismos datos.
Solaris 2, se dise con miras a ofrecer capacidades de tiempo real, ser miltihilado
y manejar multiprocesadores. Si hubiera seguido utilizando secciones crticas, el
desempeo hubiera sufrido una degradacin considerable, pues el ncleo se habra
convertido en un cuello de botella.
Solaris 2 emplea mutex adaptativos, que inicialmente es un semforo estndar
implementado como cerradura de giro.
13.9 Transaccionesatmicas
La mutua exclusin de las secciones crticas asegura que estas se ejecutarn
atmicamente.
13.9.1 Modelodelsistema
Una coleccin de instrucciones que realiza una sola funcin lgica, es una
transaccin. Un aspecto importante es la preservacin de atomicidad. Una
transaccin es una unidad de programa que accede y actualiza datos. Es una
secuencia de operaciones leer y escribir que termina con una operacin
confirmar si termin con xito, o abortar, si hubo error o un fallo del sistema.
157
FINGUDELAR
Una transaccin abortada podra haber modificado datos, por lo tanto, esos datos
deben ser restaurados; se revierte la operacin. Una de las obligaciones del
sistema es garantizar esa propiedad.
La forma que utiliza el sistema para garantizar la atomicidad depende del medio
de almacenamiento.
Almacenamiento voltil: La informacin casi nunca sobrevive a una

cada del sistema. Un ejemplo es la memoria principal o el cache.
Almacenamiento no voltil: La informacin por lo regular sobrevive
a la cada del sistema. Un ejemplo son los discos o cintas magnticas.
Almacenamiento estable: La informacin nunca se pierde.
13.9.2 Recuperacinbasadaenbitcoras
El sistema mantiene en el almacenamiento estable una estructura de datos
llamada bitcora, donde cada registro, describe una sola operacin de escritura, y
tiene los siguientes campos:
Nombre de la transaccin
Nombre del dato
Valor antiguo del dato
Valor nuevo del dato
y tambin almacena <Ti inicia> y <Ti confirma> que controla el inicio de la

escritura y el fin exitoso.
Nunca podemos permitir que se actualice un dato en una transaccin, antes de
registrarlo en la bitcora, por lo tanto se requieren dos escrituras fsicas por cada
escritura lgica.
El algoritmo de recuperacin emplea dos procedimientos: deshacer (Ti) y rehacer
(Ti), las cuales deben ser idempotentes para garantizar un comportamiento correcto.
La transaccin Ti se deshace, si la bitcora contiene <Ti inicia> y no
contiene <Ti confirma>.
Si contiene las dos, la transaccin debe rehacerse.
13.9.3 Puntosdeverificacin(checkpoints)
Cuando ocurre un fallo, se necesita consultar la bitcora, para ver que
transacciones rehacer, y cuales deshacer, pero en un principio hay que examinarla
toda. Esto tiene dos desventajas:
1. El proceso de bsqueda consume mucho tiempo.
2. La mayor parte de las transacciones que deben rehacerse ya
actualizaron los datos que hay que modificar.
Para reducir gastos extra se introduce el concepto de checkpoint, que realiza la
secuencia de acciones siguiente:
1. Grabar en almacenamiento estable los registros de la bitcora que
estn en almacenamiento voltil.
2. Grabar en el almacenamiento estable todos los datos modificados que
residen en almacenamiento voltil.
158
FINGUDELAR
3. Grabar un registro de bitcora <checkpoint> en almacenamiento
estable.
Cuando ocurra un fallo, vamos a rehacer y deshacer las transacciones que fueron
hechas despus del ltimo checkpoint.
13.9.4 Transaccionesatmicasconcurrentes
Las transacciones deben ser atmicas, y esto se realiza ejecutando cada
transaccin dentro de una seccin crtica, usando semforos. Esto soluciona el
problema pero es demasiado restrictivo, puesto que hay transacciones que si se
pueden ejecutar concurrentemente.
T0
leer(A)
escribir(A)
Consideramos un sistema con dos datos A y B, y
las transacciones T0 y T1 que leen y escriben. Si las leer(B)
ejecutamos atmicamente sera
escribir(B)
13.9.4.1 Seriabilidad
leer(A)
escribir(A)
leer(B)
escribir(B)
Este plan de ejecucin atmica se lo denomina

plan serial. En este caso la operacin escribir(A)
de T0 est en conflicto con la operacin leer(A) de
T1, en cambio, no lo est con la leer(B) de T1.
Cuando dos operaciones no estn en conflicto se
las puede intercambiar, creando un nuevo plan.
Obtenemos:
T0
leer(A)
escribir (A)
T1
T1
leer (A)
escribir (A)
leer (B)
escribir (B)
leer (B)
escribir (B)
13.9.4.2 Protocolodecerraduras
Una forma de asegurar la seriabilidad, es asociar a cada dato una cerradura, y
cada transaccin se debe regir por un protocolo de cerraduras. Hay dos modos:
Compartido: Ti Puede leer el dato pero no escribirlo.
Exclusivo: Ti puede leer y escribir el dato.
En este caso, no aseguramos la seriabilidad. Un protocolo que si lo hace es el
protocolo de cerraduras de dos fases, pero en este caso no aseguro la ausencia de
deadlock. Las fases son:
Fase de crecimiento: Una transaccin puede obtener cerraduras
pero no liberar.
159
FINGUDELAR
Fase de encogimiento: Una transaccin puede liberar cerraduras,

pero no obtener.
13.9.4.3 Protocolosbasadosenmarcasdetiempo
En los protocolos anteriores, el orden de cada par de transacciones en conflicto,
se determina en tiempo de ejecucin. Otro mtodo para mantener la seriabilidad
consiste en escoger con anticipacin un ordenamiento.
El ordenamiento por marcas de tiempo, asigna a cada transaccin una marca de
tiempo antes de que se ejecute, y si ms adelante entra otra transaccin, a la ltima
se le asigna una marca de tiempo mayor. Para hacerlo hay dos mtodos:
Utilizar el reloj del sistema como marca de tiempo. Este mtodo no
funciona en procesadores que no comparten el mismo reloj.
Utilizar un contador lgico.
A cada dato Q se le asignan dos valores de marca de tiempo:
MT-E(Q): Marca la ltima escritura de Q.
MT-L(Q): Marca la ltima lectura de Q.
El protocolo es:
Ti solicita leer(Q):
Si TS(Ti) (marca de tiempo asignada a Ti) < MT-E(Q): Ti necesita
leer un valor de Q que ya se sobrescribi, por lo tanto la lectura se
rechaza y Ti se revierte.
Si TS(Ti)
MT-E(Q): Se ejecuta leer(Q) y se asigna MT-L(Q) = max
{MT-L(Q), TS(Ti)}
Ti solicita escribir(Q):
Si TS(Ti) < MT-L(Q): El valor de Q que Ti est produciendo se
necesit previamente, por lo tanto escribir(Q) se rechaza y Ti se
revierte.
Si TS(Ti) < MT-E(Q): Ti est intentando escribir un valor obsoleto de
Q, por lo tanto escribir(Q) se rechaza y Ti se revierte.
En caso contrario, escribir(Q) se ejecuta.
160
FINGUDELAR
14 Ada
Originalmente diseado para aplicaciones militares, Ada es un lenguaje de
propsito general que puede ser usado para cualquier problema. Tiene una
estructura de bloque y un mecanismo de tipo de datos igual que Pascal, aunque con
extensiones para aplicaciones de tiempo real y distribuidas.
14.1 Unpocodehistoria
En los 70's hubo inters del Departamento de Defensa de E.U.A. para desarrollar
un lenguaje sencillo para usar en sistemas de tiempo real incrustados.
Pascal fue el punto de partida para el diseo de ADA pero el lenguaje resultante
es muy diferente en muchos aspectos. Ada es ms extenso, ms complejo, permite
ejecucin concurrente, control en tiempo real de la ejecucin, manejo de
excepciones y tipos de datos abstractos.
14.1.1 Pequeadescripcindellenguaje
Ada esta hecho para soportar la construccin de grandes programas. Un programa
en Ada esta ordinariamente diseado como una coleccin de grandes componentes
de software llamados "Packages" cada uno representando un tipo de dato abstracto
o un conjunto de objetos de datos compartidos entre subprogramas. Un programa en
Ada consiste de un procedimiento singular que sirve como programa principal, el cual
declara variables, y ejecuta sentencias, incluyendo llamadas a otros subprogramas.
Un programa Ada puede envolver tareas que se ejecuten concurrentemente, si esto
pasa entonces estas son inicializadas directamente por el programa principal y
forman el nivel superior de la estructura del programa.
Ada provee un gran nmero de tipos de datos, incluyendo enteros, reales,
enumeraciones, booleanos, arreglos, records, cadena de caracteres y apuntadores.
Abstraccin y encapsulacin de tipos de datos y operaciones definidas por el usuario
son provistas por la caracterstica de "package". El control de secuencia dentro de un
subprograma utiliza expresiones y estructuras de control similares a Pascal. La
estructura de control de datos de Ada utiliza la organizacin de estructura de bloque
esttica como en Pascal y adems el lenguaje prosee llamadas a referencias no
estticas. Desde que los programas pueden ejecutar tareas concurrentemente, estos
pueden correr subprogramas independientemente uno del otro.
14.2 Tiposdedatosprimitivos
14.2.1 VariablesyConstantes
Cualquier objeto de datos puede ser definido como variable o como

constante.
Cualquier declaracin que empiece con la palabra constant es una
constante y se deber asignar un valor el cual no se podr cambiar en
la ejecucin.
Si se omite la palabra constant la misma declaracin define un tipo de
dato variable, a la cual se le debe asignar un valor inicial y el cual se
podr cambiar en la ejecucin.
Ejemplo:
161
FINGUDELAR
MaxSize constant integer := 500;
CurrentSize integer := 0;
14.3 TiposdeDatosNumricos
Enteros, punto-flotante, punto-fijo y los tipos de datos bsicos.

Declaraciones son similares que en Pascal usando los atributos range
(para enteros) y digits (para flotantes) los cuales especifican el rango
de valores que podra tomar el tipo de dato.
Ejemplo:
type DayOfYear is range 1..366;
-- un valor entero de 1 a 366
MyBirhtday: DayOfYear := 219;
-- MyBirthday inicializada a 219
type Result is digits 7
-- flotante de 7 digitos
Anwer: Result :=3.17;
-- varible de 7 digitos.
Los tipos Integer y float estn predefinidos en el paquete estndar como:
type integer is range implementation defined;
type float is digits implementation defined;
14.3.1 Enumeraciones
Enumeraciones deben de definirse usando un estilo como Pascal de definicin
e implementacin.
Ejemplo:
type class is (Fresh, Soph, Junior, Senior);
La representacin en la ejecucin usa el nmero de posicin para cada valor de la
literal, empezando con 0 para el primer valor listado, 1 para el segundo etc.
14.3.2 TiposCaracteryBoleano
Estas son definidas en el paquete estndar para ser enumeraciones

especficas.
14.3.3 TipodeDatoApuntador
Un tipo apuntador llamado access, junto con una funcin primitiva new,
crean un nuevo objeto y regresa un apuntador a este, el cual debe ser
asignado a una variable del tipo access.
Una variable no pude ser directamente declarada como access en vez de
esto se hace lo siguiente:
type acces_typename is access typename;
y la variable deber ser declarada como un tipo de dato definido.

Todas las variables del tipo access tienen el valor NULL por default.
162
FINGUDELAR
Un bloque de almacenamiento puede ser solicitado para cualquier tipo de

dato usando la sentencia:
for acces_typename use expresion;
donde expresin es el tamao del bloque a pedir.
14.4 Tipodedatosestructurados
14.4.1 VectoresyArreglos
Un arreglo de objetos puede ser declarado con cualquier nmero de

dimensiones, cualquier rango y cualquier tipo de componente.
Ejemplo:
Table: array (1..10, 1..20) of float;
crea una matriz de 10 X 20 de nmeros reales;

Definicin de tipos puede ser utilizada para crear clases de cualquier tipo de
arreglo de objetos.
Ejemplo:
type Matrix is array (integer range <>,integer range <>) of float;
donde los < > indican un campo que se debe llenar.
Inicializacin: cualquier arreglo deber de ser inicializado en su declaracin.
14.4.2 CadenadeCaracteres
Las cadenas de caracteres son tratadas como un tipo de vector predefinido

usando otros dos tipos predefinidos positive (enteros) y character
(enumerando los caracteres definidos en el paquete estandar).
type string array (positive range <>) of character;
Ejemplo:
MyString : string(1..30);
14.4.3 TipodeDatoArchivo
Archivos y operaciones de entrada-salida son definidos como tipos de datos

abstractos, usando paquetes predefinidos.
El programador de Ada mira los archivos como tipo de datos que en su
estructura interna estn ocultos por ser encapsulados con los paquetes
estndares.
Existen diferentes tipos de archivos (texto,enteros,reales,etc..) cada paquete
tiene su propio tipo de archivo ejemplo en TEXT_IO hay un tipo para archivos
secuenciales o solo texto en FLOAT_IO hay un tipo de dato archivo para
flotantes etc.
163
FINGUDELAR
14.4.4 TipodeDatoDefinidoPorElUsuario
Los tipos de datos record en Ada son similares que en Pascal.

En Ada a diferencia de Pascal un objeto record debe de ser definido primero
usando una definicin de tipo, para definir la estructura de record y despus
dando la declaracin de la variable usando el tipo de nombre.
Ejemplo:
type Birthday is
record
Month: string (1..3) := "jun";
Day: integer range 1..31 := 17;
Year: integer range 1950..2050 := 1960;
end record
cada variable del tipo Birthday esta inicializada a "jun" 17 1960.
14.5 Controldesecuencia
La ejecucin de Ada esta orientada a sentencias como FORTRAN y Pascal.
14.5.1 Expresiones
Expresiones en Ada permiten primitivas y funciones definidas para ser

combinadas en secuencias de manera usual.
Notacin infija es usada para la aritmtica binaria, relacional y operaciones
boleanas.
Notacin prefija es usada para operaciones unarias. (+,-, y NOT), los
parntesis deben de utilizarse para agrupar operaciones y la precedencia es
la misma que en Pascal.
14.5.2 Sentencias
Las estructuras de secuencias de control de sentencias son las usuales

sentencias condicionales (if y case) y las sentencias de iteracin (loop).
Todas las sentencias de control terminan con las sentencia end seguida con la
palabra de dicha sentencia ejem: end if, end loop.
Asignacion: La asignacin es similar que en Pascal. La asignacin completa de un

grupo de valores a una variable record puede ser posible.
Ejemplo:
MyDay := ("SEP",12,1975);
MyDay := (Year => 1975, Month =>"SEP", Day => 12);
14.6 Sentenciascondicionales
14.6.1 SentenciaIf
La sentencia if tiene la siguiente forma:
164
FINGUDELAR
if boolena expresion then
- secuencias de sentencias
elsif boolean expresion then
- secuencia de sentencias
elsif boolean expresion then
...
else
end if
14.6.2 SentenciaCASE
La forma general de case es:

case expresion is
when choice | ...| choice => secuencia de sentencias;
when choice | ...| choice => secuencia de sentencias;
...
when others => secuencia de sentencias;
end case;
Cada choice indica o uno o varios rangos posibles de valores para la expresin al
principio de la sentencia.
Ejemplo:
case GradeLevel is
when Fresh => sentencias;
when Soph | Junior => secuencias;
when Senior => secuencias;
end case;
14.7 Sentenciasdeiteracin
14.7.1 SentenciaLoop
La sentencia bsica de iteracin tiene la siguiente forma.

loop
end loop
La forma de terminar una sentencia de iteracin loop se hace explcitamente

con las sentencias exit, goto o return.
Sentencias controladas pueden ser creadas con las sentencias while y for.
while boolean expresion
...
con for hay dos formas.
165
FINGUDELAR
for variable name in discrete_range;
for variable name in reverse discrete_range;
14.8 Subprogramasymanejodealmacenamiento
Procedimientos, funciones y tareas son los tres tipos de subprogramas que
Ada maneja.
14.8.1 FuncionesyProcedimientos
Un procedimiento o funcin tiene la forma de una especificacin:

procedure procname(formal-parameters) is ...
function functioname(formal-parameters) return result_type
is
seguida por un cuerpo como sigue :
- secuencia de declaraciones
begin
-secuencia de sentencias
exception
- manejadores de excepciones
end
Los subprogramas pueden ser recursivos. La salida normal de un

procedimiento o tarea es con la ejecucin de return;
En el enunciado formal-parameters deben de ir los tipos de datos con su
nombre y su forma de transmisin para ser usado.
Excepciones: Al final de cada unidad de programa debe de especificarse un
manejador de excepciones. Existen varias excepciones predefinidas en los
paquetes estndares, todas las dems son declaradas usando la siguiente
sentencia:
exceptionname: exception
Un manejador de excepciones empieza con el nombre de la excepcin que

este maneja, seguida con una secuencia de sentencias que toman la accin
apropiada para manejar dicha excepcin.
exception
when exception_name | ... | exception_name
=> secuencia de sentenecias
...
when others
=> secuencia de sentencias
donde cada secuencia de sentencias deber manejar una o mas excepciones
nombradas.
Tareas: Una tarea es un subprograma que puede ejecutarse concurrentemente con
otras tareas.
La definicin de una tarea tiene una forma general, tiene una especificacin
que permite a otras tareas comunicarse entre si y un cuerpo de
166
FINGUDELAR
implementacin. Usando un tipo de tarea, mltiples tareas pueden ser
creadas con una definicin singular.
task taskname is
-declaraciones de entrada
end
task body taskname is
-secuencia de declaraciones
begin
-secuencia de setencias
exception
-manejador de excepciones
end;
14.9 Abstraccinyencapsulamiento
14.9.1 Paquetes
La definicin de un paquete tiene dos partes una especificacin y un

cuerpo.La especificacin contiene la informacin necesaria para la correcta
utilizacin del paquete; el cuerpo proveee la encapsulacin de variables y
subprogramas que son llamados desde afuera.
La parte visible de un paquete (todo lo que procede a la palabra private)
define que es lo que el usuario final de el paquete puede usar en un
programa.
package packagename is
-declaracin de variables
private
-definicin completa de datos privados
end;
packages body packagename is
-definiciones de objetos y subprogramas
definidos arriba
begin
-sentencias para inicializar el paquete cuando es por
primera vez instanciado
exception
- manejador de excepciones
end;
14.10 HolaMundo!!
% vi Hola.ada
with Text_IO; use Text_IO;
procedure Doit is
procedure Hola(x: in integer) is
begin
if x=2 then
put("Hola Mundito");
else put ("Adios Mundito");
end if
end Hola;
167
FINGUDELAR
y: integer;
begin
y:=2;
Hola(y);
end Doit;
% ada Hola.ada
%Hola
Hola Mundito
14.11 Ejemplosdeprocedimientos:
Procedure Algo ()
// Los task son como procedimientos
TASK
end
Begin
end Algo
TASK Uno is
entry ident + 1 () Pueden tener o no parmetros
end Uno Puede tener ms citas (entrys)
TASK body Uno is
// Aceptar citas
Accept ident1 ()
sentencias
end ident1
end Uno
Accept ident1 (A: IN integer; B: OUT String; C: INOUT integer)
end Accept
// Invocacin
Uno Ident1 (2, P, R)
14.11.1 AliciaBernardo:
TASK Patio
ENTRY Pedir
ENTRY Devolver
END
TASK BODY Patio
BEGIN
loop
Accept Pedir;
Accept Devolver;
end loop
END Patio
168
FINGUDELAR
14.11.2 Factorial:
PROCEDURE Factorial IS
PROCEDURE Print (I: IN integer) is separate; Compilado en
forma separada
PROCEDURE Get (I: OUT integer) is separate;
n, x, y : integer;
TASK Type Semifact is
entry Num (I: IN integer)
entry Resultado (I: OUT integer)
END Semifact
TASK BODY Semifact is separate;
A, B : Semifact;
BEGIN
Get (N) Obtengo el nmero del teclado
A.Num (N)
B.Num (N-1)
A.Resultado (x)
B.Resultado (y)
Print (x * y)
END
TASK BODY Semifact is
u: integer;
BEGIN
Accept Num (I: IN integer)
u:= I
end Num
Semifactorial (u) Hay que especificar este procedimiento
aparte
Accept Resultado (I: OUT integer)
I = u;
end Resultado
end Semifact
14.11.3 ProductorConsumidor:
TASK Buff_Simple is
entry Leer (I: OUT character)
entry Escribir (I: IN character)
end Buff_Simple
TASK BODY Buff_Simple is
n: integer
x: character
BEGIN
loop
Accept Escribir (A: IN character) do
x:= A;
end Escribir
Accept Leer (A: OUT character) do
A:= x;
end Leer
169
FINGUDELAR
end loop
end Buff_Simple
TASK Productor;
TASK BODY Productor is
c1: character
BEGIN
loop
Produce (c1)
Buff_Simple.Escribir(c1)
end loop
end Productor
TASK Consumidor;
TASK BODY Consumidor is
c1: character
BEGIN
loop
Buff_Simple.leer (c1)
Consumir(c1)
end loop
end Consumidor
SELECT Espero por las dos, sino hay solicitud, queda bloqueado
esperando
Accept Leer (A: OUT character) do
A:= x
end Leer
// Puede haber muchas OR
OR Accept Escribir (A: IN character) do

x:= A
end Escribir
Select:
El select primero evala las condiciones, y para las que dio TRUE se queda
esperando.
Select
[when cond1 ]
Accept entrada1
end Accept
OR
[when cond2 ]
Accept entrada2
end Accept
170
FINGUDELAR
ELSE (*)
end select
(*) Tambin puedo poner OR [when condn = x] delay s, y espera s segundos.
14.11.4 Semforo:
TASK type Semaforo is
entry Init (I: IN integer);
entry p;
entry v;
end semaforo
TASK body semaforo is
N: integer
begin
accept Init (I : IN integer) do
N:= I;
end accept
loop
select
when N>0 =>
accept p;
N = N 1;
or
accept v;
N = N + 1;
end select
end loop
end semaforo
14.11.5 Productorconsumidor:
TASK Buff_finito is
entry sacar (d:OUT dato)
entry agregar (d: IN dato)
end Buff_finito
TASK body buff_finito is
max : constant := 20
buff: array (0..max) of dato
ocupado, in, out: integer range 0..max:=0
begin
loop
select
when ocupado < max =>
accept agregar (d: IN dato) do
buff (in):= d
end agregar
ocupado:= ocupado + 1;
in:= (in + 1) mod max;
or
when ocupado > 0 =>
accept sacar (d: OUT dato) do
171
FINGUDELAR
end select
end loop
end buff_finito
d:= buff (out)

end sacar
ocupado:= ocupado 1;
out:= (out + 1) mod max;
En ada, adems de poder declarar arrays de tareas, puedo declarar arrays de

entradas.
entry entrada: array (0..100) equivale a:
entry entrada (0)
entry entrada (1)
entry entrada (100)
172
FINGUDELAR
15 Bloqueosmutuos(Deadlock)
Cuando un proceso A solicita un recurso que est ocupado por otro proceso B,
pasa a un estado de espera. Si B tambin est en estado de espera, esperando un
recurso que tiene A, los dos procesos estn en deadlock.
15.1 Modelodelsistema
Un sistema consiste en un nmero finito de recursos que deben distribuirse entre
varios procesos que compiten. Los recursos se dividen en varios tipos, cada uno de
los cuales consiste en cierta cantidad de ejemplares idnticos (unidades de recursos).
Si un proceso solicita un ejemplar de un tipo de recurso, la asignacin de cualquier
ejemplar del tipo, satisface la solicitud.
Un proceso solo puede utilizar un recurso, siguiendo esta secuencia:
1. Solicitud: Si la solicitud no puede atenderse de inmediato, el proceso debe
esperar.
2. Uso: El proceso opera con el recurso.
3. Liberacin: El proceso libera el recurso.
La solicitud y liberacin, son llamadas al SO. Una tabla del sistema registra si cada
recurso est libre o asignado. Si un proceso solicita un recurso ocupado, se lo coloca
en la cola de procesos que esperan ese recurso.
Los recursos pueden ser fsicos (impresoras, memoria, ciclos de CPU), o lgicos
(archivos, semforos, monitores).
15.2 Caracterizacindebloqueosmutuos
En un bloque mutuo, los procesos nunca terminan su ejecucin y los recursos del
SO quedan acaparados.
15.2.1 Condicionesnecesarias
Ocurre bloqueo mutuo si se cumplen simultneamente las cuatro condiciones
siguientes:
1. Mutua exclusin: Al menos un recurso debe adquirirse de forma no
compartida, o sea, solo puede usarlo un proceso a la vez. Si otro
proceso lo solicita, debe esperar.
2. Retener y esperar: Debe existir un proceso que haya adquirido al
menos un recurso y est esperando para adquirir recursos adicionales,
que ya fueron otorgados a otros procesos.
3. No expropiacin: Los recursos no se pueden arrebatar, es decir, la
liberacin es voluntaria por parte del proceso que adquiri el recurso.
4. Espera circular: Debe existir un conjunto {P0, P1, , Pn} de procesos
en espera tal que P0 espera un recurso adquirido por P1, P1 espera uno
adquirido por P2, , Pn espera uno adquirido por P0.
Explique muy brevemente las condiciones necesarias para la existencia del bloqueo mutuo
(Deadlock) en sistemas donde exista solo una instancia de cada tipo de recurso. Cules
condiciones debera agregar para que adems de necesarias sean suficientes?
Respuesta:
Las condiciones son (por ms detalles ver libro):
173
FINGUDELAR
*Exclusin mutua
*Retencin y espera
*No apropiacin
*Espera circular
Si hay una sola instancia de cada tipo de recurso estas condiciones son necesarias y
suficientes.
Describa las cuatro condiciones que, si ocurren simultneamente, pueden generar un deadlock.
15.2.2 Grafodeasignacinderecursos
Los bloqueos mutuos se pueden describir con mayor precisin en trminos del
grafo de asignacin de recursos del sistema. Los vrtices son P y R (procesos y
recursos). Una arista de P a R indica que el proceso espera el recurso, y una de R a P,
indica que se asign el recurso al proceso.
P se identifica con un crculo, R con un cuadrado, y puntos adentro, donde cada
punto es una unidad de recurso.
R1
R2
P1
P2
P3
R3
R4
Casos:
No contiene ciclos: No existe bloqueo mutuo.

Si contiene ciclos:
Si los recursos solo tienen un nico ejemplar, hay bloqueo mutuo
Si hay varios ejemplares, no necesariamente hay bloqueo.
15.3 Mtodosparamanejarbloqueosmutuos
Usar un protocolo que asegure que el SO nunca llegar a deadlock

El sistema entra en un bloqueo mutuo y se recupera
Desentenderse del problema y hacer como si nunca ocurrieran
bloqueos (es lo que hacen la mayor parte de los SO)
Prevencin de bloqueos mutuos: Mtodos que garantizan que no se cumpla

por lo menos una de las condiciones necesarias.
Evitacin de bloqueos mutuos: Requiere proporcionar al SO informacin
anticipada acerca de los recursos que el proceso va a solicitar y usar. Con esa
informacin el SO decide si el proceso va a esperar o no.
Cuando el SO no cuenta con ninguno de los dos algoritmos anteriores, pueden
ocurrir bloqueos, los cuales deben ser detectados y revertidos, de otra forma, el SO
se deteriora hasta dejar de funcionar.
174
FINGUDELAR
Examen marzo 2003:
En el contexto de deadlock, explique la diferencia entre:
prevencin
deteccin con recuperacin del mismo
Respuesta:
La prevencin consiste en asegurarse de que al menos una de las condiciones necesarias de
deadlock no se cumpla. Un ejemplo es prevenir una espera circular imponiendo una ordenacin
total de todos los tipos de recursos, siguiendo un orden de numeracin ascendente, y forzando
que para obtener unidades de un mismo recurso sea emitida una nica solicitud.
La deteccin y recuperacin no evita el deadlock, sino que examina el sistema para determinar si
ha ocurrido, para recuperarse del mismo, ya sea terminando uno o ms procesos involucrados, o
expropiando recursos.
15.4 Evitacindebloqueosmutuos
Podemos tratar de que no se cumpla alguna de las condiciones necesarias para
bloqueos mutuos.
15.4.1 Mutuaexclusin
Se debe cumplir mutua exclusin para recursos no compartibles. Por ejemplo, dos
o ms procesos no pueden compartir una impresora, pero s pueden compartir un
archivo de solo lectura.
15.4.2 Reteneryesperar
Siempre que un proceso solicite un recurso, no debe retener otro. Una forma es
que el proceso solicite y reciba todos los recursos antes de iniciar su ejecucin. Otra
forma es que pueda solicitar recursos solo cuando no tiene ninguno, para solicitar
nuevos, suelto los que tengo.
Por ejemplo si tengo un proceso que copia datos de una cinta al disco, y luego
imprime los resultados en una impresora, con el primer mtodo, solicito la impresora
al comienzo, para solo usarla al final, y mientras tanto, nadie la puede usar. Con el
segundo mtodo, solicito solo la cinta y el archivo de disco, y cuando termino con los
dos, solicito nuevamente el archivo de disco y la impresora.
Las desventajas de los dos protocolos son que si mi proceso utiliza recursos que
son muy solicitados, podra esperar indefinidamente a que todos se liberen para
usarlos (inanicin).
15.4.3 Noexpropiacin
Si un proceso tiene recursos solicitados, y solicita otro, que no se le puede asignar
de inmediato, entonces todos los recursos que tiene se liberarn implcitamente. Es
aplicable solo a recursos cuyo estado es fcil de guardar.
15.4.4 Esperacircular
Se impone un ordenamiento total de los recursos y se exige que cada proceso los
solicite en orden creciente de enumeracin. Cuando se requieren varios ejemplares
de un mismo recurso, se debe emitir una sola solicitud que los incluya a todos. Para
pedir recursos con nmero mayor, debo liberar los que ya tengo.
Examen marzo 2003:
Qu medidas de prevencin de deadlock conoce?
Respuesta:
- Evitar retencin y espera,
o Forzando a que los procesos soliciten todos sus recursos y le
175
FINGUDELAR
sean asignados antes de que comience su ejecucin.
o O evitando que los procesos soliciten recursos slo cuando no
tienen ninguno asignado.
- Evitar no expropiacin,
o Forzando a que si un proceso que retiene algn recurso
solicita otro que no se le puede asignar de inmediato,
entonces se le expropian todos los que ya tiene.
o O si un proceso (A) solicita un recurso y no est disponible,
sino que est asignado a otro proceso (B) que est esperando
recursos adicionales, entonces se le quita y se le asigna a
(A).
- Evitar la condicin de mutua exclusin,
o por ejemplo utilizando un spooler para el acceso a una
impresora.
- Evitar espera circular,
o La mencionada en (a).
o O exigir que cuando un proceso solicite un ejemplar
recurso libere todo otro recurso que sea mayor en
ordenamiento definido en (a).
Examen marzo 2003:
Explique las dificultades asociadas a la expropiacin de recursos.
Respuesta:
- Debe haber un critero apropiado para seleccionar el proceso al que se le expropiar.
- Debe determinarse el orden de expropiacin para minimizar el costo.
- Es difcil hacer retroceder el proceso al que se le expropia hasta un estado seguro y reiniciarlo.
Casi siempre debe abortarse, o el sistema debe conservar ms informacin de estado de los
procesos.
- Debe asegurarse que los recursos que se expropien no sean siempre los de un mismo proceso,
posponiendo su terminacin en forma indefinida.
Describa las 4 (cuatro) condiciones necesarias que un sistema operativo debe garantizar para
prevenirse de que ocurra deadlock.
Respuesta:
Mutua exclusin: al menos un recurso debe adquirirse de modo que no pueda compartirse; es
decir, slo un proceso a la vez podr usar ese recurso. Si otro proceso solicita ese recurso, el
proceso solicitante deber esperar a que se haya liberado el recurso.
Retener y esperar: debe existir un proceso que haya adquirido al menos un recurso y est
esperando para adquirir recursos adicionales que ya han sido asignados a otros procesos.
No expropiacin: los recursos no se pueden arrebatar; es decir, la liberacin de un recurso
siempre es voluntaria por parte del proceso que lo adquiri, una vez que ha terminado su tarea.
Espera circular: debe existir un conjunto {P0, P1, ..., Pn} de procesos tal que P0 est esperando
un recurso que fue adquirido por P1, P1 est esperando un recurso que fue adquirido por P2, ...,
Pn-1 est esperando
un recurso que fue adquirido por Pn y Pn est esperando un recurso que fue adquirido por P0.
15.5 Prevencindebloqueosmutuos
La prevencin de bloqueos, disminuye el rendimiento del sistema. Se debe pedir
informacin adicional para saber la forma en que se solicitarn los recursos, y el SO
debe considerar los recursos disponibles, los ya asignados a cada proceso y las
solicitudes y liberaciones futuras de cada proceso para decidir si la solicitud se puede
satisfacer o debe esperar.
Una forma es saber el nmero mximo de recursos de cada tipo que se podra
necesitar. El estado de asignacin de los recursos est definido por el nmero de
recursos disponible y asignado, y las demandas mximas.
15.5.1 Estadoseguro
Un estado es seguro, si el sistema puede asignar recursos a cada proceso en
algn orden, evitando bloqueos. Es seguro si existe una secuencia segura de
176
FINGUDELAR
procesos, si no existe, el estado del sistema es inseguro, pudiendo derivar en
bloqueo mutuo.
La idea es asegurar que el sistema siempre permanecer en un estado seguro, asi
que antes de asignarle cualquier recurso, debo verificarlo.
Ver ejemplo pgina 218 del Silberschatz.
15.5.2 Algoritmodegrafodeasignacinderecursos
Cuando tenemos un solo ejemplar de cada tipo de recursos, podemos usar una
variante del grafo de asignacin de recursos.
Adems de la arista de solicitud y la de asignacin, tenemos la de reserva. Va
dirigida de P a R e indica que P podra solicitar R en un instante futuro. Se representa
con una lnea discontinua.
Los recursos deben reservarse a priori en el sistema, o sea que antes de iniciar la
ejecucin, ya deben aparecer todas las aristas de reserva.
La solicitud de un recurso solo puede ser satisfecha si la conversin de una arista
discontinua en continua (asignacin de recurso) no da lugar a ciclos.
15.5.3 Algoritmodelbanquero
El grafo de asignacin, no puede aplicarse a un sistema de asignacin de recursos
con mltiples ejemplares de cada recurso.
Cuando un proceso entra al sistema, debe declarar el nmero mximo de
ejemplares de cada tipo de recursos que podra necesitar, el cual no puede exceder
el total de recursos del sistema.
Cuando el usuario solicita un conjunto de recursos, el sistema debe determinar si
la asignacin no lo deja en un estado inseguro.
Hay que mantener varias estructuras de datos para implementar este algoritmo.
Ellas son:
Disponible: Un vector de longitud m indica el nmero de recursos
disponibles de cada tipo. Disponible [j] = k, hay k ejemplares
disponibles del recurso Rj.
Mx.: Una matriz n x m define la demanda mxima de cada proceso.
Mx. [i, j] = k, el proceso i puede solicitar como mximo k unidades del
recurso j.
Asignacin: Una matriz n x m define el nmero de recursos que se
han asignado actualmente a cada proceso. Asignacin [i, j] = k. El
proceso i tiene asignados actualmente k ejemplares del recurso j.
Necesidad: Una matriz n x m indica los recursos que todava le hacen
falta a cada proceso.
Las estructuras de datos anteriores varan en el tiempo, tanto en tamao como en
valor.
Examen abril 2003:
En el contexto del algoritmo del banquero:
a) Qu ventajas y desventajas presenta ?
b) Considere la siguiente situacin:
Asignado
Mximo
A B C D
A B C D
P0
0 0 1 2
0 0 1 2
P1
1 0 0 0
1 7 5 0
P2
1 3 5 4
2 3 5 6
P3
0 6 3 2
0 6 5 2
P4
0 0 1 4
0 6 5 6
Disponible
A B C D
1 5 2 0
177
FINGUDELAR
1. Est el sistema en estado seguro ? Justifique su respuesta.
2. Si para P1 llega el requerimiento (0,4,2,0), puede ser satisfecho inmediatamente ?
Justifique su respuesta
Respuesta:
b.1) Verificamos si el sistema esta en un estado seguro aplicando el algoritmo
Trabajo = (1,5,2,0)
Fin = (false, false, false, false, false)
Necesidad = Mximo Asignado =
A B C D
P0 0 0 0 0
P1 0 7 5 0
P2 1 0 0 2
P3 0 0 2 0
P4 0 6 4 2
Iniciamos el algoritmo, buscando una secuencia que muestre si el sistema esta en
estado seguro o no:
1.- Elegimos P0, Necesidad0 <= Trabajo
Trabajo = (1,5,2,0) + (0,0,1,2) = (1,5,3,2)
Fin = (true, false, false, false, false)
Trabajo = (1,5,3,2) + (1,3,5,4) = (2,8,8,6)
Fin = (true, false, true, false, false)
Trabajo = (2,8,8,6) + (0,6,3,2) = (2,14,11,8)
Fin = (true, false, true, true, false)
Trabajo = (2,14,11,8) + (0,0,1,4) = (2,14,12,12)
Fin = (true, false, true, true, true)
Trabajo = (2,14,12,12) + (1,0,0,0) = (3,14,12,12)
Fin = (true, true, true, true, true)
Como Fin[i] = true para toda i, entonces el sistema esta en estado seguro. La
secuencia obtenida es <P0, P2, P3, P4, P1>
b.2) Verificamos si el sistema esta en un estado seguro luego de hacer la
asignacin pedida para P1, (0,4,2,0). En este caso la situacin es:
Trabajo = (1,5,2,0)
Fin = (false, false, false, false, false)
Necesidad = Mximo Asignado =
A B C D
P0 0 0 0 0
P1 0 4 7 0
P2 1 0 0 2
P3 0 0 2 0
P4 0 6 4 2
Basta repetir el algoritmo anterior, dejando P1 para el final nuevamente. En
este caso tambin se cumple que Necesidad1 <= Trabajo por lo que llegamos
nuevamente a la misma secuencia valida. El sistema por tanto tambin esta en
estado seguro.
Qu puede decir de las siguientes situaciones viendo los estados de las variables durante la
ejecucin del algoritmo del banquero?. Justifique la respuesta muy brevemente.
Caso1:
Matriz Asignacin
2
1
0
1
2
0
0
2
0
Solicitud proceso 2
0
1
1
Matriz Disponibilidad:
1
2
1
Matriz Mximos:
2
1
1
1
4
1
0
4
0
Respuesta:
178
FINGUDELAR
La solicitud puede ser satisfecha manteniendo el sistema en un estado seguro.
Caso 2: Idem caso 1, pero la solicitud para el proceso 2 es :
1
0
1
El proceso 2 no puede realizar esa solicitud pues excedera su mximo
predefinido.
Utilizando el algoritmo del banquero, y dada la siguiente situacin de procesos y recursos
Asignacin
Max
Disponible
---------------------------ABCD
ABCD
ABCD
P0
0012
0012
1520
P1
1000
1750
P2
1345
2356
P3
0632
0652
P4
0014
0656
determine si el sistema est en estado seguro, y en caso afirmativo, si al llegar un solicitud del
proceso P1 de (0,4,2,0), sta puede ser satisfecha de inmediato. Justifique su/s respuesta/s.
Respuesta:
Primero establecemos las matrices Necesidad (Max Asignacin), Trabajo = Disponible, y Fin = F
para todo proceso
Necesidad
Trabajo
-----------------A
B
C
D
A
B C
D
P0 0
0
0
0
1
5 2
0
P1 0
7
5
0
P2 1
0
1
1
P3 0
0
2
0
P4 0
6
4
2
Fin
--F
F
F
F
F
Busco secuencia segura (hay ms de una, aqu se muestra una)
P0 [(0,0,0,0) < (1,5,2,0)]
Trabajo queda en (0,0,1,2) + (1,5,2,0) = (1,5,3,2)
Fin en (T,F,F,F,F)
P2 [(1,0,1,1) < (1,5,3,2)]
Trabajo queda en (1,3,4,5) + (1,5,3,2) = (2,8,7,7)
Fin en (T,F,T,F,F)
P1 [(0,7,5,0) < (2,8,7,7)]
Trabajo queda en (1,0,0,0) + (2,8,7,7) = (2,15,12,7)
Fin en (T,T,T,F,F)
P3 [(0,0,2,0) < (2,15,12,7)]
Trabajo queda en (0,6,3,2) + (2,15,12,7) = (2,21,15,9)
Fin en (T,T,T,T,F)
P4 [(0,6,4,2) < (2,21,15,9)]
Trabajo queda en (0,0,1,4) + (2,21,15,9) = (2,21,16,15)
Fin en (T,T,T,T,T)
Existe al menos una secuencia segura (<P0,P2,P1,P3,P4>), por lo que el sistema
est en estado seguro.
Con la solicitud del proceso P1 de (0,4,2,0), el estado queda en:
Asignacin
Necesidad
---------------------A
B
C
D
A
B
c
D
P0 0
0
1
2
P0 0
0
0
0
P1 1
4
2
0
P1 0
3
3
0
P2 1
3
4
5
P2 1
0
1
1
P3 0
6
3
2
P3 0
0
2
0
P4 0
0
1
4
P4 0
6
4
2
Disponible
Fin
------------1
1
0
0
F
F
F
F F
Trabajo
--------
179
FINGUDELAR
1
1
0
0
Busco secuencia segura
P0 [(0,0,0,0) < (1,1,0,0)]
Trabajo queda en (0,0,1,2) + (1,1,0,0) = (1,1,1,2)
Fin en (T,F,F,F,F)
P2 [(1,0,1,1) < (1,1,1,2)]
Trabajo queda en (1,3,4,5) + (1,1,1,2) = (2,4,5,7)
Fin en (T,F,T,F,F)
P1 [(0,3,3,0) < (2,4,5,7)]
Trabajo queda en (1,4,2,0) + (2,4,5,7) = (3,8,7,7)
Fin en (T,T,T,F,F)
P3 [(0,0,2,0) < (3,8,7,7)]
Trabajo queda en (0,6,3,2) + (3,8,7,7) = (3,14,10,9)
Fin en (T,T,T,T,F)
P4 [(0,6,4,2) < (3,14,10,9)]
Trabajo queda en (0,0,1,4) + (3,14,10,9) = (3,14,11,13)
Fin en (T,T,T,T,T)
Con esta asignacin, existe al menos una secuencia (<P0,P2,P1,P3,P4>), por lo
que es posible atender esa solicitud.
Aplicando el algoritmo del banquero conteste si el siguiente sistema est o no en un estado
seguro.
Respuesta:
Un estado es seguro si el sistema puede asignar recursos a cada proceso (hasta su mximo) en
algn orden y an as evitar los bloqueos mutuos. Ms formalmente, un sistema est en un
estado seguro solo si existe una secuencia segura. Una secuencia de procesos [P0, P1, ..., Pn] es
una secuencia segura para el estado de asignacin actual si, para cada Pi, los recursos que Pi
todava puede solicitar se pueden satisfacer con los recursos que actualmente estn disponibles
ms los recursos que tienen todos los Pj, donde j < i. En esta situacin, si los recursos que Pi
necesita todava no estn disponibles, Pi podr esperar hasta que todos los Pj hayan terminado.
En ese momento, Pi podr obtener todos los recursos que necesita, llevar a cabo su tarea
designada, liberar los recursos que adquiri y terminar.
Vamos a ver si el sistema est en estado seguro. Aplicando el Algoritmo del banquero.
trabajo0 = (3 1 1 0)
fin0 = (False False False False False)
Elijo P0 (Necesidad(0) trabajo0 : (1 0 1 0) (3 1 1 0)):

trabajo1 = trabajo0 + Asignados(0) = (3 1 1 0) + (1 0 0 3) = (4 1 1 3)
fin1 = (True False False False False)
fin2 = (True False True False False)
fin3 = (True False True True False)
Elijo P4: (Necesidad(4) trabajo3 : (0 6 4 2) (5 10 9 9)):
fin4 = (True False True True True)
fin5 = (True True True True True)
Verificacin:
180
FINGUDELAR
Asignadosini + Disponiblesini = Trabajofin
(3 9 9 13) + (3 1 1 0) = (6 10 10 13)
Entonces existe una secuencia [P0, P3, P1, P4, P2] que es segura.
Entonces es estado seguro y por lo tanto no tiene que haber deadlock.
15.5.4 Algoritmodeseguridad
1. Sean trabajo y fin, vectores con longitud m y n respectivamente. Inicializo:
a. Trabajo:= Disponible
b. Fin[i]:= false
2. Buscar una i tal que:
a. Fin[i]= false
b. Necesidadi
Trabajo
c. Si no existe i, continuar con el paso 4
3. Trabajo:= Trabajo + Asignacini
Fin[i] := true
Ir al paso 2
4. Si Fin[i] = true para toda i, el sistema esta en estado seguro.
15.5.4.1 Algoritmodesolicitudderecursos
Sea Solicitudi el vector de solicitudes del proceso Pi. Si Solicitudi [j] = k, el proceso
Pi quiere k ejemplares del tipo de recursos Rj. Para otorgarlos se siguen los siguientes
pasos:
5. Si Solicitudi < Necesidadi, ir al paso 2, sino indicar error ya que el proceso
excedi su reserva mxima.
6. Si Solicitudi < Disponible, ir al paso 3, sino Pi debe esperar a que los recursos
estn disponibles.
7. El sistema simula haber asignado los recursos al proceso Pi de la forma:
Disponible:= Disponible Solicitudi;
Asignacini:= Asignacini + Solicitudi;
Necesidadi:= Necesidadi Solicitudi;
Si el estado resultante es seguro, la transaccin se lleva a cabo, asignando los
recursos a Pi, sino Pi tendr que esperar, y se restaura el antiguo estado de solicitud
de recursos.
Ver ejemplo 7.5.3.3, pgina 222 del Silberschatz.
15.6 Deteccindebloqueosmutuos
Si el sistema no previene o evita bloqueos mutuos, se puede encontrar con una
situacin de bloqueo. Para ello necesita:
Un algoritmo que examine el estado del sistema y determine si hay
bloqueo
Un algoritmo para recuperarse del bloqueo
Este esquema de deteccin y recuperacin requiere un gasto extra que incluye no
solo los costos en tiempo para mantener la informacin sino tambin para
recuperarse despus del bloqueo.
181
FINGUDELAR
15.6.1 Unsoloejemplardecadatipoderecursos
Se utiliza el grafo de espera, que se
obtiene eliminando del grafo de
asignacin de recursos, los nodo del tipo
de recursos, y uniendo las aristas
apropiadas.
Una arista de Pi a Pj implica que el
proceso i, espera a que j libere un recurso
que i necesita.
Existe un bloqueo mutuo
en el grafo
hay un ciclo. El sistema necesita
mantener la informacin del grafo, y
peridicamente invocar el algoritmo de
deteccin de ciclos.
P5
R1
R3
R4
P1
P2
P3
R2
P4
R5
Grafodeasignacinderecursos
P5
P1
P2
P3
P4
Grafodeesperacorrespondiente
15.6.2 Variosejemplaresdecadatipoderecursos
Para este caso se utilizan estructuras similares a las del algoritmo del banquero.
Disponible: Un vector de longitud m indica el nmero de recursos
disponibles de cada tipo.
Asignacin: Una matriz n x m define el nmero de recursos de cada
tipo ya asignados a cada proceso.
Solicitud: Una matriz n x m indica la solicitud actual de cada proceso.
Solicitud [i, j] = k Pi solicita k ejemplares de Pj.
1. Sean trabajo y fin vectores con longitud m y n respectivamente. Inicializo:
a. Trabajo:= Disponible
b. Fin[i]:= false si Asignacin[i] <> 0, sino Fin[i]:= true
2. Busco
a.
b.
c.
i tal que
Fin[i] = false
Solicitudi
Trabajo
Si no existe i, salto a 4
3. Trabajo:= Trabajo + Asignacioni

Fin[i]:= true
Ir al paso 2
4. Si Fin[i] = false para alguna i El sistema est en bloqueo mutuo para ese i.
Ver ejemplo pgina 226 del Silberschatz.
15.6.3 Usodelalgoritmodedeteccin
Si los bloqueos mutuos son frecuentes el algoritmo de deteccin deber invocarse
muy seguido ya que los recursos asignados a los procesos bloqueados estn ociosos
hasta romper ese bloqueo, adems el nmero de procesos bloqueados, puede crecer.
Los bloqueos mutuos solo pueden aparecer cuando algn proceso pide un recurso
y no se le puede asignar inmediatamente. Se podra invocar el algoritmo, cada vez
que esto sucede, adems podemos identificar inmediatamente el proceso causante
del bloqueo. Pero invocarlo tan frecuentemente, puede causar demasiado gasto
182
FINGUDELAR
extra de tiempo, por lo tanto se lo puede invocar luego de un tiempo determinado
(Ej: 1 hora) o cuando el uso del CPU baja del 40%. En este caso pueden existir
muchos ciclos en el grafo, y se dificulta identificar los procesos causantes del
bloqueo.
15.7 Recuperacindespusdelbloqueomutuo
Cuando un algoritmo detecta un bloqueo puede:
Informar al operador para que lo solucione manualmente
Dejar que el SO se recupere automticamente
Las opciones para romper el bloqueo son terminar anormalmente los procesos, o
expropiarle recursos.
15.7.1 Terminacindeprocesos
Hay dos formas:
Abortar todos los procesos bloqueados: El costo es elevado puesto que
alguno de los procesos puede haber estado trabajando por largo tiempo.
Abortar de a un proceso hasta desbloquearlos: Incluye un gasto
adicional, puesto que luego de eliminar cada proceso hay que llamar
nuevamente al algoritmo de deteccin.
La terminacin forzada de procesos no es fcil, puesto que podra dejar
incoherencia de datos.
Para saber que procesos del bloqueo se pueden abortar, se debera usar un
algoritmo similar al de la planificacin de CPU. Se deben abortar los procesos
causando el ms bajo costo posible.
Los factores para seleccin de procesos son:
Prioridad del proceso
Tiempo que ha trabajado, y cuanto ms debe trabajar
Recursos usados y de que tipo (si los recursos se pueden expropiar
fcilmente)
Recursos adicionales que necesita para terminar su tarea
Cantidad de procesos para abortar
Si los procesos son interactivos o por lotes
15.7.2 Expropiacinderecursos
Expropiamos recursos de unos procesos para drselos a otros, hasta romper el
bloqueo. Hay que considerar tres aspectos:
Seleccin de la vctima: Debemos determinar el orden de expropiacin
para minimizar el costo.
Retroceso: Si expropiamos el recurso, el proceso que lo estaba usando, no
puede continuar con su ejecucin normal, por lo tanto, el proceso debe
retroceder a un estado seguro, y reiniciarlo. La forma ms fcil es abortar el
proceso y comenzar de nuevo, pero es ms conveniente regresar el proceso a
un estado seguro, aunque se debe tener guardada informacin para ello.
Inanicin: Podra suceder que siempre se escoja el mismo proceso como
vctima, por lo tanto hay que asegurarse que solo se lo va a expropiar un
nmero finito (pequeo) de veces.
Una vez ocurrido un deadlock, describa un proceso que permita recuperarse del mismo. Mencione
sus ventajas y desventajas.
183
FINGUDELAR
Respuesta:
a. Matar todos los procesos. Es seguro pero costoso. Se pueden matar procesos que llevan mucho
tiempo de cmputo. En este caso no es necesario ejecutar el algoritmo de deteccin de deadlock,
ya que se matan todos los procesos involucrados.
b. Matar un proceso a la vez hasta eliminar el ciclo que genera el deadlock. Tiene un costo
elevado debido a que luego de matar cada proceso debe ejecutarse nuevamente el algoritmo de
detencin de deadlock para determinar si an se est en deadlock.
15.8 Estrategiacombinadaparaelmanejodebloqueosmutuos
Ninguna de las estrategias anteriores, por si sola es apropiada. Una posibilidad es
combinar los tres enfoques bsicos y usar el ptimo para cada clase de recursos.
Para ello, se pueden ordenar jerrquicamente los recursos, usando dentro de cada
clase, la tcnica ms adecuada, evitando as los bloqueos mutuos.
Clasificacin:
Recursos internos: Recursos utilizados por el sistema, como un bloque de

control de procesos.
Memoria central: Memoria utilizada por trabajos de usuario.
Recursos de trabajos: Dispositivos asignables y archivos.
Espacio intercambiable: Espacio para cada trabajo de usuario en el
almacenamiento auxiliar.
Una solucin mixta ordena las clases de la siguiente forma, utilizando las
siguientes estrategias:
Recursos internos: Se puede usar prevencin mediante ordenamiento de

recursos, ya que no es necesario escoger entre solicitudes pendientes en el
momento de la ejecucin.
Memoria central: Se puede usar prevencin mediante expropiacin ya que
los trabajos pueden intercambiarse a disco, y la memoria central puede
expropiarse.
Recursos de trabajos: Se puede usar evitacin, ya que la informacin
requerida acerca de las necesidades de recursos, se puede obtener de las
tarjetas de control de trabajos.
Espacio intercambiable: Se puede usar preasignacin, pues casi siempre se
conocen las necesidades de almacenamiento mximas.
184
FINGUDELAR
16 Proteccin
Los diversos procesos de un sistema operativo se deben proteger de las
actividades de los dems procesos. Existen mecanismos que garantizan que solo los
procesos autorizados por el SO, puedan operar con los distintos recursos.
La proteccin se refiere a un mecanismo para controlar el acceso de procesos o
usuarios al sistema, controles sobre ellos, etc. La seguridad es una medida de
confianza que tenemos en que se preservar la integridad del sistema.
16.1 Objetivosdelaproteccin
Originalmente se concibi para que los usuarios compartieran recursos sin peligro
en sistemas multiprogramados. Actualmente evolucionaron para aumentar la
confiabilidad de sistemas que usan recursos compartidos.
Razones para dar proteccin:

Evitar que usuarios malintencionados violen restricciones de acceso.
Asegurar que cada componente de un programa use los recursos respetando
las polticas de uso de ellos.
La proteccin puede detectar errores en las interfaces entre subsistemas, evitando

la contaminacin de un subsistema sano, con otro que no funciona correctamente.
Existen mecanismos para distinguir entre accesos autorizados y no autorizados.
Tipos de polticas de uso de recursos:

Determinadas por el diseo del sistema
Formuladas por los administradores del sistema
Definidas por usuarios para proteger sus propios archivos o programas
Las polticas pueden cambiar en el tiempo o dependiendo de la aplicacin, por lo

tanto el sistema debe proveer de herramientas al programador para que pueda
modificarlas o utilizarlas.
16.2 Dominiosdeproteccin
Un sistema consta de procesos y objetos, stos ltimos tanto de hardware
(memoria, perifricos, etc.), como de software (archivos, semforos, etc.). Cada
objeto tiene un identificador, y se accede a l con operaciones bien definidas que
dependen del objeto (CPU: Ejecucin, Memoria: lectura, escritura, etc.).
Un proceso debe acceder a los recursos para los cuales est autorizado, y en un
momento dado solo puede acceder a aquellos que necesite para llevar a cabo su
tarea. Esto es conocido como el principio de necesidad de conocer.
16.2.1 Estructuradedominios
Un proceso opera dentro de un dominio de proteccin, que especifica los recursos
a los que puede acceder. El dominio define el conjunto de objetos, y el tipo de
operaciones que se pueden invocar sobre ellos. La capacidad para ejecutar una
operacin con un objeto, se llama derecho de acceso y un dominio, es una coleccin
de derechos de acceso de la forma:
<nombre_de_objeto, conjunto_de_derechos>
185
FINGUDELAR
Tipos de asociacin entre proceso y dominio:
Esttica: El conjunto de recursos de un proceso no cambia durante la

ejecucin del mismo, y queremos respetar el principio de necesidad de
conocer, por lo tanto necesitamos un mecanismo para cambiar el contexto de
un dominio, para reflejar los derechos de acceso mnimos necesarios. Por
ejemplo: Un proceso tiene dos fases. En una requiere escritura y en otra
lectura. Si proporcionamos al proceso un dominio que incluye los dos accesos,
proporcionamos ms derechos de los necesarios a cada una de las fases.
Dinmica: Se cuenta con un mecanismo que cambia de un dominio a otro.
Tambin se podra modificar el contenido del dominio, o en su defecto, crear
un nuevo dominio con el contenido deseado, y cambiando a l.
Formas de establecer dominios:
Usuario: El conjunto de objetos a los que se puede acceder depende de la

identidad del usuario. Hay conmutacin de dominio cuando se cambia de
usuario (cierre y apertura de sesin).
Proceso: El conjunto de objetos a los que se puede acceder depende de la
identidad del proceso. La conmutacin de dominio corresponde a que un
proceso enva un mensaje a otro proceso y espera su respuesta.
Procedimiento: El conjunto de objetos a los que se puede acceder
corresponde a variables locales definidas dentro del procedimiento. La
conmutacin de dominio ocurre cuando se invoca a otro procedimiento.
16.2.2 Ejemplos
El modo dual (usuario monitor) es una forma de proteger el SO. Cada uno tiene
su propio dominio. En un sistema multiusuario no alcanza con esta proteccin puesto
que se debe proteger un usuario de otro.
16.2.2.1 UNIX
Asocia un dominio a cada usuario, y cambiar de dominio significa cambiar
temporalmente la identificacin de usuario.
Cada archivo tiene asociados una identificacin de propietario y un bit de dominio.
Cuando un usuario con user-id = A, comienza a ejecutar un archivo de propiedad de
B, con el bit de dominio apagado, el user-id del proceso se hace igual a A. Si el bit de
dominio est prendido, el user-id del usuario se hace igual al del propietario del
archivo, hasta que el proceso termina.
Esto se usa para poner a disposicin e usuarios, los recursos privilegiados. Por
ejemplo, el usuario puede tomar momentneamente el user-id root para usar un
recurso, pero hay que controlar que no pueda crear un archivo con user-id root y el
bit encendido, porque podra convertirse en root.
Hay sistemas ms restrictivos que no permiten cambiar los identificadores de
usuario. Se deben usar mecanismos especiales para acceder a recursos especiales
como demonios.
186
FINGUDELAR
16.2.2.2 Multics
anillo0
anillo1
anilloN1
Los dominios de proteccin se organizan jerrquicamente en una estructura de

anillos. Cada anillo corresponde a un dominio. El proceso que se ejecuta en el
dominio D0 es el que ms privilegios tiene.
Tiene un espacio de direcciones segmentado donde cada segmento es un archivo
y est asociado a un anillo. A cada proceso se le asocia un nmero de anillo, y puede
acceder a segmentos asociados a procesos con menos privilegios (mayor nmero de
anillo), pero no a los segmentos ms privilegiados.
Se produce una conmutacin de contexto cuando un proceso invoca un
procedimiento de otro anillo, y esa conmutacin es controlada por el SO. Para este
control, el anillo cuenta con los campos:
Intervalo de acceso: (b1, b2) y b1 b2.
Limite: b3 tal que b3 > b2
Lista de puertas: Identifica puertas en las que se pueden invocar
segmentos.
Un proceso en el anillo i, puede ejecutar segmentos de un intervalo de acceso (b1,
b2), solo si b1 i b2. Si no se cumple se efecta una trampa y se hacen nuevos
controles:
i < b1: Se permite la llamada porque el anillo que busco es menos privilegiado.
i > b2: Solo se permite la llamada si b3 i. La llamada se destina a una
puerta, permitiendo que los procesos con derechos de acceso limitado,
puedan invocar procedimientos ms privilegiados, pero de manera
controlada.
Desventaja: No permite el cumplimiento de la necesidad de conocer.
Los mecanismos de proteccin tambin dependen de la necesidad de seguridad o
performance. En una computadora en la que se procesan calificaciones de
estudiantes, y a la que acceden estudiantes, se justifica un complejo sistema de
seguridad, pero en una que solo es necesaria para triturar nmeros, tiene ms peso
la performance.
16.3 Matrizdeacceso
Las decisiones de poltica relativas a la proteccin se pueden implementar con una
matriz de acceso. Las filas representan dominios, y las columnas objetos. Cada
entrada es un conjunto de derechos de acceso.
Dominio \
Objeto
D1
D2
F1
F2
leer
F3
Impresora
escribir
leer
imprimir
187
FINGUDELAR
Todos los procesos que se ejecutan en el dominio D1, pueden leer el archivo F1, y
escribir el F3. Los que se ejecutan en D2, pueden leer el archivo F2, e imprimir.
Conmutacin
Si incluimos tambin a la matriz como un objeto, podemos darle privilegios solo a
algunos dominios para modificarla. De la misma forma, podemos controlar la
conmutacin de dominios.
Dominio\Objeto
D1
D2
F1
leer
F2
F3
escribir
Impresora
leer
D1
D2
conmutar
imprimir
Un proceso en el dominio D1, puede conmutar al dominio D2.

Copia
Se puede dar la capacidad de copiar derechos, aadiendo un (*) al derecho de
acceso. Se puede copiar el derecho de acceso solo dentro de la misma columna (en
el mismo objeto).
Variantes:
Transferencia: Se copia el acceso (j, k) al acceso (i, k) y se borra el acceso
(j, k).
Limitacin: El derecho (R*) se copia de (j, k) a (i, k) creando el derecho R, y
no R*, por lo tanto un proceso en el dominio l, no puede copiarlo.
Tambin el sistema podra elegir que derecho darle a la copia, si el de
copia, trasferencia o copia limitada colocando diferentes valores en la matriz.
Se necesita un mecanismo que permita aadir o quitar derechos. Para eso se le
asigna el derecho de dueo a uno de los dominios que utiliza el objeto y solo l
puede asignar o quitar derechos.
Se requiere un mecanismo que cambie derechos en las filas, y es el de control.
16.4 Implementacindelamatrizdeacceso
La mayor parte de las entradas de la matriz estn vacas.
16.4.1 Tablaglobal
Consiste en un conjunto de tripletas ordenadas:
<dominio, objeto, conjunto_de_derechos>
Si ejecuto una operacin M, con un objeto Oj, en el dominio Di, busco la entrada
<Di, Oj, Rk> M Rk. Si no existe, se genera error.
Desventajas: La tabla es grande, por lo tanto no puede estar en memoria
principal. Adems hay informacin repetida, ya que si todos los dominios usan de la
misma forma un mismo objeto, debo tener una entrada de la tabla para cada
dominio.
188
FINGUDELAR
16.4.2 Listadeaccesoparaobjetos
Cada columna (objeto) es una lista de acceso, que contiene los pares <dominio,
conjunto_de_derechos> (conjunto_de_derechos <>
).
En este caso se puede implementar un conjunto de derechos por omisin, que
contiene todo los objetos a los que puedo acceder desde cualquier dominio.
16.4.3 Listadecapacidadesparadominios
Es igual que en el caso anterior, pero para los dominios. Cada dominio tiene una
lista de capacidades (objetos y operaciones). El usuario puede acceder a estas listas
indirectamente, ya que estn protegidas por el sistema.
Proteccin de capacidades:
Cada objeto tiene una etiqueta para denotar su tipo (puntero, booleano, valor
no inicializado). No son directamente accesibles al usuario.
El espacio de direcciones de un programa se puede dividir:
Una parte accesible con datos e instrucciones normales.
Otra parte con la lista de capacidades accesibles
16.4.4 Unmecanismodecerradurayllave
Es un trmino medio entre las dos listas (capacidades y acceso). Cada objeto tiene
una lista de patrones de bit llamada cerradura, y cada dominio tiene otra llamada
llave.
Para que un proceso que se ejecuta en un dominio pueda acceder a un objeto, el
dominio debe tener la llave adecuada.
16.4.5 Comparacin
Cuando un usuario crea un objeto, establece sus derechos, pero es difcil
determinar el conjunto de derechos para cada dominio. Las listas de capacidades son
tiles para localizar informacin de un proceso en particular pero no se corresponden
con las necesidades del usuario.
El mecanismo de cerradura y llave, es un trmino medio. Puede ser eficaz y
flexible, dependiendo de la longitud de las llaves, y los privilegios de acceso se
pueden revocar para un dominio, simplemente cambiando su llave.
La mayor parte de los sistemas usa una combinacin entre listas de acceso y
capacidades.
16.5 Revocacindederechosdeacceso
Tipos:
Inmediata o diferida
Selectiva o general:
General: Al revocar un derecho de acceso afecto a todos los usuarios
con ese derecho.
Selectiva: Puedo seleccionar usuarios para revocarlo.
Parcial o total:
Total: Revoco todos los derechos de acceso a un objeto.
Parcial: Revoco un subconjunto.
Temporal o permanente:
189
FINGUDELAR
Temporal: Se puede revocar el derecho y luego obtenerlo nuevamente.

Permanente: Si lo revoco, no puedo volverlo a obtener.
Con un sistema de lista de acceso la revocacin es fcil. Es inmediata y puede ser

general, selectiva, etc. Con listas de capacidades debo hallarlas en todo el sistema
antes de revocarlas.
Esquemas de revocacin:
Readquisicin: Peridicamente se eliminan capacidades de cada dominio. El

proceso tiene que tratar de readquirirla para usarla, y si fue revocada, no la
puede adquirir.
Retropunteros: Cada objeto tiene punteros asociados a sus capacidades. Se
puede seguir esos punteros para revocar o modificar capacidades. Su
implementacin es costosa.
Indireccin: Las capacidades no apuntan directamente al objeto sino a una
entrada nica de una tabla global. Para revocar, busco la entrada en la tabla
global y la elimino. No permite revocacin selectiva.
Claves: La clave se define al crear la capacidad y el proceso que posee dicha
capacidad no puede modificarla. Debo cambiar la clave maestra de cada
objeto con un set_key para revocar los derechos. No permite revocacin
selectiva.
16.6 Sistemasbasadosencapacidades
16.6.1 Hydra
Es flexible. Proporciona un conjunto fijo de posibles derechos de acceso que el
sistema conoce, y proporciona a un usuario del sistema de proteccin, un mecanismo
para declarar nuevos derechos. Las operaciones sobre objetos, son tratadas tambin
como objetos, y se accede a ellas a travs de capacidades.
Otro concepto interesante es la amplificacin de derechos que certifica un
procedimiento como confiable y le permite acceder a objetos inaccesibles, a nombre
de otro procedimiento que si puede accederlos. Estos derechos no son universales, y
estn restringidos.
Ej: Un procedimiento invoca una operacin P, la cual es amplificada. La operacin
utiliza sus derechos nuevos, y cuando termina, el procedimiento vuelve a tener los
derechos normales.
Hydra dise proteccin directa contra el problema de subsistemas que
sospechan uno del otro. Cuando varios usuarios invocan un programa de servicios,
asumen el riesgo de que falle, perdiendo datos, o que retenga los datos y puedan ser
usados posteriormente sin autorizacin.
16.6.2 SistemaCambridgeCAP
Es ms sencillo que Hydra. Proporciona tambin proteccin segura a datos de
usuario.
Capacidades:
Capacidad de datos: Sirven para obtener acceso a objetos y tienen los
derechos estndar (leer, escribir, etc.). Est en el micro cdigo de CAP.
Capacidad de software: Corre por cuenta de un procedimiento privilegiado.
Cuando es invocado, l mismo obtiene los derechos de leer y escribir.
190
FINGUDELAR
16.7 Proteccinbasadaenellenguaje
La proteccin se logra con la ayuda del ncleo del SO que valida los intentos de
acceso a recursos. El gasto de inspeccionar y validar todos los intentos de acceso a
todos los recursos es muy grande, por lo tanto debe ser apoyada por hardware.
Al aumentar la complejidad del SO, se deben refinar los mecanismos de
proteccin. Los sistemas de proteccin, no solo se preocupan de si puedo acceder a
un recurso, sino tambin de cmo lo accedo, por lo tanto los diseadores de
aplicaciones deben protegerlos, y no solo el SO.
Los diseadores de aplicaciones mediante herramientas de los lenguajes de
programacin pueden declarar la proteccin junto con la tipificacin de los datos.
Ventajas:
Las necesidades de proteccin se declaran sencillamente y no llamando
procedimientos del SO.
Las necesidades de proteccin pueden expresarse independientemente de los
recursos que ofrece el SO.
El diseador no debe proporcionar mecanismos para hacer cumplir la
proteccin.
Los privilegios de acceso estn ntimamente relacionados con el tipo de datos
que se declara.
Diferencias entre las distintas formas de proteccin:

Seguridad: La obligacin de cumplimiento por ncleo ofrece un grado de
seguridad que el cdigo de seguridad ofrecido por el compilador.
Flexibilidad: La flexibilidad de la implementacin por ncleo es limitada. Si
un lenguaje no ofrece suficiente flexibilidad, se puede extender o sustituir,
perturbando menos cambios en el sistema que si tuviera que modificarse el
ncleo.
Eficiencia: Se logra mayor eficiencia cuando el hardware apoya la
proteccin.
La especificacin de proteccin en un lenguaje de programacin permite describir

en alto nivel las polticas de asignacin y uso de recursos.
El programador de aplicaciones necesita un mecanismo de control de acceso
seguro y dinmico para distribuir capacidades a los recursos del sistema entre los
procesos de usuario.
Las construcciones que permiten al programador declarar las restricciones tienen
tres operaciones bsicas:
Distribuir capacidades de manera segura y eficiente entre procesos clientes.
Especificar el tipo de operaciones que un proceso podra invocar en un
recurso asignado.
Especificar el orden en que un proceso dado puede invocar las operaciones de
un recurso.
191
FINGUDELAR
17 Seguridad
La proteccin es estrictamente un problema interno, la seguridad en cambio no
solo requiere un sistema de proteccin adecuado, sino tambin considerar el entorno
externo donde el sistema opera.
La proteccin no es til si la consola del operador est al alcance de personal no
autorizado. La informacin debe protegerse de accesos no autorizados, destruccin,
alteracin mal intencionada o inconsistencias.
17.1 Elproblemadelaseguridad
Un sistema es seguro si los recursos se usan y acceden como es debido en todas
las circunstancias. Esto no siempre es posible pero se debe contar con mecanismos
que garanticen que las violaciones de seguridad sean un suceso poco comn.
Formas de acceso mal intencionado:
Lectura no autorizada de datos (robo de informacin).

Modificacin no autorizada de datos.
Destruccin no autorizada de datos.
El hardware del sistema debe proporcionar proteccin que permita implementar

funciones de seguridad. MS-DOS casi no ofrece seguridad, y sera relativamente
complejo agregar nuevas funciones.
17.2 Validacin
Se deben identificar los usuarios del sistema.
17.2.1 Contraseas
Cuando el usuario se identifica con un identificador, se le pide una contrasea, y si
sta coincide con la almacenada en el sistema, se supone que el usuario est
autorizado. Se usan cuando no se cuenta con sistemas de proteccin ms completos.
17.2.2 Vulnerabilidaddelascontraseas
El problema es la dificultad de mantener secreta una contrasea. Para averiguarla
se puede usar fuerza bruta, usando todas las combinaciones posibles de letras,
nmeros y signos de puntuacin, o probando con todas las palabras del diccionario.
El intruso podra estar observando al usuario cuando la digita o husmeando en
la red, o sea, viendo los datos que el usuario transfiere a la red, incluidos
identificadores y contraseas.
Si el sistema elige la contrasea, puede ser difcil de recordar, y el usuario la
anota, si la elige el usuario, puede ser fcil de adivinar.
Algunos sistemas envejecen las contraseas, obligando al usuario a cambiarlas
cada determinado tiempo. Se controla que el usuario no vuelva a usar una
contrasea que ya us antes, guardando un historial de contraseas.
17.2.3 Contraseascifradas
El sistema UNIX usa cifrado para no tener que mantener en secreto su lista de
contraseas. Cada usuario tiene una contrasea y el sistema contiene una funcin,
extremadamente difcil de invertir, pero fcil de calcular, que codifica las contraseas
192
FINGUDELAR
y las almacena codificadas. Cuando el usuario presenta la contrasea, se codifica y
compara con las ya codificadas. De esta forma no es necesario mantener en secreto
el archivo con contraseas.
Problemas:
Se puede obtener una copia del archivo de contraseas y comenzar a

cifrar palabras hasta descubrir una correspondencia (ya que el
algoritmo de cifrado de UNIX es conocido). Las nuevas versiones de
UNIX ocultan el archivo.
Muchos sistemas UNIX solo tratan los primeros 8 caracteres como
significativos, quedando pocas opciones de contrasea.
Algunos sistemas prohben el uso de palabras de diccionario como
contrasea, para que sea ms difcil de adivinar.
17.3 Contraseasdeunsolouso
Se pueden usar contraseas algortmicas, donde el sistema y el usuario
comparten un secreto. El sistema proporciona una semilla, el usuario con el
algoritmo y la semilla introduce la contrasea, y el sistema la comprueba (ya que
conoce el algoritmo del usuario). La contrasea es de un solo uso, por lo tanto,
cualquiera que la capte, no podra utilizarla luego.
17.4 Amenazasporprogramas
17.4.1 CaballodeTroya
Muchos sistemas permiten que un usuario pueda ejecutar programas de otro
usuario. Estos programas podran aprovechar los derechos que le proporciona el
dominio del usuario ejecutante y abusar de ellos. Un segmento de cdigo que abusa
de su entorno es llamado caballo de Troya.
17.4.2 Puertasecreta(Trapdoor)
El diseador del programa podra dejar una puerta, por la cual entra saltendose
todos los protocolos de seguridad. Se podra generar una puerta ingeniosa en un
compilador, que coloque puertas en todos los programas que compile.
Una puerta en un sistema es difcil de detectar por la cantidad de cdigo que el
sistema pose.
17.5 Amenazasalsistema
17.5.1 Gusanos
El gusano engendra copias de si mismo ocupando los recursos del sistema,
impidiendo que sean usados por otros procesos. En las redes son muy potentes, ya
que pueden reproducirse entre los sistemas, y paralizar toda la red.
Gusano de Morris:
Caus en 1988 prdidas millonarias a travs de Internet. Era auto-replicante, para
distribuirse rpidamente, adems caractersticas de UNIX, le permitieron propagarse
por todo el sistema. El gusano aprovech defectos en rutinas de seguridad de UNIX,
para obtener accesos no autorizados a miles de sitios interconectados. Ver ejemplo
de pgina 631. Interesante pero intil.
193
FINGUDELAR
17.5.2 Virus
Tambin estn diseados para extenderse hacia otros programas, y pueden
producir daos graves en un sistema, como modificar o destruir archivos y causar
cadas en programas o sistemas. Un gusano es un programa completo y autnomo;
un virus es un fragmento de cdigo incrustado en un programa legtimo.
Los computadores multiusuario no son tan vulnerables, porque protegen los
programas ejecutables contra escritura, an as es fcil su infeccin.
Antivirus: La mayor parte solo actan sobre virus conocidos, examinando los
programas del sistema en busca de instrucciones especficas que sabe que contiene
el virus.
17.6 Vigilanciadeamenazas
Se buscan patrones de actividad sospechosos. Las tcnicas son:
Cuenta de las veces que se proporcionan contraseas incorrectas en el login

Llevar una bitcora de auditora que registra la hora, el usuario y los accesos
a objetos, para determinar los problemas, pero estas bitcoras pueden crecer
mucho, ocupando demasiados recursos en el sistema.
Explorar el sistema peridicamente en busca de agujeros de seguridad, que
se pueden realizar en el computador cuando hay poco trfico, no como en el
caso de las bitcoras. Puede examinar:
o Contraseas fciles de adivinar.
o Programas setuid no autorizados (si el sistema maneja el mecanismo).
o Programas no autorizados en directorios del sistema.
o Procesos cuya ejecucin tiene una duracin inusual.
o Protecciones inapropiadas de directorios de usuario y sistema.
o Protecciones inapropiadas de archivos de datos, contraseas, drivers,
o el ncleo del sistema.
AccesocomputadorassegurasInternet
o Caballos de troya.
Los computadores en red son

susceptibles a ataques por la gran
cantidad de ataques remotos
posibles.
Una ayuda de proteccin en red
son los firewalls. Un firewall es un
computador que se coloca entre lo
confiable y lo no confiable, limita
el acceso por red, y lleva una
bitcora.
17.7 Cifrado
Internet
FIREWALL
Computadoras
seguras
Acceso
computadoras
semiSeguras
computadoras
seguras
AccesoInternet
Computadoras
semiSeguras
Computadoras
semiseguras
Por la red se transmite gran cantidad de informacin que no se desea que sea
descubierta. Para lograr esto, se sigue el siguiente mecanismo:
La informacin se cifra (codifica) de su forma comprensible original (texto
limpio) a una forma interna (texto cifrado). La forma interna se puede leer
pero no es comprensible.
El texto cifrado se puede almacenar en archivos legibles y enviarse por
canales desprotegidos.
194
FINGUDELAR
Para entender el texto, el receptor debe descifrarlo (decodificarlo) para

obtener el texto limpio.
El reto es crear esquemas de cifrado imposibles de romper.

Hay varios mtodos, pero uno de ellos consiste en tener un algoritmo de cifrado
general E, uno de descifrado general D, y una o ms claves secretas.
Ek y Dk son los algoritmos para la clave k.
Para el mensaje m se debe cumplir:
1. Dk(Ek(m)) = m
2. Dk, Ek se calculan de forma eficiente.
3. Se debe mantener en secreto la clave y no los algoritmos.
Se cre el DES, estndar de cifrado de datos, que contiene el problema de
distribucin de claves, ya que hay que enviar secretamente las claves.
Una solucin a esto es usando clave pblica. Cada usuario tiene dos claves, una
pblica y una privada, y para comunicarse solo basta con saber la pblica del otro.
Algoritmo:
Clave pblica = (e, n)
Clave privada = (d, n)
El mensaje se representa con un entero y se divide en submensajes de largo
0.. (n 1)
E(m) = me mod n = C
D(C) = Cd mod n
n se calcula como el producto de dos primos p y q al azar (n = p x q); d es al
azar, y satisface mcd [d, (p-1) x (q-1) ] = 1; e se calcula tal que e x d mod [(p-1) x
(q-1)] = 1.
Si es necesario, ver ejemplo en pgina 638.
17.8 Clasificacindeseguridaddeloscomputadores
El total de sistemas de computacin que obligan al cumplimiento correcto de
polticas de seguridad son llamados Base de computador confiable (TCB).
Se clasifican en A, B, C y D:
D Proteccin mnima: Son sistemas evaluados que no satisfacen los

requisitos de seguridad de las otras clases. Ej: MS-DOS y Windows 3.1.
C Proteccin discrecional: Se contabilizan los usuarios y sus acciones
mediante auditoras. Tiene dos niveles:
C1: Permite que los usuarios puedan proteger informacin privada y
evitar que otros la lean o destruyan. Abarca la mayor parte de las
versiones de UNIX. La TCB de C1 controla el acceso entre usuarios y
archivos permitiendo compartir objetos entre individuos nombrados, o
grupos definidos. El usuario debe identificarse antes de iniciar
cualquier actividad que la TCB deba mediar.
C2: Une a los requisitos de C1, un control de acceso a nivel individual,
y el administrador del sistema puede auditar de forma selecta las
195
FINGUDELAR
acciones de cualquier usuario conociendo su identidad. Hay algunas

versiones de UNIX que certifican el nivel C2.
B Proteccin obligatoria: Tienen todas las propiedades de C2, y adems
pegan etiquetas de confidencialidad a cada objeto.
B1: Mantiene la etiqueta de seguridad en cada objeto del sistema la
cual es usada para tomar decisiones relacionadas con el control de
acceso obligatorio. Maneja niveles de seguridad jerrquicos, de
manera que usuarios pueden acceder a cualquier objeto con etiqueta
de confidencialidad igual o menor.
B2: Extiende etiquetas de confidencialidad a los recursos del sistema.
Se asignan a los dispositivos fsicos, para seleccionar los usuarios que
pueden usarlos.
B3: Permite crear listas de control de acceso que denotan usuarios a
los que no se concede acceso a un objeto nombrado dado. La TCB
contiene un mecanismo que detecta violaciones de seguridad,
avisando al administrador y finalizando los sucesos.
A Nivel alto de proteccin: Funciona arquitectnicamente igual que B3,
pero contiene tcnicas de verificacin con ms alto grado que las
especificadas por TCB.

Defina brevemente que es "Mandatory Access Control" en oposicin al concepto de
"Discretionary Access Control".
Respuesta:
En el modelo de control de acceso discrecional (Discretionary Access Control, DAC) el usuario
tiene un completo control sobre los objetos que le pertenecen y los programas que ejecuta. As
mismo, el programa ejecutado por un usuario tendr (generalmente) los mismos permisos de ese
usuario que lo est ejecutando . Esto implica que la seguridad del sistema depende de las
aplicaciones que se estn ejecutando y, por tanto, cuando se produce una vulnerabilidad de
seguridad en una aplicacin, sta afecta a todos los objetos a los que el usuario tiene acceso. As,
si la aplicacin es ejecutada por root, el atacante puede obtener los mximos privilegios en la
mquina, comprometiendo la seguridad global del sistema.
Otro modelo de control de acceso es el denominado control de acceso obligatorio (Mandatory
Access Control, MAC), donde existe una poltica de seguridad definida por el administrador y que
los usuarios no pueden modificar. Esta poltica va ms all de establecer propietarios de archivos
sino que fija "contextos", en donde se indica cuando un objeto puede acceder a otro objeto. Un
ejemplo de esto es el modelo de Bell-Lapadula pensado para restringir permisos en un esquema
military, donde se le asocia a los objetos y a los sujetos del sistema dos etiquetas (sensibilidad,
categora) Donde sensibilidad es por ejemplo: no-clasificado, confidencial, secreto y ultra secreto
Y categora es por ejemplo: otan, misiles, afganistan, etc. Un sujeto para poder acceder a un
objeto debe tener una sensibilidad igual o mayor con la que est clasificado el objeto y tener su
misma categora. Por ejemplo si el sujeto tiene la clasificacin (ultra secreto. Otan) no puede
acceder a los objetos clasificados como (no-confidenciales, afganistan). Un sujeto no puede
cambiar la etiqueta de un objeto salvo elevar su sensibilidad.
Examen julio 2004:
Describa brevemente tres mtodos de autenticacin de usuarios.
Respuesta:
Autenticacin por passwords: el usuario o proceso que quiere autenticarse provee, adems de su
identificador, una password. Pueden asociarse distintas passwords, c/u con distintos derechos de
acceso. La ventaja es que son fciles de entender y usar, la desventaja es que puede ser
intencional o accidentalmente descubierta o transferida. Otra forma, variante de las anterior, es
encriptar/desencriptar las passwords al de almacenarlas/recuperarlas, o al transmitirlas por un
medio inseguro. Finalmente, puede hacerse por passwords de una sola vez. En este caso el
sistema genera aleatoriamente un valor cuyo resultado conoce, para ese usuario. El usuario
aplica una funcin (que recibe ese valor e informacin extra que slo el usuario y el sistema
tienen) y retorna el resultado al sistema, probando, segn sea el esperado o no, si es quien dice
ser.
196
FINGUDELAR
17.9 Ejemplodemodelodeseguridad:WindowsNT
Va desde seguridad mnima (por defecto) hasta C2. El administrador puede
configurarlo al nivel deseado mediante C2config.exe. El modelo se basa en el
concepto de cuentas de usuario. Permitiendo crear cualquier cantidad de cuentas
de usuario que se pueden agrupar de cualquier manera.
Cuando un usuario ingresa al sistema, NT crea un testigo de seguridad que
contiene todos los datos y permisos del usuario, y que va a ser accedido por los
procesos cada vez que el usuario quiere acceder a un objeto. La validacin de una
cuenta de usuario se efecta a travs del nombre de usuario y contrasea.
NT cuenta con una auditora integrada y permite vigilar amenazas de seguridad
comunes. Los atributos de seguridad de un objeto NT se describen con un descriptor
de seguridad que contiene el identificador de seguridad del propietario del objeto
(quien puede cambiar los permisos), un identificador de seguridad de grupo, una lista
de control de acceso discrecional (usuarios o grupos a los que se le permite o prohbe
el acceso) y una lista de control de acceso al sistema (guarda mensajes de auditora
del sistema).
NT clasifica los objetos como contenedores o no contenedores. Los contenedores
pueden contener lgicamente otros objetos (Ej: Directorios).
El subobjeto hereda los permisos del padre. Si se cambian los del padre,
cambian los del hijo.
197
FINGUDELAR
18 ElsistemaUNIX
18.1 Historia
La primera versin fue en 1969 en Bell Laboratories, y MULTICS tuvo una gran
influencia sobre l. La tercer versin fue el resultado de escribir la mayor parte del
SO en lenguaje C, en lugar de lenguaje ensamblador, agregando funciones de
multiprogramacin.
La primera versin liberada fue la 6, en 1976, y se utiliz en universidades.
Con el pasar del tiempo se fueron agregando funciones de memoria virtual,
paginacin y memoria compartida. Se apoyaron los protocolos TCP/IP, logrando gran
popularidad y permitiendo un masivo crecimiento de Internet. Se implement una
nueva interfaz con el usuario (C-shell), un nuevo editor de textos (vi), y compiladores.
En 1986 se liber la versin 4.3BSD, sobre la que se basa este captulo.
El conjunto actual de sistemas UNIX no est limitado por los producidos por Bell
Laboratories, por lo tanto tambin existen una gran cantidad de interfaces de usuario
que los distintos proveedores distribuyen.
UNIX est disponible para casi todos los computadores de propsito general, como
PCs, estaciones de trabajo, etc. en entornos que van de acadmicos a militares.
Se trata de crear un standard para lograr una nica interfaz y popularizar an mas
el sistema.
18.2 Principiosdediseo
UNIX se dise como un sistema de tiempo compartido. El shell es sencillo y
puede ser sustituido por otro si se desea. El sistema de archivos es un rbol con
mltiples niveles, y las dependencias y peculiaridades de los dispositivos se
mantienen en el ncleo hasta donde es posible, confinadas en su mayor parte a los
drivers de dispositivos.
UNIX apoya mltiples procesos. La planificacin de la CPU es un sencillo algoritmo
de prioridades. Se usa paginacin por demanda para gestin de memoria, usando un
rea de SWAP si hay hiperpaginacin.
El sistema es sumamente flexible, y cuenta con recursos para ampliarlo
fcilmente. Al ser diseado para programadores, cuenta con recursos como make
(til para compilar archivos fuentes de un programa) y el Sistema de control de
cdigo fuente (SCCS) para mantener versiones sucesivas de archivos sin necesidad
de almacenarlos. Est escrito en C, por lo tanto es portable.
18.3 Interfazconelprogramador
Consta de dos partes separables,
el ncleo y los programas de
sistemas.
Est formado por capas, y los
servicios del SO son proporcionados
a travs de llamadas al sistema. Las
llamadas al sistema definen la
interfaz con el programador, y el
conjunto de programas del sistema,
la interfaz con el usuario, las dos
apoyadas por el ncleo.
(losusuarios)
shellsyrdenes
compiladoreseintrpretes
bibliotecasdelsistema
interfazconelncleoatravsdellamadasalsistema
manejodesealesde
terminales
sistemadeE/Spor
caractres
driversdeterminales
sistemadearchivos
sistemadeE/Spor
intercambiodebloques
driversdediscoycinta
planificacindelaCPU
reemplazodepginas
paginacinpordemanda
memoriavirtual
interfazentreelncleoyelhardware
contadoresdeterminales
terminales
controladoresdedispositivos
discosycintas
controladoresdememoria
memoriafsica
198
FINGUDELAR
Las llamadas al sistema se agrupan en tres categoras explicadas a continuacin.
18.3.1 Manipulacindearchivos
Un archivo en UNIX es una secuencia de bytes. El ncleo no impone ninguna
estructura de archivo, aunque los diferentes programas esperan distintos niveles de
estructura.
Estn organizados en directorios con estructura de rbol. Los directorios tambin
son archivos con informacin para encontrar otros archivos. Un nombre de camino
(path) consiste en nombres de archivo (directorios) separados por /, donde la base
de partida es el directorio root.
UNIX tiene:
Nombres de camino absoluto: Parten de la raz del sistema y se distinguen
por comenzar con una diagonal. Ej. /usr/local.
Nombres de camino relativo: Parten del directorio actual.
Maneja enlaces:
Simblicos o blandos: Son archivos que contienen el nombre de camino de
otro archivo. Pueden apuntar a directorios y cruzar fronteras de sistemas de
archivo (a diferencia de los duros).
Duros:
o El nombre del archivo . es un enlace duro al directorio mismo.
o El nombre del archivo .. es un enlace duro al directorio padre.
Los dispositivos de hardware tienen nombres en el sistema de archivos. Los
directorios comunes son:
/bin: Contiene binarios de los programas UNIX.
/lib: Contiene bibliotecas.
/user: Contiene los directorios de usuarios.
/tmp: Contiene archivos temporales.
/etc.: Contiene programas administrativos.
Para trabajar con archivos y directorios uso las siguientes llamadas al sistema:
creat: Crea un archivo:
open, close: Abre y cierra archivos.
read, write: Trabaja sobre el archivo.
link, unlink: Crea o destruye enlaces duros a archivos.
symlink: Crea un enlace simblico al archivo.
mkdir, rmdir: Crea o elimina directorios.
cd: Cambia de directorio.
18.3.2 Controldeprocesos
Los procesos se identifican con su identificador de proceso (PID), y se crea un
proceso nuevo con la llamada al sistema fork.
El proceso nuevo consiste en una copia del espacio de direcciones del padre, y
ambos continan su ejecucin en la instruccin siguiente al fork, con la diferencia
que el cdigo de retorno del fork es 0 para el hijo, y es el PID del hijo para el padre.
El proceso termina con una llamada al sistema exit, y el padre puede esperarlo
con wait. El hijo al terminar queda como difunto por si el padre necesita su
informacin. En el caso que el padre termine, sin esperar por el hijo, el hijo pasa a ser
199
FINGUDELAR
un proceso zombie. Todos los procesos de usuario son hijos de un proceso original
llamado init.
Tipos de identificador de usuario:
Efectivo: Se usa para los permisos de acceso a archivos, y se hace igual al id
del usuario dueo del archivo, para abrirlo.
Real: Es el id del usuario.
Esto permite a ciertos usuarios tener privilegios ms all de los ordinarios, pero
controlados por el SO.
18.4 Seales
Son un recurso para manejar excepciones, y son similares a las interrupciones de
software.
SIGINT: Interrupcin. Detiene una orden antes de que termine de ejecutarse.
Se produce con el carcter ^C.
SIGQUIT: Abandonar. Detiene un programa y vaca su memoria en un archivo
llamado core (^bs).
SIGILL: Instruccin no vlida.
SIGSEV: Acceso invlido a memoria.
SIGKILL: No se puede pasar por alto. Sirve para terminar un proceso
desbocado que no hace caso a otras seales como SIGINT o SIGQUIT.
No hay prioridades entre seales, y si mando dos del mismo tipo a un proceso, se
sobrescriben. Tambin existen seales para entregar datos urgentes en una red, o
dormir procesos hasta que sean interrumpidos.
18.4.1 Gruposdeprocesos
Grupos relacionados de procesos podran cooperar para realizar una tarea comn,
y es posible enviar seales a todos los procesos del grupo.
Solo un grupo de procesos puede usar una terminal de E/S en un momento dado.
Este trabajo de primer plano tiene la atencin del usuario de la terminal, mientras los
trabajos de segundo plano realizan otras tareas.
18.4.2 Manipulacindeinformacin
Existen llamadas al sistema para devolver y ajustar temporalizadores, hora actual,
y para obtener el PID de un proceso (getpid), nombre de una mquina
(gethostname), etc.
18.4.3 Rutinasdebiblioteca
La interfaz de llamadas al sistema de UNIX se apoya con bibliotecas y archivos de
cabecera. Estos ltimos proporcionan estructuras de datos complejas que se
emplean en las llamadas. Por ejemplo <stdio.h> proporciona una interfaz que lee y
escribe miles de bytes usando buffers locales. Hay otras para funciones matemticas,
acceso a redes, etc.
18.5 Interfazconelusuario
Los programadores y usuarios manejan los programas de sistema que UNIX
provee. Estos efectan llamadas al sistema que en muchos casos no son obvias para
el usuario.
200
FINGUDELAR
Programa ls: Lista los nombres de archivos del directorio actual. Hay
opciones:
- l: Listado largo. Muestra el nombre de archivo, dueo, proteccin,
fechas y tamao.
Programa cp: Copia un archivo existente.
Programa mv: Cambia un archivo de lugar o nombre.
Programa rm: Borra archivos
Programa cat: Muestra el contenido de un archivo en la pantalla.
Tambin hay editores (vi), compiladores (C, PASCAL), programas para

comparar (cmp, diff), buscar patrones (grep), etc.
18.5.1 Shellsyrdenes
Los programas normalmente se ejecutan con un intrprete de rdenes, que en el
caso de UNIX es un proceso de usuario como cualquier otro llamado shell. Hay
diferentes shells, pero todos tienen rdenes en comn.
El shell indica que est listo exhibiendo una seal de espera (prompt) que
depende del tipo de shell (ej.: en shell C es %), y la orden de usuario es de una
nica lnea.
Generalmente el shell espera (wait) hasta que termin la tarea que el usuario
orden, pero se pueden ejecutar tareas en segundo plano donde la tarea queda
ejecutndose y el shell sigue interpretando rdenes.
El shell C cuenta con un control de trabajos que permite transferir procesos entre
el primer y el segundo plano.
18.5.2 E/Sestndar
Los procesos pueden abrir archivos a discrecin, pero siempre tienen abiertos tres
descriptores de archivo en su inicio:
0: Entrada estndar.
1: Salida estndar.
2: Error estndar.
Y stos, les permite trabajar con ellos (ej: pantalla, teclado, etc.).
Esos archivos son por defecto, pero puedo asignar otros si es necesario (ej:
impresora como salida). Este cambio es llamado redireccin de E/S.
18.5.3 Conductos,filtrosyguionesdeshell
Se usa un conducto para llevar datos de un proceso a otro. En UNIX se usa una
barra vertical | (pipe), como por ejemplo ls | lpr que imprime lo que devolvi el
comando ls.
Una orden que pasa su entrada estndar a su salida estndar realizando un
proceso sobre ella, es llamada filtro.
Un archivo que contiene rdenes de shell es un guin de shell (shell script). Se
ejecuta como cualquier orden y se invoca el shell apropiado para leerlo.
18.6 Gestindeprocesos
Es fcil crear y manipular procesos en UNIX. Los procesos se representan con
bloques de control, y se almacenan en el ncleo, el cual los usa para controlar el
proceso y planificar la CPU.
201
FINGUDELAR
18.6.1 Bloquesdecontroldeprocesos
La estructura de proceso contiene lo que el sistema necesita para saber acerca de
l. Existe un arreglo de estructuras de proceso, cuyo tamao se define al enlazar el
sistema. El planificador implementa la cola de procesos listos como una lista
doblemente enlazada de estructuras e proceso.
El espacio de direcciones virtual del proceso se divide en segmentos de texto
(cdigo del programa), datos y pila. Los dos ltimos estn en el mismo espacio de
direcciones, pero como son variables crecen en direcciones opuestas.
Las tablas de pginas registran informacin de la correspondencia entre memoria
virtual y fsica.
En la estructura de usuario se guardan los id de usuario y grupo, el directorio
actual, la tabla de archivos abiertos, etc.
Cuando un proceso se ejecuta en modo de sistema, se utiliza una pila de ncleo
para el proceso, en lugar de la pila del proceso. La pila de ncleo y la estructura de
usuario constituyen el segmento de datos del sistema de ese proceso.
El fork copia los datos y la pila en el nuevo proceso, al contrario del vfork.
18.6.2 PlanificacindeCPU
Est diseada para beneficiar los procesos interactivos. Cada proceso tiene una
prioridad de planificacin (a mayor nmero, menor prioridad). Los procesos que
realizan tareas importantes tienen prioridades menores que pzero y no se pueden
matar. Los dems tienen prioridades positivas.
Cuanto ms tiempo de CPU acumula un proceso, ms baja su prioridad, y se usa
envejecimiento para evitar inanicin.
En el ncleo, ningn proceso desaloja a otro.
18.7 Gestindememoria
18.7.1 Intercambio
Un proceso ms grande que la memoria no poda ser ejecutado, y los segmentos
de datos de sistema y usuario, que se mantenan en memoria principal, causaban
fragmentacin externa.
La asignacin de memoria virtual y espacio de intercambio es por primer ajuste. Si
la memoria aumentaba se buscaba un nuevo hueco y se copiaba. Si no exista tal
hueco, se cambiaba a disco.
El proceso planificador decide que procesos se deben intercambiar, y se despierta
cada 4 segundos para revisar. Para evitar hiperpaginacin, no se intercambia a disco
un proceso que no haya estado un cierto tiempo en memoria.
Todas las particiones de swap deben tener el mismo tamao (potencia de dos) y
deben poder accederse con diferentes brazos del disco.
18.7.2 Paginacin
Utiliza paginacin por demanda, eliminando la fragmentacin externa, y
reduciendo la cantidad de intercambios.
Algunas arquitecturas, no cuentan con un bit de referencia a pgina en hardware,
impidiendo el uso de muchos algoritmos de gestin de memoria. Utiliza una
modificacin del algoritmo de segunda oportunidad. La escritura de pginas se
efecta en cmulos para mejorar el desempeo.
Se realizan verificaciones para que el nmero de pginas en memoria para cada
proceso no se reduzca demasiado, o no aumente demasiado. El encargado es
202
FINGUDELAR
pagedaemon que est dormido hasta que el nmero de marcos libres se reduce ms
all de un umbral.
En VAX el tamao de pgina es pequeo causando ineficiencias de la E/S, as que
se juntan en grupos de a dos. El tamao de pgina efectivo no necesariamente es
idntico al tamao de pgina de hardware, aunque si debe ser mltiplo.
18.8 Sistemadearchivos
18.8.1 Bloquesyfragmentos
El sistema de archivos est ocupado por bloques de datos los cuales deben ser
mayores a 512 bytes, por razones de velocidad, pero no muy grandes por causa de la
fragmentacin interna.
UNIX usa dos tamaos de bloque. Todos los bloques de un archivo son grandes
menos el ltimo que es llamado fragment. Los tamaos se establecen al crear el
sistema de archivos, obligando que la proporcin bloque-fragmento sea 8:1.
Se debe conocer el tamao del archivo antes de copiarlo a disco, a fin de saber si
debo copiar un bloque o un fragmento. De otra forma tendra que copiar 7
fragmentos, y luego pasarlos a un bloque, causando ineficiencia.
18.8.2 Inodos
Un archivo se representa con un i-nodo que es un registro que guarda informacin
acerca del archivo. Contiene:
Identificadores de usuario y grupo.
Hora de ltima modificacin y ltimo acceso.
Cuenta del nnmero de enlaces duros.
Tipo de archivo.
15 punteros a bloques
o 12 primeros: Apuntan a bloques directos, o sea son una direccin de
un bloque de datos.
o 3 siguientes: Apuntan a bloques indirectos.
Primero: Apunta a un bloque de indireccin simple, que es un
bloque ndice con punteros a bloques de datos.
Segundo: Es un puntero a un bloque de indireccin doble, el
cual apunta a un bloque ndice que contiene direcciones de
bloques ndices que apuntan a bloques de datos.
Tercero: Es un puntero a un bloque de indireccin triple. En
UNIX no se usa, ya que el tamao de los archivos puede
alcanzar solo 232 bytes (por ser un sistema de
direccionamiento de 32 bits), y para ello alcanza con el
segundo.
18.8.3 Directorios
Se representan igual que los archivos, pero difieren en el campo tipo del i-nodo,
adems que el directorio tiene una estructura especfica.
Los primeros nombres de cada directorio son . y ... Para buscar un archivo, voy
recorriendo paso a paso el camino, y no todo junto, ya que en muchos casos, cuando
cambio de dispositivo, tambin cambia el sistema de archivos. El ltimo nombre de
un camino, debe ser el de un archivo.
Debido a la existencia de enlaces, para evitar ciclos, en una bsqueda no puedo
pasar por ms de 8 enlaces.
203
FINGUDELAR
Los archivos que no estn en disco (dispositivos) no tienen bloques asignados. El
ncleo los detecta y llama a los controladores de E/S apropiados.
18.8.4 Transformacindeundescriptordearchivoenuninodo
Para trabajar con un archivo, debo pasar un descriptor de l como argumento a las
llamadas al sistema. El ncleo lo usa como entrada de una tabla que apunta al i-nodo
del archivo. La tabla de archivos abiertos tiene una longitud fija, por lo tanto no
puedo abrir archivos ilimitadamente.
18.8.5 Estructurasdedisco
Los dispositivos fsicos se dividen en dispositivos lgicos, y cada uno de estos
ltimos define un sistema de archivos fsico, para diferentes usos. Una de las
particiones es la de swap.
El primer sector del dispositivo lgico es el bloque de arranque que puede
contener un programa de autoarranque primario, que llama al secundario que est
en los prximos 7,5 Kb.
18.8.6 Organizacinypolticasdeasignacin
El ncleo usa un par <nmero de dispositivo lgico, nmero de i-nodo> para
identificar un archivo. No puedo asegurar la confiabilidad del sistema de archivos, ya
que se mantiene en memoria, escribindolo a disco cada 30 segundos. Por lo que un
corte de energa podra producir inconsistencia.
Se introdujo el sistema de grupo de cilindros para localizar bloques de archivos
logrando casi no tener que mover la cabeza del disco. Cada cilindro guarda
informacin til para recuperacin. Siempre se trata que todos los bloques de un
archivo estn dentro del mismo grupo de cilindros.
18.9 SistemasdeE/S
Se trata de ocultar las peculiaridades de los dispositivos, y se hace en el ncleo
con el sistema de E/S, que consiste en un sistema de buffers en cache, y drivers para
los dispositivos (que conoce las peculiaridades de ellos).
Hay tres tipos principales de dispositivos:
Por bloques: Discos y cintas. Se pueden direccionar directamente en
bloques de tamao fijo. Las transferencias se hacen a travs del cache de
buffers de bloques.
Por caracteres: Terminales, impresoras, etc. Agrupa los dispositivos que no
usan cache de buffers de bloques, como por ejemplo las interfaces de grficos
de alta velocidad.
Interfaz de socket
Un dispositivo se distingue por:
Tipo
Nmero de dispositivo: Se divide en:
Nmero de dispositivo principal: Indica el lugar en el arreglo de
dispositivo, para encontrar puntos de ingreso al driver apropiado.
Nmero de dispositivo secundario: Es interpretado por el driver,
como por ejemplo una particin lgica de disco, etc.
204
FINGUDELAR
18.9.1 cachedebuffersdebloques
Consiste en varias cabeceras de buffer que pueden apuntar a memoria fsica, a un
nmero de dispositivo, o a un nmero de bloque en el dispositivo.
Los buffers no usados se mantienen en tres listas:
Recientemente usados: Enlazados en orden LRU (Lista LRU).
No usados recientemente: Sin contenido vlido (Lista AGE).
Vacos: No tienen memoria fsica asociada (Lista EMPTY).
Al requerir una lectura, se busca en el cache de buffers. Si se encuentra, se usa, y
si no se encuentra, se lee del dispositivo, y se guardan los datos en el cache,
eligiendo un buffer de la lista AGE, o si est vaca, de la lista LRU.
La cantidad de datos del buffer es variable, y el tamao mnimo es el tamao del
cmulo de paginacin. El tamao del cache, tiene un efecto considerable en el
desempeo del sistema, dependiendo de l, la cantidad de transferencias de E/S que
se deben realizar.
Cuando escribo en una cinta, debo sincronizar los buffers, para que escriban en un
orden determinado. Cuando escribo en un disco, los puedo sincronizar para lograr el
menor movimiento posible de la cabeza del disco.
18.9.2 Interfacescondispositivoscrudas
Se les llama a las interfaces por caracteres que tienen los dispositivos por bloques,
y lo que hacen
es pasar por alto el cache de bloques. En estos casos, el tamao de la
transferencia est limitado por los dispositivos fsicos, algunos de los cuales
requieren un nmero par de bytes.
18.9.3 ListasC
Los controladores de terminales usan un sistema de buffer de caracteres, que
mantiene bloques pequeos de caracteres en listas enlazadas. Tanto las salidas
como entradas se controlan con interrupciones.
Los editores de pantalla completa y otros programas que necesitan reaccionar con
cada digitacin, usan el modo crudo que pasa por alto el buffer de caracteres.
18.10 Comunicacinentreprocesos(IPC)
La comunicacin entre procesos no es uno de los puntos fuertes de UNIX. En
muchos casos no se permite la memoria compartida porque algunas arquitecturas no
apoyaban su uso. En los actuales si, pero de todas formas, presenta problemas en un
entorno de red, ya que los accesos por la red no son tan rpidos como los accesos
locales, perdiendo la ventaja de velocidad en la memoria compartida.
18.10.1 Sockets
Es el mecanismo de IPC caracterstico de UNIX. Un conducto permite establecer un
flujo de bytes unidireccional entre dos procesos, y se implementan como archivos
ordinarios (con algunas excepciones). El tamao es fijo, y si esta lleno, los procesos
que intentan escribir en l, se suspenden. Como ventaja, es pequeo, y su escritura
no pasa por disco, sino a travs de los buffers de bloques.
En 4.3BSD se implementan con sockets, que proporcionan una interfaz general,
tanto en la misma mquina, como en redes. Puede ser usado entre procesos no
relacionados entre s.
205
FINGUDELAR
Los socket tienen vinculadas direcciones, cuya naturaleza depende del dominio de
comunicacin del socket. Dos procesos que emplean el mismo dominio, tienen el
mismo formato de direcciones. Los tres dominios que se implementan son el dominio
de UNIX (AF_UNIX), cuyo formato de direcciones es el de los nombres de caminos del
sistema de archivos (ej: /casa/auto), el dominio de Internet (AF_INET) y el de
Servicios de red (AF_NS).
Hay varios tipos de sockets, los cuales se clasifican dependiendo del servicio que
realizan, y el recurso socket tiene un conjunto de llamadas especficas al sistema.
Luego de establecer una conexin por sockets, se conocen las direcciones de ambos
puntos, y no se necesita ningn tipo de informacin para transferir datos. Algunos
tipos de socket, no conocen conexiones (datagramas), y se les debe especificar el
destinatario del mensaje.
18.10.2 Soportepararedes
Reconoce gran cantidad de protocolos de Internet, y el ncleo se dise con miras
de facilitar la implementacin de protocolos adicionales.
Los procesos de usuario se comunican con los protocolos de red a travs del
recurso de sockets; y los sockets se apoyan con protocolos, los cuales prestan sus
servicios.
Suele haber un driver de interfaz de red para cada tipo de controlador de red, que
maneja las caractersticas especficas de la red local, asegurando que los protocolos
no tengan que preocuparse por ello. Las funciones de la interfaz de red, dependen
del hardware de red, y de las funciones que l apoya (como trasmisin segura, etc.).
206
FINGUDELAR
19 ElsistemaLinux
19.1 Historia
Es muy parecido a UNIX y tiene la compatibilidad fue una de las metas de su
diseo. Su desarrollo se inici en 1991, para el 80386 (de 32 bits).
El cdigo fuente se ofreca gratuitamente en Internet, por lo tanto su historia ha
sido una colaboracin de muchos usuarios de todo el mundo.
Se divide entre el ncleo y un sistema Linux. El ncleo fue desarrollado de cero
por la comunidad Linux, y el sistema incluye gran cantidad de componentes. Es un
entorno estndar para aplicaciones y programacin, y una distribucin Linux incluye
todos los componentes estndar, junto con un conjunto de herramientas
administrativas que simplifican la instalacin y desinstalacin de paquetes, etc.
19.1.1 ElncleodeLinux
La primera versin, en 1991 no trabajaba con redes y slo se ejecutaba con
procesadores compatibles con el 80386, adems, el soporte de drivers era limitado.
No tena soporte para archivos con correspondencia en memoria virtual, pero
manejaba pginas compartidas. Solo reconoca un nico sistema de archivos (Minix),
pero implementaba correctamente procesos UNIX.
En 1994, sali la siguiente versin que apoyaba el trabajo con redes, con los
protocolos TCP/IP y UNIX, sockets, y nuevos drivers de dispositivos (para redes o
Internet). Tambin inclua nuevos sistemas de archivos y reconoca controladores
SCSI. El subsistema de memoria virtual se extendi para apoyar el intercambio por
paginacin, pero de todas formas segua restringido a la plataforma Intel. Adems se
implement la comunicacin entre procesos (IPC) de UNIX, con memoria compartida,
semforos y cola de mensajes.
En 1994 sali la versin 1.2, soportando nuevo hardware, y la arquitectura de bus
PCI. Se aadi soporte para emular el sistema DOS. Inclua soporte para otros
procesadores, aunque no completo.
En 1996 la versin 2.0 Soportaba mltiples arquitecturas (inclusive la Alpha de 64
bits) y arquitecturas multiprocesador. Se mejor la gestin de memoria, y se
introdujo soporte de hilos internos del ncleo y carga automtica de mdulos por
demanda.
19.1.2 ElsistemaLinux
El sistema Linux es cdigo comn a varios sistemas operativos tipo UNIX. Las
bibliotecas principales se comenzaron como GNU, pero se fueron mejorando y
agregando funcionalidades. El sistema Linux es mantenido por una red de
desarrolladores que colaboran por Internet, pero se tiene un libro de normas, para
asegurar la compatibilidad.
19.1.3 DistribucionesdeLinux
Incluyen el sistema Linux bsico, utilitarios de instalacin y administracin,
paquetes, herramientas, procesadores de texto, editores, juegos, etc. facilitando la
tarea de la persona que lo quiere instalar en su mquina, y poniendo cada
componente en su lugar apropiado. Hay distribuciones comerciales y no comerciales
como Red Hat, SuSE, Mandrake, etc.
207
FINGUDELAR
19.1.4 LicenciasdeLinux
El ncleo se distribuye bajo la Licencia Publica General de GNU. Los autores
renunciaron a los derechos de autor sobre el software, pero los derechos de cdigo
siguen siendo propiedad de dichos autores. Linux es software gratuito, y nadie que
haga un derivado, lo puede registrar como propio.
19.2 PrincipiosdeDiseo
Linux es un sistema multiusuario, multitarea con un conjunto completo de
herramientas compatibles con UNIX. Linux desde sus principios procur sacar el
mximo de funcionalidad posible en recursos limitados, por lo tanto puede ejecutarse
en muchos sistemas pequeos.
19.2.1 ComponentesdeunsistemaLinux
El sistema Linux se divide en tres partes principales de cdigo:
Ncleo: Mantiene las abstracciones importantes del sistema operativo como

memoria virtual y procesos. Implementa todas las operaciones necesarias
para calificar como SO.
Bibliotecas del sistema: Definen un conjunto estndar de funciones a
travs de las cuales las aplicaciones pueden interactuar con el ncleo y que
implementan gran parte de la funcionalidad del SO, que no necesita todos los
privilegios del cdigo de ncleo.
Utilitarios del sistema: Son programas que realizan tareas de
administracin. Implementa por ejemplo los demonios que son procesos
que se ejecutan de forma permanente.
El cdigo de ncleo se ejecuta en el modo privilegiado del procesador (modo de

ncleo) con pleno acceso a todos los recursos fsicos. No se incorpora cdigo del
modo usuario en el ncleo, el cual es colocado en bibliotecas del sistema.
El ncleo de Linux se crea como algo separado, aislado (estructura monoltica) al
igual que UNIX. Este sistema tiene muchas ventajas, dado que el ncleo se mantiene
en un solo espacio de direcciones, no se requieren conmutaciones de contexto
cuando un proceso invoca a una funcin del SO. Adems dentro de ese espacio de
direcciones se encuentra el cdigo de planificacin, memoria virtual central, todo el
cdigo de ncleo, incluido el de los drivers de dispositivos, sistema de archivos y
trabajo con redes.
El sistema operativo que el ncleo de Linux ofrece no se parece en absoluto a un
sistema UNIX. Faltan muchas caractersticas extra de UNIX, y las funciones que si se
ofrecen no son necesariamente del formato que utiliza UNIX. El ncleo no mantiene
una interfaz con el SO que ven las aplicaciones, mas bien las aplicaciones para
comunicarse con el SO deben hacer llamadas a las bibliotecas del sistema las cuales
solicitan servicios del SO.
Las bibliotecas del sistema ofrecen funcionalidad, permitiendo hacer solicitudes de
servicio al ncleo, y otras rutinas como funciones matemticas, etc.
Los programas en modo usuario, incluyen programas necesarios para iniciar el
sistema, configurar la red, programas de inicio de sesin de usuarios, etc. Tambin
incluye operaciones sencillas como listar directorios, trabajar con archivos, y otras
ms complejas como procesadores de texto, etc.
208
FINGUDELAR
19.3 MdulosdelNcleo
El ncleo de Linux tiene la facultad de cargar y descargar mdulos del ncleo
cuando se le pide hacerlo. Estos se ejecutan en modo de ncleo privilegiado,
teniendo acceso a todas las capacidades de hardware. Los mdulos pueden
implementar desde un driver hasta un protocolo de redes.
La ventaja de esta modularizacin, es que cualquiera puede variar a su gusto
algunos de los mdulos ncleo (usualmente no es necesario re-compilar todo el
ncleo, despus que se hizo una variacin en algn modulo del sistema). Otra
ventaja es que se puede configurar el sistema con un ncleo mnimo, y agregar
controladores mientras se usa, como por ejemplo el montaje de un CD-ROM, etc.
El soporte de mdulos en Linux tiene tres componentes principales:

Gestin de mdulos: Permite cargar mdulos en la memoria y comunicarse
con el resto del sistema.
Registro de controladores: Permite a los mdulos notificar al resto del
ncleo que est disponible un nuevo controlador.
Resolucin de conflictos: Permite a los drivers reservar recursos de
hardware y protegerlos.
19.3.1 Gestindemdulos
La carga de un mdulo no es solo la carga en memoria del ncleo, sino que el
sistema debe asegurarse de que cualquiera referencia que el mdulo haga a
smbolos o puntos de ingreso del ncleo se actualicen de modo que apunten a las
posiciones correctas dentro del espacio de direccionamiento del ncleo. Si el sistema
no puede resolver alguna referencia del mdulo, el mdulo se rechaza.
La carga se efecta en dos etapas:
Se reserva un rea continua de memoria virtual del ncleo para el
mdulo, y se devuelve un puntero a esa direccin.
Se pasa el mdulo junto con la tabla de smbolos al ncleo, copiando el
mdulo sin alteraciones en el espacio previamente asignado.
Otro componente de la gestin de mdulos encontramos el solicitador de mdulos,
que es una interfaz de comunicacin con la cual puede conectarse un programa de
gestin de mdulos. La funcin que cumple es de avisar cuando el proceso necesite
un driver, o sistema de archivo etc., que no este cargado actualmente, y dar la
oportunidad de cargar ese servicio.
19.3.2 Registrodecontroladores
El ncleo mantiene tablas dinmicas de todos los controladores conocidos, y
proporciona un conjunto de rutinas que permite aadir o quitar controladores de de
estas tablas en cualquier momento. Las tablas de registro incluyen los siguientes
elementos:
Drivers de dispositivos: Incluyen los dispositivos de caracteres (impresoras,
teclados), dispositivos por bloques (Disco) y dispositivos de interfaz de red.
Sistemas de archivos: Puede ser cualquier cosa que implemente rutinas de
invocacin del sistema de archivos virtual de Linux.
Protocolos de red: Puede implementar un protocolo de red completo o un
conjunto de reglas de un firewall.
Formato binario: Especifica una forma de reconocer, y cargar, un nuevo tipo
de archivo ejecutable.
209
FINGUDELAR
19.3.3 Resolucindeconflictos
Linux ofrece un mecanismo central de resolucin de conflictos que ayuda a
arbitrar el acceso a ciertos recursos de hardware. Sus objetivos son:
Evitar que los mdulos entren en conflictos al tratar de acceder a recursos de
hardware.
Evitar que los sondeos de drivers que auto detectan la configuracin de un
dispositivo interfieran con los drivers de dispositivos existentes.
Resolver conflictos entre mltiples drivers que tratan de acceder al mismo
hardware.
Para esto el ncleo mantiene una lista de recursos de hardware asignados. Por lo
que si cualquier controlador de dispositivo quiere acceder a un recurso, debe
reservar primero el recurso en la lista del ncleo. Si la reservacin se rechaza, debido
a que esta en uso, corresponde al mdulo decidir cmo proceder.
19.4 Gestindeprocesos
19.4.1 Elmodelodeprocesofork/exec
A diferencia de UNIX, en Linux cualquier programa puede invocar execve en
cualquier momento sin necesidad de crear un proceso nuevo. Bajo Linux la
informacin que contiene un proceso se puede dividir en varias secciones
especficas, descriptas a continuacin.
19.4.1.1 Identidaddelproceso
Consiste en los siguientes elementos:
Identificador del proceso (PID): Es nico y sirve para especificar procesos
al SO. Tambin puede tener identificadores adicionales de grupo.
Credenciales: Cada proceso debe tener asociado un identificador de usuario
y uno o mas identificadores de grupo, que determinan los derechos de acceso
a lo recursos y archivos del sistema que el proceso tiene.
Personalidad: Cada proceso tiene asociado un identificador de personalidad
el cual sirve para modificar un poco las semnticas de ciertas llamadas al
sistema. Sirven para crear compatibilidad con algunos sistemas UNIX.
19.4.1.2 Entornodelproceso
Se hereda del padre y consiste en dos vectores terminados con el carcter nulo:
Vector de argumentos: Lista los argumentos de lnea de rdenes que se
usan para invocar el programa que se esta ejecutando (por convencin
comienza con el nombre del programa del mismo).
Vector de entorno: Es una lista de pares NOMBRE = VALOR que asocia
variables de entorno con nombre a valores de texto arbitrarios.
19.4.1.3 Contextodeunproceso
La identidad del proceso no se cambia en su ejecucin. El contexto es el estado
del programa en ejecucin en cualquier instante dado, y cambia constantemente. Se
divide en:
Contexto de planificacin: Contiene la informacin que el planificador
necesita para suspender y reiniciar el proceso. Se incluye copias guardadas
210
FINGUDELAR
de todos los registros del proceso. Tambin incluye informacin acerca de la

prioridad de planificacin, y de seales pendientes que esperan ser
entregadas al proceso.
Contabilidad: El ncleo mantiene informacin acerca de los recursos que
cada proceso est consumiendo, y el total de recursos que el proceso ha
consumido durante toda su existencia.
Tablas de archivos: Es un arreglo de punteros a estructuras de archivos del
ncleo. Al efectuarse una llamada al sistema para E/S con archivos, los
procesos se refieren a los archivos empleando su ndice en esta tabla.
Contexto del sistema de archivos: Guarda los nombres de los directorios
raz y por omisin que se usarn para buscar archivos.
Tabla de manejadores de seales: Define la rutina invocara cuando
lleguen seales especficas.
Contexto de memoria virtual: Describe todo el contenido del espacio de
direcciones privado de dicho proceso.
19.4.2 ProcesoseHilos
Dos hilos adentro de un proceso, a diferencia de los procesos, comparten el mismo
espacio de direcciones.
El ncleo de Linux maneja de forma sencilla la creacin de hilos y procesos, ya que
utiliza exactamente la misma representacin interna para todos. Un hilo no es ms
que un proceso nuevo que comparte el mismo espacio de direcciones que su padre.
La distincin entre un proceso y un hilo se hace slo cuando se crea un hilo nuevo
con la llamada clone. Mientras que fork crea un proceso nuevo que tiene su
propio contexto totalmente nuevo, clone crea un proceso nuevo que tiene
identidad propia pero que puede compartir las estructuras de datos de su padre.
La llamada al sistema fork es un caso especial de la llamada clone que copia
todos los subcontextos y no comparte ninguno.
19.5 Planificacin
En Linux la planificacin no cumple solo con la funcin de ejecucin e interrupcin
de procesos, sino que tambin tiene asociado la ejecucin de diversas tareas del
ncleo.
19.5.1 Sincronizacindelncleo
La sincronizacin del ncleo implica mucho ms que la simple planificacin de
procesos. Se requiere una estructura que permita la ejecucin de las secciones
crticas del ncleo sin que otra seccin crtica la interrumpa, para que se puedan
ejecutar concurrentemente las tareas del ncleo con las rutinas de servicio de
interrupciones.
La primera tcnica para solucionar el problema radica en hacer no expropiable el
cdigo de ncleo normal. Una vez que un fragmento del cdigo del ncleo comienza
a ejecutarse se puede garantizar que ser el nico cdigo del ncleo que se ejecute
hasta que pase algo de lo siguiente:
Interrupcin: Solo son un problema si sus rutinas de servicio contienen
secciones crticas.
Fallo de pgina: Si una rutina del ncleo trata de leer o escribir la memoria
del usuario, esto podra incurrir en un fallo de pgina, que requiera E/S de
disco y el proceso en ejecucin se suspender hasta que termine la E/S.
211
FINGUDELAR
Llamada al planificador desde el cdigo del ncleo: El proceso se

suspender y habr una replanificacin.
En conclusin con esta tcnica el cdigo del ncleo nunca ser desalojado por otro
proceso, y no es necesario tomar medidas especiales para proteger las secciones
crticas, teniendo como precondicin que las secciones crticas no tenga referencias a
memoria de usuario ni esperas para que termine una E/S.
La segunda tcnica que Linux utiliza para proteger a las secciones crticas es
inhabilitando las interrupciones durante una seccin critica, garantizando que podr
continuar sin que haya peligro de acceso concurrente a estructuras de datos
compartidas. El problema de este sistema es que muy costoso.
Linux plantea una solucin intermedia para poder aplicar secciones crticas largas
sin tener que inhabilitar las interrupciones. Para esto divide en varias partes el
servicio de interrupciones.
Manejadordeinterrupcionesdelamitad
superior
Manejadordeinterrupcionesdemitadinferior
Rutinasdeserviciosdelncleosistema(no
desalojables)
Programasenmodousuario(desalojables)
Cada nivel puede ser

interrumpido por cdigo que se
ejecute en un nivel ms alto, pero
nunca por cdigo del mismo nivel, o
de un nivel inferior, con excepcin
del cdigo en modo de usuario.
19.5.2 Planificacindeprocesos
Linux tiene dos algoritmos de planificacin de procesos independientes:
Algoritmo de tiempo compartido para una planificacin expropiativa
justa entre procesos: Es implementado con prioridad basada en crditos.
Cada proceso tiene un cierto nmero de crditos de planificacin, cuando es
preciso escoger una nueva tarea para ejecutar se selecciona el proceso con
mas crditos. Cada vez que se produce una interrupcin del temporizador el
proceso pierde un crdito, cuando llegan a cero se suspende y se escoge otro
proceso. Adems se tiene una forma de renovacin de crditos en las que se
aaden crditos a todos los procesos del sistema (crdito = crdito /2 +
prioridad).
Algoritmo para tareas en tiempo real en las que las prioridades
absolutas son ms importantes que la equitatividad: Con este sistema
el procesa que entra primero es el proceso que tiene mas prioridad (utiliza
una cola circular), si hay dos con la misma prioridad ejecuta el proceso que ha
esperado mas tiempo. Este planificador es de tiempo real blando, ofrece
garantas acerca de las prioridades pero no acerca de la rapidez.
19.5.3 Multiprocesamientosimtrico
El ncleo de Linux implementa correctamente el multiprocesamiento simtrico
(SMP). La desventaja que tiene, es que procesos e hilos se pueden ejecutar en
paralelo en distintos procesadores, pero no puede estar ejecutndose cdigo del
ncleo en ms de un procesador.
212
FINGUDELAR
19.6 Gestindememoria
La gestin de memoria en Linux tiene dos componentes:
Sistema de gestin de memoria fsica: Se encarga de asignar y liberar
pginas, grupos de pginas y bloques pequeos de memoria.
Sistema de gestin de memoria virtual: Maneja la memoria virtual, que
es memoria que tiene una correspondencia con el espacio de direcciones de
procesos en ejecucin.
19.6.1 Gestindememoriafsica
El administrador primario de memoria fsica es el asignador de pginas, encargado
de asignar y liberar todas las pginas fsicas adems de asignar intervalos de pginas
contiguas fsicamente si se lo solicitan. El asignador utiliza el algoritmo de montculo
de compaeras para saber las pginas que estn disponibles. Si dos regiones
compaeras asignadas quedan libres se combinan para formar una regin ms
grande. Si se solicita una pequea, y no hay, se subdivide recursivamente una
grande, hasta lograr el tamao deseado.
Las funciones del ncleo no tienen que usar el asignador bsico para reservar
memoria, existen otros subsistemas de gestin de memoria especializados, dentro
de ellos encontramos:
Memoria Virtual.
Asignador de longitud variable: Utiliza el asignador de pginas kmalloc, el
cual cumple solicitudes de tamao arbitrario que no necesariamente se
conocen con anticipacin. Este asignador esta protegido contra
interrupciones.
El cache de buffer: Es el cache principal del ncleo para dispositivos
orientados a bloques.
El cache de pginas: Almacena pginas enteras del contenido de archivos,
de todo tipo de dispositivos (no solo bloques).
Los tres sistemas interactan entre ellos.
19.6.2 Memoriavirtual
Se encarga de mantener el espacio de direcciones visible para cada proceso. Se
crean pginas por solicitud. Mantiene dos vistas del espacio de direcciones:
Vista lgica: Consiste en un conjunto de regiones que no se traslapan. Cada
regin se describe internamente como una sola estructura que define las
propiedades (lectura, escritura, etc.). Las regiones se enlazan en un rbol
binario balanceado.
Vista fsica: Almacena las tablas de pginas de hardware para el proceso.
Guardan la ubicacin exacta de la pgina, que puede estar en disco o
memoria. Cada direccin de la tabla guarda un puntero a una tabla de
funciones que controla el espacio de memoria indicado.
19.6.2.1 Regionesdememoriavirtual
Hay varios tipos dependiendo de las propiedades:
Almacenamiento auxiliar: Describe el origen de las pginas de una regin.
Se puede respaldar en un archivo, o no respaldar (tipo ms sencillo de
memoria virtual).
Reaccin a las escrituras: La correspondencia entre una regin y el espacio
de direcciones del proceso puede ser privada o compartida.
213
FINGUDELAR
Privada: Se requiere copiar al escribir para que los cambios sean

locales al proceso.
Compartida: Se actualiza para que todos los procesos vean de
inmediato la modificacin.
19.6.2.2 Tiempodevidadeunespaciodedireccionesvirtual
Hay dos formas de crear procesos:
ec:Secreaunespaciodedireccionesvirtualnuevo.
Fork: Se copia el espacio de direcciones de un proceso existente (el padre).

Cuando debo copiar una regin de correspondencia privada, las
modificaciones que hagan el hijo y el padre son privadas, por lo tanto la
pgina se debe marcar como solo lectura, para que se deba realizar una
copia antes de modificarla.
19.6.2.3 Intercambioypaginacin
Los primeros sistemas UNIX intercambian a disco procesos enteros. Actualmente
se intercambian pginas. El sistema de paginacin se divide en dos secciones:
Algoritmo de poltica: Decide que pginas pasar a disco y cuando
escribirlas.
Mecanismo de paginacin: Transfiere la pgina a memoria cuando se la
necesita.
Linux emplea un mecanismo modificado del algoritmo de segunda oportunidad.
19.6.2.4 Memoriavirtualdelncleo
Linux reserva para el ncleo una regin constante, que depende de la
arquitectura, y las entradas de la tabla de pginas correspondiente a esa zona, se
marcan como protegidas. Esta rea contiene dos regiones:
Esttica: Contiene referencias de tabla de pginas, a cada pgina de
memoria fsica disponible en el sistema, para traducir fcilmente direcciones
fsicas en virtuales cuando se ejecuta cdigo del ncleo.
Sin propsito especfico: El ncleo en esta zona puede modificar entradas
de tabla de pginas para que apunten donde quiera.
19.6.3 Ejecucinycargadeprogramasdeusuario
La ejecucin se dispara con la llamada al sistema exec, que ordena ejecutar un
programa nuevo dentro del proceso actual. Las tareas del SO son:
1. Verificar que el proceso invocador tenga permiso de hacerlo.
2. Invocar la rutina de carga para iniciar la ejecucin del programa.
No hay una nica rutina de carga sino que Linux mantiene una tabla de rutinas
cargadoras, ya que en la evolucin de Linux, se cambi el formato de los archivos
binarios. Antiguamente el formato era .out, actualmente es ELF, que es ms flexible y
extensible.
19.6.4 Correspondenciaentrelosprogramasylamemoria
214
FINGUDELAR
memoriavirtualdelncleo
memoriainvisibleparacdigoenmododeusuario
pila
regindecorrespondenciaconlamemoria
Organizacindela
memoriapara
programasELF
elpunterobrk
datosdetiempodeejecucin
datossinvaloresiniciales
datosconvaloresiniciales
textodelprograma
reginprohibida
Al comenzar la ejecucin, no se carga el programa en memoria fsica, sino que se

establece la correspondencia entre las pginas del archivo binario, y las regiones de
memoria virtual. Solo cuando el programa trata de acceder a una pgina, se genera
un fallo de pgina, y se la trae a la memoria fsica.
El formato ELF consiste en una cabecera seguida de varias secciones alineadas
con pginas. El cargador lee la cabecera y establece correspondencia entre las
secciones del programa y la memoria virtual.
19.6.4.1 Enlazadoestticoydinmico
Luego de cargar el programa, tambin se necesita cargar en memoria las
funciones del sistema que utiliza este programa. En el caso ms sencillo, ests se
incrustan en el cdigo binario (enlace esttico) con el problema que se repite gran
cantidad de cdigo entre todos los programas. El enlace dinmico soluciona este
problema.
Linux implementa el enlace dinmico a travs de una biblioteca. Cuando enlazo el
programa, se coloca en l un pequeo programa con instrucciones para cargar esas
bibliotecas que necesita.
Las bibliotecas se compilan en cdigo independiente de la posicin (PIC) que se
puede ejecutar en cualquier direccin de memoria.
Usa el sistema de archivos estndar de UNIX. Un archivo no tiene que ser un
objeto, sino que puede ser cualquier cosa capaz de manejar la entrada y salida de
datos, como por ejemplo un driver.
A travs de una capa de software, el sistema de archivos virtual (VFS) se encarga
de abstraer sus peculiaridades.
19.7.1 Elsistemadearchivosvirtual
Est orientado a objetos y tiene dos componentes:
Definiciones sobre el aspecto del archivo. Los tres tipos principales de objetos
son:
i-nodo, objeto archivo: Son mecanismos empleados para acceder a
archivos.
i-nodo: Representa el archivo como un todo. Mantiene
informacin estndar acerca del archivo.
objeto archivo: Representa un punto de acceso a los datos del
archivo.
Objeto sistema de archivos: Representa un conjunto conectado de
archivos que forma una jerarqua de directorios, y su principal
obligacin es dar acceso a los i-nodos.
215
FINGUDELAR
Capa de software para manejar dichos objetos.
Se define un conjunto de operaciones que cada uno de los tres tipos debe
implementar, as la capa de software, puede realizar funciones sobre los objetos
independientemente de su tipo.
Los archivos de directorio en Linux se manejan de una forma un tanto diferente a
los dems archivos, por lo tanto tienen definidas operaciones especficas.
19.7.2 ElsistemadearchivosLinuxext2fs
Es similar al ffs (fast file system) de BSD. Los archivos de directorio se almacenan
en disco, al igual que los archivos normales, pero su contenido se interpreta de
diferente manera.
Ext2fs no usa fragmentos, sino que realiza todas sus asignaciones en unidades
ms pequeas. El tamao del bloque es de 1kb (aunque tambin se manejan bloques
de 2 y 4 Kb). Est dividido en grupos de bloques, y dentro de ellos, el planificador
trata de mantener las asignaciones fsicamente contiguas, tratando siempre de
reducir la fragmentacin. Adems la fragmentacin se compensa con que los bloques
estn cercanos, por lo tanto no es necesario mover mucho la cabeza del disco para
leerlos a todos.
19.7.3 ElsistemadearchivosprocdeLinux
El sistema de archivos de procesos es un sistema de archivos cuyo contenido no
est almacenado realmente en ninguna parte sino que se calcula bajo demanda,
segn las solicitudes de E/S de los usuarios.
Cada subdirectorio no corresponde a un directorio de disco, sino a un proceso
activo del sistema, y el nombre del directorio es la representacin ASCII del PID del
proceso.
De esta forma se puede dar un listado de todos los procesos activos con
solamente la llamada al sistema ps.
19.8 Entradaysalida
Los drivers de dispositivos son archivos, por lo tanto un usuario puede abrir un
canal de acceso a un dispositivo de la misma forma que puede abrir cualquier otro
archivo. Adems, puede utilizar el mismo sistema de proteccin de archivos para
proteger los dispositivos.
Linux divide todos los dispositivos en tres clases:
Dispositivos por bloques: Suelen usarse para almacenar sistemas de
archivos, pero tambin se permite el acceso directo a estos dispositivos para
que los programas puedan crear y reparar el sistema de archivos que el
dispositivo contiene.
Dispositivos por caracteres: No necesitan apoyar toda la funcionalidad de
los archivos normales. Por ejemplo, es til manejar una bsqueda en un
dispositivo de cinta, pero no en un mouse.
Dispositivos de red: Se tratan de manera diferente. Los usuarios no pueden
transferir datos directamente, sino que deben abrir una conexin.
19.8.1 Dispositivosporbloques
Para asegurar un rpido acceso a los discos se utiliza el cache de buffers de
bloques y el gestor de solicitudes.
216
FINGUDELAR
19.8.1.1 Elcachedebuffersporbloques
El cache de buffers sirve como reserva de buffers para E/S activa y como cache
para la E/S finalizada.
El cache de buffers cuenta con dos partes:
Los buffers mismos: Son un conjunto de pginas cuyo tamao
cambia dinmicamente y se asignan desde la reserva de memoria principal
del ncleo. Cada pgina se divide en varios buffers de igual tamao.
Los buffer_heads: Son un conjunto de descriptores de buffers de
cache. Contienen la informacin que el ncleo tiene acerca de los buffers (el
dispositivo al que pertenece el buffer, la distancia entre los datos dentro de
ese dispositivo, y el tamao del buffer).
Los buffers son guardados en diferentes tipos de listas: para buffers limpios,
sucios, bloqueados y libres. Hay dos demonios en segundo plano que ayudan a
escribir los buffers sucios. Uno se despierta a intervalos regulares, y escribe los
buffers que han estado sucios por un determinado tiempo. El otro es un hilo del
ncleo que se despierta cuando hay una proporcin demasiado alta del cache de
buffers que est sucia.
19.8.1.2 Elgestordesolicitudes
Es la capa de software que controla la lectura y escritura del contenido de los
buffers de y a un driver de dispositivo por bloque.
Se mantiene una lista individual de solicitudes para cada controlador de
dispositivo por bloques, y las solicitudes se planifican segn el algoritmo C-SCAN.
A medida que se hacen nuevas solicitudes de E/S, el gestor intenta fusionar las
solicitudes de las listas por dispositivo, pasando de varias solicitudes pequeas, a
una grande.
Se pueden hacer solicitudes de E/S que pasen por alto el cache de buffers, y se
usa generalmente en el ncleo, y en memoria virtual.
19.8.2 Dispositivosporcaracteres
El ncleo prcticamente no preprocesa las solicitudes de leer o escribir en un
dispositivo por caracteres, y se limita a pasar la solicitud al dispositivo en cuestin
para que l se ocupe de ella.
19.9 ComunicacinentreProcesos
19.9.1 Sincronizacinyseales
Para informar a un proceso que sucedi un suceso se utiliza una seal. Este
sistema tiene la desventaja de que el nmero de seales es limitado y estas no
pueden enviar informacin, solo puede comunicar a un proceso el hecho de que
ocurri un suceso.
El ncleo de Linux no usa seales para comunicarse con los procesos que se estn
ejecutando en modo de ncleo. Generalmente hay una cola de espera para cada
suceso, y cuando ese suceso se produce, despierta todos los procesos que estn en
esa cola.
Otra forma que utiliza Linux como comunicacin son los semforos.
217
FINGUDELAR
19.9.2 Transferenciadedatosentreprocesos
Linux ofrece el mecanismo pipe (conducto) que permite a un proceso hijo heredar
un canal de comunicacin con su padre.
La memoria compartida ofrece un mecanismo extremadamente rpido para
comunicar cantidades grandes o pequeas de datos. Pero tiene como desventaja que
no ofrece mecanismo de sincronizacin, por lo cual es recomendable usarla con
algn otro mtodo de sincronizacin.
19.10 Estructuraderedes
Linux apoya tanto los protocolos estndar de Internet de UNIX y de otros SO. El
trabajo de redes se implementa con tres capas de software:
Interfaz de sockets: Las aplicaciones de usuario efectan todas las
solicitudes de trabajo con redes a travs de esta interfaz.
Controladores de protocolos: Cada vez que llegan datos de trabajo con
redes a esta capa, se espera que los datos estn etiquetados con un
identificador que indique el protocolo de red. Cuando termina de procesar los
paquetes, los enva a la siguiente capa. Decide a que dispositivo debe enviar
el paquete.
Drivers de dispositivos de red: Codifican el tipo de protocolo de diferentes
maneras dependiendo de su medio de comunicacin.
Los paquetes de IP se entregan al controlador de IP. Este debe decidir hacia donde
est dirigido el paquete, y remitirlo al driver de protocolo indicado. El software de IP
pasa por paredes cortafuegos, filtrando los paquetes para fines de seguridad.
Otras funciones son el desensamblado y reensamblado de paquetes grandes, para
poder encolarlos en dispositivos en fragmentos ms pequeos si no pueden ser
encolados por su tamao.
19.11 Seguridad
Los problemas de seguridad se pueden clasificar en dos grupos:
Validacin: Asegurarse de que solo personas autorizadas puedan ingresar al
sistema.
Control de acceso: Proporcionar un mecanismo para verificar si un usuario
tiene derechos suficientes para acceder a un objeto dado.
19.11.1 Validacin
La contrasea de un usuario se combina con un valor aleatorio y resultado se
codifica con una funcin de transformacin unidireccional (esto implica que no es
posible deducir la contrasea original a partir del archivo de contrasea) y se
almacena en el archivo de contraseas. Cuando el usuario la ingresa, se vuelve a
codificar, y se busca en el archivo codificado para ver si coincide.
19.11.2 Controldeacceso
Se realiza con la ayuda de identificadores numricos nicos. El uid identifica un
solo usuario o un solo conjunto de derechos de acceso, y un gid es un identificador
de grupo. Cada objeto disponible en el sistema que esta protegido por los
mecanismos de control de acceso por usuario y grupo tiene asociado un solo uid y un
solo gid.
Linux efecta el control de acceso a los objetos mediante una mascara de
proteccin, que especifica cules modos de acceso (lectura, escritura, o ejecucin)
218
FINGUDELAR
habrn de otorgarse a procesos con acceso de propietario, acceso a grupos o al
mundo. Otros de los mecanismos que ofrece es el setuid, el cual permite a un
programa ejecutarse con privilegios distintos de los que tiene el usuario que ejecuta
el programa.
Examen julio 2004:
Explique brevemente para que sirve el bit de setuid en Unix.
Respuesta:
Si un ejecutable tiene el SETUID encendido, y lo ejecuta un usuario distinto al que lo cre, el
nuevo proceso tendr, en efectividad, el UID del usuario dueo del ejecutable. Esto sirve, por
ejemplo, para dar un acceso controlado, mediante un ejecutable, a dispositivos de E/S o
archivos privilegiados. Por ejemplo, el comando de cambio de password es propiedad de un
superusuario, tiene el bit SETUID encendido, y actualiza un archivo de passwords. Sin SETUID,
habra que prohibir a los usuarios que cambien su propia password, o darle demasiados permisos
a ese archivo.
219
FINGUDELAR
20 WindowsNT
Es un sistema operativo multitareas, expropiativo de 32 bits para
microprocesadores modernos. NT se puede trasladar a varias arquitecturas, y hasta
la versin 4 no es multiusuario.
Las dos versiones de NT son Windows NT Workstation y Windows NT Server.
Ambas usan el mismo cdigo para el ncleo y el sistema, pero el Server est
configurado para aplicaciones cliente-servidor.
20.1 Historia
A mediados de los 80s Microsoft e IBM cooperaron para desarrollar OS/2, escrito
en lenguaje ensamblador para sistemas monoprocesador Intel 80286.
En 1988 Microsoft decidi desarrollar un sistema porttil que apoyara las
interfaces de programacin de aplicaciones (API). Se supona que NT utilizara la API
de OS/2, pero utiliz la Win32 API.
Las primeras versiones fueron Windows NT 3.1 y 3.1 Advanced Server. En la
versin 4, NT adopt la interfaz con el usuario de Windows 95, e incorpor software
de servidor de Web en Internet y de navegador. Se pasaron al ncleo algunas rutinas
de interfaz con el usuario y cdigo de grficos a fin de mejorar el desempeo, con el
efecto secundario de disminucin en la confiabilidad del sistema.
20.2 Principiosdediseo
Los objetivos clave del sistema son transportabilidad, seguridad, soporte a
multiprocesadores, extensibilidad, soporte internacional y compatibilidad con
aplicaciones MS-DOS y MS-Windows.
Extensibilidad: Se implement con una arquitectura de capas a fin de

mantenerse al da con los avances tecnolgicos. El ejecutivo NT que opera en
modo protegido, proporciona los servicios bsicos, y encima operan varios
subsistemas servidores en modo usuario, entre los cuales se encuentran los
subsistemas de entorno o ambiente que emulan diferentes sistemas
operativos. Es posible aadir nuevos subsistemas de entorno fcilmente,
adems NT utiliza controladores cargables, para poder cargar nuevos
sistemas de archivos, dispositivos de E/S, etc, mientras el sistema est
trabajando.
Transportabilidad: Casi todo el sistema fue escrito en C y C++, al igual que
UNIX, y todo el cdigo que depende del procesador est aislado en una DLL
llamada capa de abstraccin de hardware (HAL). Las capas superiores de NT
dependen de la HAL y no del hardware, ayudando a la portabilidad.
Confiabilidad: Emplea proteccin por hardware para la memoria virtual y por
software para los recursos del SO. Posee tambin un sistema de archivos
propio (NTFS) que se recupera automticamente de muchas clases de errores
del sistema de archivos despus de una cada del sistema.
Compatibilidad: Ofrece compatibilidad en el nivel de fuente (se compilan sin
modificar el cdigo fuente) con aplicaciones que cumplen el estndar IEEE
1003.1 (POSIX). Ejecuta tambin binarios de muchos programas compilados
para Intel X86. Esto se logra mediante los subsistemas de entorno antes
mencionados, aunque la compatibilidad no es perfecta, ya que por ejemplo,
MS-DOS permita accesos directos a los puertos de hardware y NT prohbe tal
acceso.
220
FINGUDELAR
Desempeo: Los subsistemas se comunican de forma eficiente llamando a

procedimientos locales que transfieren mensajes con gran rapidez.
Uso internacional: Cuenta con soporte para diferentes ubicaciones a travs
de la API de soporte a idiomas nacionales (NLS). El cdigo de caracteres
nativo es UNICODE, aunque reconoce caracteres ANSI, convirtindolos en
UNICODE (8 bytes a 16 bytes).
20.3 Componentesdelsistema
La arquitectura NT es un
sistema de mdulos en capas.
Una de las principales ventajas
de este tipo de arquitectura es que
las interacciones entre los mdulos
son relativamente sencillas.
20.3.1 Capadeabstraccinde
hardware
procesologon
aplicaciones
OS/2
aplicaciones
Win16
subsistemade
seguridad
subsistema
OS/2
VDMWin16
aplicaciones
WIn32
aplicaciones
MSDOS
aplicaciones
POSIX
VDMMS
DOS
subsistema
POSIX
paquetede
validacin
basededatosde
seguridadgestorde
cuentas
subsistema
Win32
Es una capa de software que

oculta las diferencias de hardware
para que no las perciban los
gestordeE/S
monitorde
gestorde
niveles superiores, y lograr
gestorde
gestorde
referenciasde
memoria
objetos
procesos
seguridad
virtual
sistemadearchivos
portabilidad. Es usada por el
gestordechach
ncleo y los drivers de dispositivos,
driversde
dispositivos
ncleo
por lo tanto solo se necesita una
controladoresdered
versin de cada driver, para las
capadeabstraccindehardware
diferentes plataformas de
hardware.
hardware
Por razones de desempeo, los
controladores de E/S y de grficos acceden directamente al hardware.
mododeusuario
recursode
llamadasa
procedimientos
locales
mododencleo
20.3.2 Ncleo
Constituye los cimientos del ejecutivo y los subsistemas. Siempre est cargado en
memoria principal.
Tiene cuatro obligaciones principales:
Planificacin de hilos
Manejo de interrupciones y excepciones
Sincronizacin de bajo nivel del procesador
Recuperacin despus de una cada en el suministro de electricidad
Est orientado a objetos. Los objetos estn definidos por el sistema, y tiene
atributos y mtodos.
Windows NT, tambin maneja los conceptos de hilos y procesos. El proceso tiene
un espacio de direcciones en memoria virtual, informacin sobre prioridad, y afinidad
por uno o ms procesadores.
Cada proceso tiene uno o ms hilos, y cada hilo tiene su propio estado, que
incluye prioridad, afinidad de procesador e informacin de contabilidad.
Estados de los hilos:
221
FINGUDELAR
Listo: Espera para ejecutarse.

A punto: El hilo listo con la prioridad ms alta se pasa a este estado,
implicando que ser el siguiente hilo en ejecutarse. Se mantiene un hilo a
punto para cada procesador, en un sistema multiprocesador.
Ejecutndose: Se ejecuta n un procesador hasta ser desalojado por un hilo
de ms alta prioridad, hasta terminar, hasta que se agote su cuanto de
tiempo o hasta que necesite E/S.
Esperando: Espera una seal, como por ejemplo el fin de E/S.
Transicin: Espera los recursos necesarios para ejecutarse.
Terminado: Termin su ejecucin.
El despachador tiene un esquema de 32 niveles de prioridad, dividido en dos

clases:
Tiempo real: Hilos con prioridad de 16 a 31.
Clase variable: Hilos con prioridad de 0 a 15.
El despachador usa una cola para cada prioridad, y las recorre de mayor a menor,
buscando el primer hilo listo a ser ejecutado. Cuando se agota el cuanto de un hilo,
se interrumpe, y si el hilo es de prioridad variable, la prioridad se reduce, aunque
nunca por debajo de la prioridad base.
Cuando un hilo de prioridad variable sale del estado de espera, se aumenta su
prioridad. Esta estrategia tiende a mejorar los tiempos de respuesta de los hilos
interactivos que estn usando el ratn y las ventanas, manteniendo los dispositivos
de E/S ocupados por los hilos limitados por E/S, y que los hilos limitados por CPU,
acten en segundo plano con los ciclos de CPU sobrantes. Adems, la ventana actual
con la que el usuario est interactuando, recibe un aumento de prioridad para reducir
su tiempo de respuesta.
Si un hilo de tiempo real, con prioridad ms alta queda listo mientras se ejecuta
un hilo con mas baja prioridad, ste es desalojado, por lo tanto la expropiacin
proporciona acceso preferencial al CPU a los hilos de tiempo real, sin embargo, no se
pueden garantizar que se cumplan los lmites de tiempo, y por ello NT no es un
sistema de tiempo real duro.
El ncleo tambin maneja trampas para excepciones e interrupciones por
hardware o software. NT define excepciones independientes de la arquitectura como
violacin de acceso a memoria, desbordamiento de enteros, desbordamiento hacia
infinito o cero de punto flotante, divisin entera entre cero, divisin punto flotante
entre cero, instruccin no vlida, falta de alineacin de datos, instruccin
privilegiada, error de lectura de pgina, violacin de pgina guardia, etc.
El manejador de trampas se encarga de excepciones sencillas, y el despachador
de excepciones del ncleo se encarga de las dems, buscando manejadores que se
encarguen de ellas. Cuando ocurre una excepcin en modo de ncleo, si no se
encuentra el manejador correcto, ocurre un error fatal del sistema, presentando la
pantalla azul que significa, fallo del sistema.
El ncleo utiliza una tabla de despacho de interrupciones para vincular cada nivel
de interrupcin con una rutina de servicio, y en un computador multiprocesador, NT
mantiene una tabla para cada procesador.
NT se puede ejecutar en mquinas con multiprocesadores simtricos, por lo tanto
el ncleo debe evitar que dos hilos modifiquen estructuras de datos compartidas al
mismo tiempo. Para lograr la mutua exclusin, el ncleo emplea cerraduras giratorias
que residen en memoria global. Debido a que todas las actividades del procesador se
suspenden cuando un hilo intenta adquirir una cerradura giratoria, se trata que sea
liberada lo ms rpido posible.
222
FINGUDELAR
20.3.3 Ejecutivo
Presta un conjunto de servicios que los subsistemas de entorno pueden usar.
20.3.3.1 Gestordeobjetos
NT es un sistema orientado a objetos, y el gestor supervisa su uso. Cuando un hilo
desea usar un objeto, debe invocar el mtodo open del gestor de objetos, para
obtener un handle para ese objeto. Adems el gestor se encarga de verificar la
seguridad, verificando si el hilo tiene derecho de acceder a ese objeto. El gestor
tambin se mantiene al tanto de que procesos estn usando cada objeto. Se encarga
de eliminar objetos temporales cuando ya no hay referencias a ellos (Nota: algo del
estilo garbageCollector).
20.3.3.2 Nombresdeobjetos
NT permite dar nombres a los objetos. El espacio de nombres es global, por lo
tanto un proceso puede crear un objeto con nombre, y otro, puede hacer un handle
hacia l, y compartirlo con el primer proceso. El nombre puede ser temporal o
permanente. Uno permanente representa entidades, como unidades de disco que
existe aunque ningn proceso lo est usando. Los temporales existen mientras
alguien haga referencia a ellos (Nota: no sobreviven al garbageCollector).
Los nombres de objeto tienen la misma estructura que los nombres de camino de
archivos en MS-DOS y UNIX. Los directorios se representan con un objeto directorio,
que contiene los nombres de todos los objetos de ese directorio.
El espacio de nombres de objetos aumenta al agregar un dominio de objetos,
como por ejemplo discos flexibles y duros, ya que estos tienen su propio espacio de
nombres que se debe injertar en el espacio de nombres existente.
Al igual que UNIX, NT implementa un objeto de enlace simblico, refirindose a un
mismo archivo con varios seudnimos o alias, como por ejemplo la correspondencia
de nombres de unidades en NT, con las letras de unidad estndar de MS-DOS.
Cada proceso crea handle a varios objetos, los cuales son almacenados en una
tabla de objetos del proceso, y al terminar, NT cierra automticamente todos esos
handle.
Cada objeto est protegido por una lista de control de acceso que contiene los
derechos de acceso. El sistema los compara con los derechos de acceso del usuario
que intenta acceder al objeto, y verifica si puede hacerlo. Esta verificacin solo se
hace al abrir el objeto, y no al crear un handle, por lo tanto los servicios internos de
NT que usan handle, pasan por alto la verificacin de acceso.
20.3.3.3 Gestordememoriavirtual
El diseador del gestor, supone que el hardware apoya la correspondencia virtual
a fsica, un mecanismo de paginacin y coherencia de cache transparente en
sistemas multiprocesador, y que permite hacer que varias entradas de la tabla de
pginas, correspondan al mismo marco de pgina.
Utiliza un esquema de gestin basado en pginas con un tamao de 4 KB, y usa
direcciones de 32 bits, por lo tanto cada proceso tiene un espacio de direcciones
virtual de 4GB. Los 2 GB superiores son idnticos para todos los procesos, y NT los
usa en modo ncleo. Los 2GB inferiores son distintos para cada proceso y son
accesibles en modo usuario o ncleo.
Dos procesos pueden compartir memoria obteniendo handle para el mismo objeto,
pero sera ineficiente ya que los dos deberan reservar el espacio de memoria, antes
223
FINGUDELAR
de poder acceder al objeto. Para ello se cre el objeto seccin que representa un
bloque de memoria compartida, y que se maneja con handle.
Un proceso puede controlar el uso de un objeto en memoria compartida. Puede
protegerse de modo lectura-escritura, solo lectura, solo ejecucin, pgina guardia y
copiar al escribir. La pgina guardia genera una excepcin si es accedida, y sirve por
ejemplo para controlar si un programa defectuoso va ms all del tope de un arreglo.
El mecanismo de copiar al escribir, permite ahorrar memoria, ya que si dos procesos
desean copias independientes de un mismo objeto, coloca una sola copia compartida
en la memoria, activando la propiedad de copiar al escribir en esa regin de
memoria, y si uno de los objetos desea modificar los datos, el gestor hace primero
una copia privada de la pgina para que ese proceso la use.
La traduccin de direcciones virtuales de NT usa varias estructuras de datos. Cada
entradade
directorio
depginas
0
entradade
tablade
pginas
0
pginade
4K
tabladepginas0
directoriodepginas
entradade
directorio
depginas
1023
entradade
tablade
pginas
1023
entradade
tablade
pginas
0
pginade
4K
pginade
4K
tabladepginas1023
entradade
tablade
pginas
1023
pginade
4K
proceso tiene un directorio de pginas que contiene 1024 entradas de directorio de

pginas (PDE) de cuatro bytes cada una. El directorio es privado, pero podra
compartirse entre procesos si fuera necesario.
Cada entrada de directorio, apunta a una tabla de pginas que contiene 1024
entradas de tabla de pginas (PTE) de cuatro bytes cada una, y cada entrada de
tabla de pginas apunta a un marco de pgina de 4 KB en la memoria fsica.
31
0
Una direccin de memoria
virtual de 32 bits se divide en tres
enteros. Los primeros 10 son el
PDE
PTE
distanciadepgina
ndice de directorio de pgina,
seleccionando la entrada al
directorio de pginas que apunta a
una tabla de pginas.
Los siguientes 10 bits sirven para escoger una PTE de esa tabla de pginas, la cual
apunta a un marco de pgina en la memoria fsica.
Los restantes 12 bits se usan para describir la pgina.
La pgina puede estar en seis estados:

Vlida: Usada por un proceso activo.
Libre: No se hace referencia en ninguna PTE.
En ceros: Pgina libre, con ceros, lista para usarse de inmediato.
A punto: Ha sido eliminada del conjunto de trabajo de un proceso.
Modificada: Se ha escrito pero todava no se copi en disco.
Defectuosa: No puede utilizarse porque se detect un error de hardware.
224
FINGUDELAR
El principio de localidad dice que cuando se usa una pgina, es probable que en
un futuro cercano, se haga referencia a pginas adyacentes, por lo tanto, cuando se
produce un fallo de pgina, el gestor de memoria, tambin trae las pginas
adyacentes, a fin de reducir nuevos fallos.
Si no hay marcos de pgina disponibles en la lista de marcos libres, NT usa una
poltica de reemplazo FIFO por proceso para expropiar pginas.
NT asigna por defecto 30 pginas a cada proceso. Peridicamente va robando una
pgina vlida a cada proceso, y si el proceso se sigue ejecutando sin producir fallos
por falta de pgina, se reduce el conjunto de trabajo del proceso, y se aade la
pgina a la lista de pginas libres.
20.3.3.4 Gestordeprocesos
Presta servicios para crear, eliminar y usar hilos y procesos. No tiene conocimiento
de las relaciones padre-hijo ni de jerarquas de procesos.
20.3.3.5 Recursodellamadasaprocedimientoslocales
El LPC (local procedure call) sirve para transferir solicitudes y resultados entre
procesos clientes y servidores dentro de una sola mquina. En particular se usa para
solicitar servicios de los diversos subsistemas de NT. Es un mecanismo de
transferencia de mensajes. El proceso servidor publica un objeto puerto de conexin
que es visible globalmente. Cuando un cliente desea servicios de un subsistema,
abre un handle (mango) al objeto puerto de conexin de ese subsistema, y le enva
una solicitud de conexin. El servidor crea un canal, y le devuelve un handle al
cliente.
El canal consiste en un par de puertos de comunicacin privados, uno para los
mensajes del cliente al servidor, y otro para los del servidor al cliente.
Hay tres tcnicas de transferencia de mensajes para el canal LPC:
Mensajes pequeos: Para mensajes de hasta 256 bytes. Se usa la cola de
mensajes del puerto como almacenamiento intermedio, y los mensajes se
copian de un proceso al otro.
Mensajes medianos: Se crea un objeto seccin de memoria compartida para el
canal, y los mensajes del puerto, contienen un puntero, e informacin de
tamao referidos a ese objeto seccin, evitando la necesidad de copiar
mensajes grandes.
Mensajes LPC, o LPC rpida: Es utilizado por las porciones de exhibicin
grafica del subsistema Win32. Cuando un cliente pide LPC rpida, el servidor
prepara tres objetos: Un hilo servidor, dedicado a atender solicitudes, un
objeto seccin de 64KB y un objeto par de sucesos, que es un objeto de
sincronizacin para Win32, que notifica cuando el hilo cliente copio un
mensaje en el servidor o viceversa.
o Ventajas:
El objeto seccin elimina el copiado de mensajes, ya que
representa memoria compartida.
El objeto par de sucesos elimina el gasto extra de utilizar el
objeto para transferir punteros y longitudes.
El hilo servidor elimina el gasto extra de determinar que hilo
cliente est llamando al servidor ya que hay un hilo servidor por
cada cliente.
o Desventajas:
225
FINGUDELAR
Se utilizan ms recursos que con los otros mtodos, por lo tanto

solo se usa para el gestor de ventanas e interfaces con
dispositivos de grficos.
20.3.3.6 GestordeE/S:
Funciones:
Se mantiene al tanto de cuales sistemas de archivos instalables estn
cargados.
Gestiona buffers para solicitudes de E/S
Trabaja con el gestor de caches de NT que maneja los caches de todo el
sistema de E/S.
Trabaja con el gestor de Memoria Virtual para efectuar E/S de archivos con
correspondencia en la memoria.
Apoya operaciones de E/S, sincrnicas y asincrnicas.
Proporciona tiempos lmite para los controladores, y cuenta con mecanismos
para que un controlador llame a otro.
En muchos sistemas operativos, el sistema de archivos se encarga de manejar los
cache, en cambio NT cuenta con un manejo de caches centralizado. El gestor de
cache presta servicios, controlado por el gestor de E/S, e ntimamente vinculado con
el gestor de VM.
Los 2GB superiores del espacio de direcciones de un proceso, son del sistema, y el
gestor de VM asigna la mitad del espacio disponible al cache del sistema.
Cuando el gestor de E/S recibe una solicitud de lectura, enva un IRP al gestor de
caches (a menos que se solicite lectura sin uso de cache). El gestor de cache calcula
la direccin de la solicitud, y pueden suceder dos cosas con el contenido de la
direccin:
Es nula: asigna un bloque al cache e intenta copiar los datos invocados.
Se puede realizar el
Proceso
copiado: La operacin
finaliza.
E/S
No se puede realizar el
gestordeE/S
copiado: Se produjo un
E/Sporcach
sistemadearchivos
gestordecachs
fallo de pgina, lo que
hace que el gestor de VM
E/Ssincach
copiadodedatos
enve una solicitud de
fallodepgina
controladordedisco
gestordeVM
lectura sin uso del cache.
El driver apropiado, lee los
datos, y los devuelve al
gestor de VM, que carga los datos en el cache, y los devuelve al
invocador, quedando satisfecha la solicitud.
No es nula: Se leen los datos y la operacin finaliza.
Para mejorar el desempeo, el gestor mantiene un historial de solicitudes de
lectura, e intenta predecir solicitudes futuras. Si detecta un patrn en las tres
solicitudes anteriores, como acceso secuencial hacia delante o atrs, obtiene datos y
los coloca en el cache, antes de que la aplicacin haga la siguiente solicitud, evitando
la espera de leer a disco.
El gestor tambin se encarga de indicar al gestor de VM que escriba de vuelta en
disco el contenido del cache. Efecta escritura retardada, ya que acumula escrituras
226
FINGUDELAR
durante 4 o 5 segundos, y luego despierta el hilo escritor. Si sucede que un proceso
escribe rpidamente llenando las pginas libres del cache, el gestor est
controlando, y cuando se llena gran parte de las pginas, bloquea los procesos que
escriben datos, y despierta el hilo escritor.
En el caso de redes, para que no queden procesos bloqueados en la red (causando
retransmisin por exceso de tiempo), se puede ordenar al gestor de cache que no
deje que se acumulen muchas escrituras en el cache. Hay una interfaz DMA directa
entre el cache y la red, evitando el copiado de datos a travs de un buffer
intermedio.
20.3.3.7 Gestordereferenciasdeseguridad
La naturaleza orientada a objetos de NT permite la validacin de accesos durante
la ejecucin y verificaciones de auditoria para cada entidad del sistema.
20.4 Subsistemasdeentorno
Son procesos en modo usuario, apilados sobre los servicios nativos del ejecutivo
de NT, que permiten ejecutar programas escritos para otros sistemas operativos,
incluidos Windows de 16 bits, MS-DOS, POSIX y aplicaciones basadas en caracteres
para el OS/2 de 16 bits. Cada subsistema de entorno, proporciona una API.
NT usa el subsistema Win32 como entorno operativo principal. Si el ejecutable no
es Win32 nativo, se verifica si ya se est ejecutando el subsistema de entorno
apropiado, y si no se est ejecutando, se pone en marcha como proceso en modo
usuario y Win32 le transfiere el control a dicho subsistema.
El subsistema de entorno no accede directamente al ncleo, contribuyendo a la
robustez de NT, ya que se permite controlar la correctitud de los parmetros antes
de invocar la rutina del ncleo. NT prohbe a las aplicaciones, mezclar rutinas de API
de diferentes entornos.
La cada de un subsistema, no afecta a los dems, salvo el caso de Win32 que es
el gestor de todos los dems.
Win32 clasifica las aplicaciones como grficas o de caracteres (se supone que las
salidas se dirigen a una pantalla ASCII de 80x24). Cuando es de caracteres,
transforma la salida, en una representacin grfica dentro de una ventana (Caso de
la ventanita de MS-DOS, en el escritorio de Windows). Al ser una emulacin, se puede
transferir texto de pantalla entre ventanas, a travs del portapapeles.
20.4.1 EntornoMSDOS
MS-DOS no tiene la complejidad de los otros subsistemas de entorno NT. Una
aplicacin Win32 llamada mquina dos virtual (VDM) se encarga de proporcionar el
entorno. La VDM tiene una unidad de ejecucin de instrucciones para ejecutar o
emular instrucciones Intel 486, tambin el ROM BIOS de MS-DOS y los servicios de
interrupcin de software int 21, as como drivers de dispositivos virtuales para
pantalla, teclado y puertos de comunicacin.
Est basada en el cdigo fuente de MS-DOS 5.0 y proporciona a la aplicacin al
menos 620 KB de memoria. El shell es una ventana muy similar a un entorno MSDOS.
Si NT se ejecuta en un procesador X86, las aplicaciones grficas de MS-DOS se
ejecutan en modo de pantalla completa, y las de caracteres en cualquiera de las dos
opciones (completa o ventana). Si la arquitectura de procesador es otra, todas las
227
FINGUDELAR
aplicaciones se ejecutan en ventanas. En general, las aplicaciones MS-DOS que
acceden directamente a hardware, no funcionan bajo NT.
Hay aplicaciones para MS-DOS que acaparan la CPU (ya que no era multitareas)
como espera activa o pausas. El despachador de NT detecta los retardos, y los frena
(haciendo que la aplicacin no funcione correctamente).
20.4.2 EntornoWindowsde16bits
Corre por cuenta de un VDM que incorpora software adicional llamado windows on
windows que cuenta con las rutinas del ncleo de Windows 3.1, y las rutinas
adaptadoras (stubs) para las funciones del gestor de ventanas. Las rutinas
adaptadoras, invocan las subrutinas apropiadas de Win32. Las aplicaciones que
dependen de la estructura interna del gestor de ventanas de 16 bits no funcionan,
porque Windows on Windows no implementa realmente la API de 16 bits.
Windows on Windows puede ejecutarse en forma multitareas con otros procesos
en NT, pero solo una aplicacin Win16 puede ejecutarse a la vez. Todas las
aplicaciones son de un solo hilo, y residen en el mismo espacio de direcciones, con la
misma cola de entrada.
20.4.3 EntornoWin32
Ejecuta aplicaciones Win32 y gestiona toda la E/S de teclado, ratn y pantalla. Es
robusto, y a diferencia de Win16, cada proceso Win32 tiene su propia cola de
entrada.
El ncleo NT ofrece operacin multitareas expropiativa, que permite al usuario
terminar aplicaciones que han fallado o no se necesitan.
Win32 valida todos los objetos antes de usarlos, evitando cadas, el gestor de
objeto, evita que se eliminen objetos que todava se estn usando, e impide su uso,
una vez eliminados.
20.4.4 SubsistemaPOSIX
Est diseado para ejecutar aplicaciones POSIX, basadas en el modelo UNIX. El
estndar no especifica impresin, pero se pueden usar impresoras a travs del
mecanismo de redireccin de NT.
Las aplicaciones POSIX tienen acceso a cualquier sistema de archivos NT, pero
hace respetar los permisos tipo UNIX en los rboles de directorio. No apoya varios
recursos de Win32 como trabajo en redes, grficos, etc.
20.4.5 SubsistemaOS/2
NT proporciona recursos limitados en el subsistema de entorno OS/2, aunque en
sus el propsito general haba sido proporcionar un entorno OS/2 robusto.
Las aplicaciones basadas en caracteres solo pueden ejecutarse bajo NT en
computadores Intel x86. Las de modo real, se pueden ejecutar en todas las
plataformas, usando el entorno MS-DOS.
20.4.6 Subsistemasdeingresoyseguridad
Antes de que un usuario pueda acceder a objetos NT, el subsistema de ingreso
debe validarlo (login). Para ello el usuario debe tener una cuenta, y proporcionar la
contrasea.
Cada vez que el usuario intenta acceder a un objeto, el subsistema chequea que
se tengan los permisos correspondientes.
228
FINGUDELAR
Los sistemas MS-DOS utilizaban el sistema de archivos FAT, de 16 bits, que tiene
muchas deficiencias, como fragmentacin interna, una limitacin de tamao de 2 GB,
y falta de proteccin de archivos. FAT32 resolvi los problemas de tamao y
fragmentacin, pero su desempeo y funciones son deficientes en comparacin con
NTFS.
NTFS se dise teniendo en mente muchas funciones, incluidas recuperacin de
datos, seguridad, tolerancia de fallos, archivos y sistemas de archivos grandes,
nombres UNICODE y compresin de archivos. Por compatibilidad tambin reconoce
los sistemas FAT.
20.5.1 Organizacininterna
La entidad fundamental de NTFS es el volumen. El administrador de disco de NT
crea los volmenes que se basan en particiones de disco lgicas. Un volumen puede
ocupar una porcin de disco, un disco entero o varios discos.
No maneja sectores de disco individuales sino que usa cmulos (nmero de
sectores de disco que es potencia de 2) como unidad de asignacin. El tamao del
cmulo se configura cuando se formatea el sistema de archivos NTFS.
Tamaos por omisin:

Tamao de sector en el caso de volmenes de hasta 512 Mb.
1 KB para volmenes de hasta 1 GB
2 KB para volmenes de hasta 2 GB
4 KB para volmenes mayores
Este tamao es mucho menor al del cmulo de FAT, ayudando a reducir la

fragmentacin interna. Ej: En un disco de 1.6 GB con 16000 archivos, se podran
perder 400MB con sistema FAT (cmulos de 32KB), o 17MB bajo NTFS.
NTFS usa nmeros de cmulo lgicos (LCN), y los asigna numerando los cmulos
desde principio de disco, al final, pudiendo calcular la distancia fsica en el disco,
multiplicando el LCN por el tamao del cmulo.
Un archivo NTFS, no es un simple flujo de bytes como en MS-DOS o UNIX, sino un
objeto estructurado con atributos, algunos estndar, y otros especficos para ciertas
clases de archivos.
El espacio de nombres est organizado como una jerarqua de directorios, y cada
directorio emplea una estructura llamada rbol B+, debido a que elimina el costo de
reorganizar el rbol, y tiene la propiedad de que la longitud de cada camino desde la
raz hasta una hoja, es la misma. La raz ndice de un directorio, contiene el nivel
superior del rbol. Si el directorio es grande, el nivel superior contiene punteros a
alcances de disco que contienen el resto del rbol.
Cada entrada de directorio contiene el nombre y la referencia del archivo y una
copia del tiempo de actualizacin, y del tamao. Esto es til para no tener que
recabar en la MFT (Tabla maestra de archivos) cuando se pide un listado de los
archivos del directorio.
Los datos del volumen NTFS se almacenan en archivos. El primero es la MFT, y el
segundo contiene una copia de las 16 primeras entradas de la MFT, que se utiliza en
la recuperacin si la MFT se daa.
Otros archivos:
Archivo de bitcora: Registra actualizaciones de los datos del sistema de
archivos.
229
FINGUDELAR
Archivo de volumen: Contiene el nombre del volumen, la versin de NTFS

que dio formato, y un bit que indica si es posible que el volumen se haya
corrompido, y se necesite verificar su consistencia.
Tabla de definicin de atributos: Indica los atributos del volumen y qu
operaciones se pueden efectuar con cada uno de ellos.
Directorio raz: Es el directorio del nivel ms alto en la jerarqua del sistema
de archivos.
Archivo de mapa de bits: Indica qu cmulos del volumen estn asignados,
y cuales estn libres.
Archivo de arranque: Contiene el cdigo de inicio de NT, y debe estar en
una direccin especfica para que el autoarranque de la ROM lo localice
fcilmente. Tambin contiene la direccin de la MFT.
Archivo de cmulos defectuosos: Sigue la pista a las reas defectuosas
del volumen, y se usa para recuperacin de errores.
20.5.2 Recuperacin
En NTFS, todas las actualizaciones de estructura de datos, se efectan en
transacciones. Antes de alterar la estructura, se escribe un registro de bitcora con
informacin para deshacerla y rehacerla, y luego de modificarla con xito, se escribe
un registro de confirmacin en la bitcora.
Despus de una cada el sistema puede restaurar las estructuras, procesando la
bitcora, rehaciendo las operaciones de las transacciones confirmadas, y
deshaciendo la de las que no lograron confirmarse antes de la cada.
Peridicamente (cada cinco segundos aproximadamente), se escribe en la
bitcora un checkpoint, indicando al sistema que no necesita registros de bitcora
anteriores a l, desechando los registros, para que la bitcora no crezca
indefinidamente.
La primera vez que se accede a NTFS luego de una cada, se realiza
automticamente la recuperacin del sistema de archivos. Esto no garantiza la
correctitud de los archivos de usuario, solo asegura las estructuras de datos del
sistema de archivos.
Si el espacio de la bitcora se reduce demasiado, NTFS suspende todas las E/S
nuevas, para poder confirmar las que se estn haciendo, poner un checkpoint en la
bitcora, y borrar todos los datos ya confirmados.
20.5.3 Seguridad
La seguridad se deriva del modelo de objetos, ya que cada uno tiene almacenado
un descriptor de seguridad.
20.5.4 Gestindevolmenesytoleranciadefallos
FtDisk es el controlador de disco tolerante a fallos. Ofrece mecanismos para
combinar mltiples unidades de disco en un solo volumen lgico. Hay varias formas
de hacerlo.
230
FINGUDELAR
disco1(2.5Gb)
disco2(2.5Gb)
discoC:(FAT)2GB
unidadlgicaD:(NTFS)3GB
LCN128000783361
LCN0128000
Se pueden concatenar discos lgicamente para formar un volumen lgico grande.

En NT es llamado conjunto de volmenes y puede consistir de hasta 32 unidades
fsicas. NTFS usa el mismo mecanismo LCN que para un solo disco fsico, y FtDisk se
encarga de hacer la correspondencia.
Otra forma de combinar mltiples particiones fsicas es intercalar sus bloques bajo
disco1(2Gb)
disco2(2Gb)
LCN015
LCN1631
LCN3147
LCN4863
LCN6479
LCN8095
unidadlgicaC:4GB
un rgimen de turno circular, para formar un conjunto de franjas. FtDisk usa 64Kb
como tamao de franja. Los primeros 64Kb de volumen lgico se almacenan en la
primer particin fsica, los segundos en la segunda y as hasta que cada particin
fsica tiene 64Kb de la lgica.
Esto permite mejorar el ancho de banda de E/S ya que las unidades pueden
transferir datos en paralelo.
disco1(2Gb)
disco2(2Gb)
disco3(2Gb)
paridad015
LCN015
LCN1631
LCN3247
paridad1631
LCN4863
LCN6479
LCN8095
paridad3247
paridad4863
LCN96111
LCN112127
unidadlgicaC:4GB
Se pueden dividir tambin en franjas de paridad. Si hay 8 discos, entonces por

cada siete franjas de datos en siete discos diferentes hay una franja de paridad en el
octavo que contiene el or exclusivo de las siete franjas, por lo tanto, si una se
destruye, se puede reconstruir. De todas formas, cada actualizacin de una franja de
datos, obliga a recalcular la franja de paridad, as siete escrituras concurrentes,
requieren calcular siete franjas de paridad, por lo tanto, se deben encontrar en discos
diferentes, para no sobrecargar un mismo disco con el clculo de todas las paridades.
Las paridades se asignan entre los discos por turno circular.
Un esquema ms robusto, es el espejo de discos. Un juego de espejos comprende
dos particiones del mismo tamao, en dos discos, con su contenido de datos idntico.
Cuando se requiere escritura, FtDisk escribe en los dos discos, y si hay fallo, se tiene
una copia almacenada a salvo. Los dos discos, deben estar conectados a dos
231
FINGUDELAR
controladores de disco diferentes, por si el fallo es en el controlador. Esta
organizacin se denomina juego duplex.
Para superar la situacin en que sectores del disco se arruinan, FtDisk usa una
tcnica de hardware llamada ahorro de sectores, y NTFS, una de software llamada
retransformacin de cmulos.
Cuando se da formato al disco, se crea correspondencia entre nmeros de bloque
lgicos y sectores libres de defectos del disco, dejando algunos sectores sin
correspondencia como reserva. Si un sector falla, FtDisk ordena a la unidad de disco
que lo sustituya por una unidad de reserva.
La retransformacin de cmulos se aplica por NTFS, que reemplaza un bloque
defectuoso por uno no asignado, modificando los punteros pertinentes en la MFT,
adems tiene en cuenta que ese bloque no vuelva a ser asignado.
Si un bloque se arruina, se pierden datos, que en casos se pueden calcular si se
tiene un disco espejo, o calculando la paridad por or exclusivo, y los datos
reconstruidos se colocan en un nuevo espacio, que se obtuvo por ahorro de sectores
o retransformacin de cmulos.
20.5.5 Compresin
NTFS puede aplicar compresin a archivos. Divide sus datos en unidades de
compresin, que son bloques de 16 cmulos contiguos. Cada vez que se escribe en
una unidad de compresin, se aplica un algoritmo de compresin de datos. Para
mejorar la lectura, NTFS las preobtiene y descomprime adelantndose a las
solicitudes de las aplicaciones.
En caso de archivos poco poblados (contiene gran cantidad de ceros), la tcnica
es no almacenar en disco los cmulos que contienen nicamente ceros. Se dejan
huecos en la secuencia de nmeros almacenados en la tabla MFT para ese archivo, y
al leerlos, si NTFS encuentra un hueco en los nmeros, llena con ceros esa porcin
del buffer del invocador. UNIX emplea la misma tcnica.
20.6 Trabajoconredes
NT cuenta con recursos de gestin de redes, y apoya el trabajo de cliente-servidor.
Adems tambin tiene componentes de trabajo con redes como:
Transporte de datos
Comunicacin entre procesos
Compartimiento de archivos a travs de una red
Capacidad para enviar trabajos de impresin a impresoras remotas.
20.6.1 Protocolos
Implementa los protocolos de transporte como controladores, los cuales puede
cargar y descargar dinmicamente, aunque en la prctica, casi siempre debe
reiniciarse el sistema despus de un cambio.
20.6.2 Mecanismosdeprocesamientodistribuido
NT no es distribuido, pero s apoya aplicaciones distribuidas. Mecanismos
apoyados:
Aplicaciones NetBIOS: Se comunican en NT a travs de la red utilizando
algn protocolo.
232
FINGUDELAR
Conductos con nombre: Son mecanismos de envo de mensajes, orientados

a conexiones. Un proceso tambin puede usarlos para conectarse con otro
proceso en la misma mquina. Puesto que el acceso a estos conductos es a
travs de la interfaz con el sistema de archivos, se aplican los mecanismos de
seguridad sobre ellos.
Ranuras de correo: Son un mecanismo de envo de mensajes sin
conexiones. No son confiables, porque el mensaje podra perderse antes de
llegar al destinatario.
Sockets: Winsock es la API de sockets para ventanas. Es una interfaz de capa
de sesin, compatible (en buena parte) con sockets de UNIX.
Llamada a procedimiento remoto (RPC): Es un mecanismo clienteservidor que permite a una aplicacin de una mquina, emitir una llamada a
un procedimiento cuyo cdigo est en otra mquina. El cliente invoca, un stub
empaca sus argumentos en un mensaje y lo enva por la red a un proceso
servidor especfico. El servidor desempaca el mensaje, invoca el
procedimiento, empaca los resultados en otro mensaje, y lo enva de vuelva al
cliente, que espera el mensaje bloqueado. El cliente se desbloquea, lo recibe,
y desempaca los resultados.
Lenguaje de definicin de interfaces de Microsoft: Se utiliza para
describir los nombres de procedimientos remotos, argumentos y resultados,
para facilitar las llamadas a procedimientos remotos. El compilador para este
lenguaje genera archivos de cabecera que declaran rutinas adaptadoras para
los procedimientos remotos, asi como un desempacador y un despachador.
Intercambio dinmico de datos (DDE): Mecanismo para la comunicacin
entre procesos creado para Microsoft Windows.
20.6.3 Redirectoresyservidores
En NT, una aplicacin puede usar la API de E/S para acceder a archivos remotos.
Un redirector es un objeto del lado del cliente que reenva solicitudes de E/S a
archivos remotos, donde un servidor las atiende. Por razones de desempeo y
seguridad, los redirectores y servidores se ejecutan en modo de ncleo. Por razones
de transportabilidad, redirectores y servidores utilizan la API TDI para el transporte
por redes.
20.6.4 Dominios
Para gestionar derechos de acceso globales (ej: todos los usuarios de un grupo de
estudiantes), NT utiliza el concepto de dominio.
Un dominio NT, es un grupo de estaciones de trabajo y servidores NT que
comparten una poltica de seguridad y una base de datos de usuarios comunes. Un
servidor de dominio controla y mantiene las bases de datos de seguridad. Otros
servidores pueden actuar como controladores de respaldo, y validacin de solicitudes
de inicio.
A menudo es necesario manejar mltiples dominios dentro de una sola
organizacin. NT ofrece cuatro modelos de dominios para hacerlo.
Modelo de dominio nico: Cada dominio queda aislado de los dems.
Modelo de dominio maestro: Todos los dominios confan en un dominio
maestro designado, que mantiene las bases de datos de cuentas de usuario, y
proporciona servicios de validacin. Puede apoyar hasta 40000 usuarios.
Modelo de mltiples dominios maestros: Diseado para organizaciones
grandes, con ms de un dominio maestro, y todos los dominios confan unos
233
FINGUDELAR
en otros. El usuario con cuenta en un dominio, puede acceder a recursos de

otro dominio, si ese dominio certifica los permisos del usuario.
Modelo de mltiple confianza: No existe un dominio maestro, todos los
dominios confan unos en otros.
20.6.5 ResolucindenombresenredesTCP/IP
Es el proceso de convertir un nombre de computador en una direccin de IP. Por
ejemplo, transformar www.bell-labs.com en 135.104.1.14.
NT cuenta con varios mtodos, incluidos el Servicio de Nombres de Internet de
Windows (WINS), resolucin de nombres difundida, sistema de nombres de dominio
(DNS).
WINS: Dos o ms servidores WINS, mantienen una base de datos dinmica de
vinculaciones Nombre-direccin de IP, y software cliente para consultarlos. Se usan
dos servidores para que el servicio funcione, aunque falle uno, y adems para
distribuir la carga.
20.7 Interfazconelprogramador
La API Win32 es la interfaz fundamental con las capacidades de NT.
20.7.1 Accesoaobjetosdelncleo
Se acceden para obtener los servicios del ncleo. Cuando un proceso quiere
acceder a un objeto X del ncleo, debe hacer createX y abre un handle a ese objeto.
Para cerrar el handle hace closeHandle y el sistema elimina el objeto si nadie tiene
handles con l.
20.7.1.1 Compartimientodeobjetos
Hay tres formas:
Un proceso hijo hereda un handle del padre. El padre y el hijo podrn
comunicarse a travs del objeto.
Un proceso crea un objeto con nombre, y el segundo proceso lo abre con ese
nombre.
Desventajas:
NT no ofrece un mecanismo para verificar si existe un objeto
con nombre escogido.
El espacio de nombres es global. Por ejemplo, dos aplicaciones
podran crear un objeto llamado pepe, cuando se desean dos
objetos individuales (y diferentes).
Ventajas:
Procesos no relacionados entre si, pueden compartir objetos
fcilmente.
Compartir objetos por medio de la funcin DuplicateHandle. Pero requiere
de un mtodo de comunicacin entre procesos para pasar el mango
duplicado.
20.7.2 Gestindeprocesos
Un proceso es un ejemplar de una aplicacin que se est ejecutando y un hilo es
luna unidad de cdigo que el sistema operativo puede planificar. Un proceso tiene
uno o ms hilos.
234
FINGUDELAR
Una aplicacin multihilada necesita protegerse contra acceso no sincronizado, y la
funcin envolvente beginthreadex (iniciar ejecucin de hilo) proporciona la
sincronizacin apropiada.
Las prioridades en el entorno Win32 se basan en el modelo de planificacin NT,
pero no pueden escogerse todos los valores de prioridad. Se usan cuatro clases:
IDLE_PRIORITY_CLASS: Nivel de prioridad 4 (ocioso).
NORMAL_PRIORITY_CLASS: Nivel de prioridad 8 (normal).
HIGH_PRIORITY_CLASS: Nivel de prioridad 13 (alta).
REALTIME_PRIORITY_CLASS: Nivel de prioridad 24 (tiempo real).
Solo los usuarios con privilegio de incremento de prioridad pueden pasar un
proceso a la prioridad de tiempo real. Por defecto los administradores o usuarios
avanzados tienen ese privilegio.
Cuando un usuario est ejecutando un programa interactivo, el sistema debe darle
mayor prioridad, para ello tiene una regla de planificacin que distingue entre el
proceso de primer plano que es el seleccionado actualmente en la pantalla y los
procesos de segundo plano que no estn seleccionados. Cuando un proceso pasa a
primer plano, el sistema incrementa su cuanto de planificacin al triple, por lo que el
proceso se ejecuta por un tiempo tres veces mayor, antes de ser desalojado.
Para sincronizar el acceso concurrente de hilos a objetos compartidos, el ncleo
proporciona objetos de sincronizacin como semforos y mutexes. Otro mtodo es la
seccin crtica, que es una regin de cdigo sincronizada que solo un hilo puede
ejecutar a la vez.
Una fibra es cdigo en modo usuario, planificado segn un algoritmo definido por
el usuario. Se utiliza de la misma forma que los hilos, pero a diferencia de ellos, no se
pueden ejecutar dos fibras concurrentemente, an en un hardware multiprocesador.
20.7.3 Comunicacinentreprocesos
Una forma es compartiendo objetos del ncleo, y otra es transfiriendo mensajes.
Los mensajes se pueden publicar o enviar. Las rutinas de publicacin son
asincrnicas, por lo tanto envan el mensaje y regresan de inmediato. El hilo que
envi el mensaje no sabe si lleg. Las rutinas de envo son sincrnicas, y bloquean al
invocador hasta que se ha entregado y procesado el mensaje.
Cada hilo Win32 tiene su propia cola de entrada, y esta estructura es ms
confiable que la cola de entradas compartida de las ventanas de 16 bits, porque una
aplicacin bloqueada no bloquea a las dems.
Si un proceso que envi un mensaje, no recibe respuesta en cinco segundos, el
sistema marca la aplicacin como No responde.
20.7.4 Gestindememoria
Hay varios mecanismos de uso de memoria como:
Memoria Virtual: Para pedir y liberar memoria virtual se usa VirtualAlloc y

VirtualFree. La funcin VirtualLock asegura pginas en memoria fsica,
pudiendo asegurar 30 como mximas.
Archivos con correspondencia en memoria: Es cmodo para que dos
procesos compartan memoria.
235
FINGUDELAR
Montculo (heap): Es una regin de espacio de direcciones reservada.

Cuando Win32 crea un proceso, lo hace con un montculo por omisin de 1MB.
El acceso al montculo es sincronizado para proteger las estructuras de datos
de hilos concurrentes. Se usan funciones como HeapCreate, HeapAlloc,
HeapRealloc, HeapSize, HeapFree y HeapDestroy.
236

Teorico Con Preguntas de Examen

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Teorico Con Preguntas de Examen

Transféré par

Droits d'auteur :

Formats disponibles

FINGUDELAR

Brindar un ambiente para realizar y ejecutar los programas y aplicaciones de

Todas las aplicaciones requieren un conjunto de operaciones comunes que son

Proveer uno o varios entornos y contexto apropiado para la ejecucin

Podr implementar diferentes entornos adecuados para diferentes

Examen marzo 2006:

Administra todos los recursos disponibles.

Controla la ejecucin de los programas para la prevencin de

Frecuentemente, la porcin residente del propio sistema operativo se denomina

SISD (Single Instruction, Single Data): una arquitectura secuencial

Dentro de los sistemas MIMD se suelen hacer dos divisiones:

Sistemas asimtricos: al surgir los sistemas multiprocesadores los

Los sistemas multiprocesadores se caractrizan en dos tipos:

Sistemas UMA (Uniform Memory Access): acceso uniforme a la

Examen febrero 2005:

Simtricos: todos los nodos ejecutan tareas y asumen las de otros

Existen varias arquitecturas de procesadores, se clasifican en RISC (Reduced

Mayor rendimiento, no se satura el bus del sistema (cuello de botella).

Examen julio 2005:

Pistas (tracks): La superficie de los platos es dividida lgicamente en

La velocidad del disco se compone de dos partes:

Los device drivers son cargados de diferentes formas:

Ensamblarlos estticamente al ncleo del sistema.

Las controladoras contienen un conjunto de registros que sirven para comunicarse

El sistema queda en busy waiting consultando un registro del controlador para

El sistema se independiza del controlador, que genera una interrupcin cuando

Se dispone de un dispositivo especializado que permite realizar transferencias

Modo Dual: se provee de al menos dos modos de operacin.

Examen julio 2005:

Modo usuario (user mode): en este modo de ejecucin se puede

Examen marzo 2003:

Red LAN (Local Area Network): son pequeas y su alcance est

La diferencia principal es cmo estn geogrficamente distribuidas.

Costos bsicos: qu costo a nivel monetario implica interconectar la

Las topologas que se implementen

Examen marzo 2005:

Un conjunto de servicios que provean la interfaz con el subsistema e

Examen marzo 2006:

Algoritmos de planificacin de disco.

La interfaz con el usuario se implementa en trminos de un intrprete de comandos dispuesto en el ncleo

Al principio los system calls estaban programados en lenguaje ensamblador.

Cargar los parmetros en el lugar adecuado (Stack).

Examen julio 2005:

Existen 3 formas de pasar los parmetros al sistema operativo:

A travs de los registros. Se utilizan un conjunto de registros para

Los system calls se clasifican en distintos tipos:

Examen marzo 2005:

Metas de los usuarios: ser amigable, intuitivo, confiable, seguro,

Diseo del sistema:

Examen abril 2003:

4.4.3 Sistema con microncleo (microkernel).

Aumenta la portabilidad y escalabilidad ya que encapsula las

Examen abril 2003:

Cdigo (text): Instrucciones del

Nuevo (new): Cuando el proceso es creado.

Transiciones y estados de procesos:

Examen abril 2003:

Memoria: Describe el espacio virtual y/o real de direccionamiento

Examen abril 2003:

Lista de procesos del sistema (job queue): En esta lista estn

Examen diciembre 2005:

Diagrama de transicin de un proceso entre las colas del sistema:

Examen abril 2003:

Ventajas del uso de threads: