示例#1
0
        private void EnviarAMemoriaBloqueVSiModificado(BloqueCacheDatos bloqueV)
        {
            if (bloqueV.Estado != EstadosB.Invalido)
            {
                Directorio directorioBloqueV = bloqueV.Directorio;

                // Bloqueo directorio de BloqueV
                directorioBloqueV.Bloquear(this.Nombre);
                bloqueados.Add(directorioBloqueV);

                // Se pregunta si el bloque a reemplazar en mi cache está modificado
                if (bloqueV.Estado == EstadosB.Modificado)
                {
                    // Envio el bloque a memoria
                    // Este método modifica tanto la cache como el directorio (U en directorio e I en Cache)
                    bloqueV.EnviarAMemoria();
                }
                else
                {
                    bloqueV.Invalidar();
                }

                // Desbloqueo el directorio del BloqueV
                directorioBloqueV.Desbloquear(this.Nombre);
                bloqueados.Remove(directorioBloqueV);
            }
        }
示例#2
0
        /// <summary>
        /// Crea todas las condiciones necesarias para la simulacion y
        /// posteriormente la inicia simplemente diciendole a cada procesador
        /// que se ejecute
        ///
        /// Este metodo esta pensado en que se va a envolver en un hilo cuando se
        /// cree desde la vista!
        /// </summary>
        public void EjecutarSimulacion()
        {
            Debug.WriteLine("Simulador: Iniciando...");
            Debug.Flush();

            // Modificar aqui la cantidad de procesadores deseados!
            int numeroProcesadores = cantidadProgramas > 2 ? 3 : cantidadProgramas; //para ajustar la cantidad según necesidad

            // Se crean vectores para todos los objetos necesarios
            Controlador controlador = new Controlador();

            Procesador[]       procesadores       = new Procesador[numeroProcesadores];
            CacheInstrucciones cacheInstrucciones = new CacheInstrucciones(numeroProcesadores, instrucciones, iniciosProgramas, cantidadProgramas, nombresProgramas);

            CacheDatos[]       cachesDatos         = new CacheDatos[numeroProcesadores];
            Directorio[]       directorios         = new Directorio[numeroProcesadores];
            MemoriaPrincipal[] memoriasPrincipales = new MemoriaPrincipal[numeroProcesadores];

            // Se inicializan todos los objetos relacionados a los procesadores
            for (int i = 0; i < numeroProcesadores; ++i)
            {
                directorios[i]         = new Directorio(controlador, i);
                memoriasPrincipales[i] = new MemoriaPrincipal(controlador, i);
                cachesDatos[i]         = new CacheDatos(controlador, i);
                procesadores[i]        = new Procesador(controlador, i);
            }

            // Se agrega la interfaz como listener del controlador/modelo
            controlador.AddListener(interfaz);

            // Se inicializa el controlador que hasta el momento no conocia a nadie
            controlador.Inicializar(procesadores, cachesDatos, cacheInstrucciones, directorios, memoriasPrincipales);

            // Se crean los hilos necesarios
            Thread[] hilosProcesadores = new Thread[numeroProcesadores];
            for (int i = 0; i < numeroProcesadores; ++i)
            {
                // Se crea un hilo para cada procesador y se manda a ejectuar instrucciones
                hilosProcesadores[i] = new Thread(procesadores[i].Procesar);
                hilosProcesadores[i].Start();
            }

            // Cuando todos los procesadores comienzan, se empiezan a sincronizar
            // solos con ayuda del objeto controlador porque ahi esta la barrera

            // Se espera que cada procesador termine
            for (int i = 0; i < numeroProcesadores; ++i)
            {
                hilosProcesadores[i].Join();
            }

            // El hilo del simulador termina en el momento que todos los procesadores terminan!
        }
示例#3
0
        /// <summary>
        /// Para poner el bloque en un estado completamente inválido.
        /// </summary>
        public void Invalidar()
        {
            Debug.Assert(Directorio.EstaBloqueado());
            Debug.Assert(Cache.EstaBloqueado());

            // Quito del directorio
            Directorio.EliminarUsuarioBloque(Cache, this);

            // Invalido el bloque
            this.id = -1;
            this.direccionInicial       = -1;
            this.indiceMemoriaPrincipal = -1;
            this.Estado = EstadosB.Invalido;
        }