/// <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>
/// Envía este bloqueMemoria a la memoria correspondiente.
/// Espera el tiempo correspondiente a si es un envio local o remoto.
/// Pone el estado en Compartido.
/// </summary>
public void EnviarAMemoria()
{
// Solo tiene sentido enviar un bloqueMemoria a memoria si está modificado
Debug.Assert(Cache.EstaBloqueado());
Debug.Assert(Estado == EstadosB.Modificado);
// Se espera a que se envien los datos
EsperarEnvio();
// Se copia el bloqueMemoria a la memoria principal correspondiente
int indice = MemoriaPrincipal.GetIndice(Direccion);
MemoriaPrincipal[indice] = this;
// Se invalida el bloque
this.Invalidar();
}
