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);
}
}
/// <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!
}
/// <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;
}