public static string ObtenerPlacaCronica(this DateTime fecha, Estaciones estaciones)
{
DateTime fechaEstacion = new DateTime();
int diferencia = 0;
switch (estaciones)
{
case Estaciones.Invierno:
fechaEstacion = new DateTime(DateTime.Now.Year, 6, 21);
break;
case Estaciones.Primavera:
fechaEstacion = new DateTime(DateTime.Now.Year, 9, 21);
break;
case Estaciones.Verano:
fechaEstacion = new DateTime(DateTime.Now.Year, 12, 21);
break;
case Estaciones.Otonio:
fechaEstacion = new DateTime(DateTime.Now.Year, 3, 21);
break;
}
if (fechaEstacion < fecha)
{
fechaEstacion = fechaEstacion.AddYears(1);
}
diferencia = (int)(fechaEstacion - fecha).TotalDays;
//return $"Faltan {diferencia} dias para el {estaciones}";
return($"Faltan {diferencia} dias para el {Enum.GetName(typeof(Estaciones), estaciones)}");
}
public static string ObtenerPlacaCronica(this DateTime instanciaDateTime, Estaciones estacion)
{
DateTime fechaAComparar;
switch (estacion)
{
case Estaciones.Verano:
fechaAComparar = Convert.ToDateTime("21/12/19");
break;
case Estaciones.Primavera:
fechaAComparar = Convert.ToDateTime("21/09/20");
break;
case Estaciones.Invierno:
fechaAComparar = Convert.ToDateTime("21/06/20");
break;
/*case Estaciones.Otonio:
* fechaAComparar = Convert.ToDateTime("21/03/19");
* break;*/
default:
fechaAComparar = Convert.ToDateTime("21/03/20");
break;
}
TimeSpan tiempoFaltante = fechaAComparar - instanciaDateTime;
string retorno = string.Format("Faltan {0} dias para el {1}", tiempoFaltante.Days, estacion.ToString());
return(retorno);
}
public static string ObtenerPlacaCronica(this DateTime fecha, Estaciones estacion)
{
string str;
TimeSpan timeSpan = new TimeSpan();
DateTime dateTime;
switch (estacion)
{
case Estaciones.Verano:
dateTime = new DateTime(2020, 12, 21);
timeSpan = dateTime.Subtract(fecha);
break;
case Estaciones.Otoño:
dateTime = new DateTime(2021, 3, 21);
timeSpan = dateTime.Subtract(fecha);
break;
case Estaciones.Invierno:
dateTime = new DateTime(2020, 6, 21);
timeSpan = dateTime.Subtract(fecha);
break;
case Estaciones.Primavera:
dateTime = new DateTime(2020, 9, 21);
timeSpan = dateTime.Subtract(fecha);
break;
}
str = string.Format($"Faltan {timeSpan.TotalDays} dias para el {estacion}");
return(str);
}
public async Task <IHttpActionResult> PutEstaciones(int id, Estaciones estaciones)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != estaciones.IdEstacion)
{
return(BadRequest());
}
db.Entry(estaciones).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EstacionesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static void Main()
{
//se instancia el enum como un objeto de una clase
Estaciones alergia = Estaciones.Invierno;
Console.WriteLine(alergia);
Bono Oscar = Bono.simple;
double bonusAntonio = (double)Oscar;
double salarioOscar = bonusAntonio + 54.60;
Console.WriteLine(salarioOscar);
Empleado francisco = new Empleado(Bono.supreme, 3000);
Console.WriteLine("El salario de Francisco más el bono \"supreme\" es: " + francisco.getSalario());
Dias viernes = Dias.Vie;
Dias sabado = Dias.Sab;
Dias domingo = Dias.Dom;
Dias libre = Dias.Sab;
Console.WriteLine(sabado == libre);
Console.WriteLine(viernes == domingo);
//conocer el valor de un enum
Console.WriteLine((int)Dias.Mar);
Console.WriteLine("El mes de febrero es el número " + (int)Meses.Feb);
//si se reasigna un valor de cualquier posicion, el siguiente constante tomara el numero consiguiente. Por ejemplo Oct = 500, ver el resultado en consola de noviembre (501)
Console.WriteLine((int)Meses.Nov);
}
public async Task <IHttpActionResult> GetEstaciones(int id)
{
Estaciones estaciones = await db.Estaciones.FindAsync(id);
if (estaciones == null)
{
return(NotFound());
}
return(Ok(estaciones));
}
public async Task <IHttpActionResult> PostEstaciones(Estaciones estaciones)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Estaciones.Add(estaciones);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = estaciones.IdEstacion }, estaciones));
}
public async void actualizarListaEstaciones()
{
LoadingRing.Visibility = Visibility.Visible;
Estaciones es = new Estaciones();
await es.actualizar();
listaEstaciones = es.estaciones_tranvía;
//foreach(Parada p in listaEstaciones)
//{
// p.actualizar(); //await
//}
this.Bindings.Update();
LoadingRing.Visibility = Visibility.Collapsed;
}
public async Task <IHttpActionResult> DeleteEstaciones(int id)
{
Estaciones estaciones = await db.Estaciones.FindAsync(id);
if (estaciones == null)
{
return(NotFound());
}
db.Estaciones.Remove(estaciones);
await db.SaveChangesAsync();
return(Ok(estaciones));
}
private void ReasignarEstaciones()
{
float Porcentaje1 = longitud / longAnterior;
Estaciones.ForEach(Estacion =>
{
float LongElementoNueva = Estacion.LineaOrigen.ConfigLinea.LongitudPonderacion * Porcentaje1;
float Porcentaje2 = LongElementoNueva / Estacion.LineaOrigen.ConfigLinea.LongitudPonderacion;
Estacion.CoordX = Estacion.CoordX * Porcentaje2;
});
var LinesOrigen = Estaciones.Select(y => y.LineaOrigen).Distinct().ToList();
LinesOrigen.ForEach(y => y.ConfigLinea.LongitudPonderacion = y.ConfigLinea.LongitudPonderacion * Porcentaje1);
}
public static string ObtenerPlacaCronica(this DateTime fecha, Estaciones estacion)
{
string diasQueFaltan;
TimeSpan timeSpan = new TimeSpan();
DateTime dateTime;
switch (estacion)
{
case Estaciones.Verano:
dateTime = new DateTime(2020, 12, 21);
timeSpan = dateTime.Subtract(fecha);
break;
case Estaciones.Primavera:
dateTime = new DateTime(2020, 9, 21);
timeSpan = dateTime.Subtract(fecha);
break;
case Estaciones.Invierno:
dateTime = new DateTime(2020, 6, 21);
timeSpan = dateTime.Subtract(fecha);
break;
case Estaciones.Otonio:
dateTime = new DateTime(2021, 3, 21);
timeSpan = dateTime.Subtract(fecha);
break;
}
if (estacion == Estaciones.Primavera)
{
diasQueFaltan = $"Faltan {(int)timeSpan.TotalDays} para la Primavera";
}
else
{
diasQueFaltan = $"Faltan {(int)timeSpan.TotalDays} para el {estacion}";
}
return(diasQueFaltan);
}
static void Main(string[] args)
{
Estaciones alegria = Estaciones.Invierno;
Console.WriteLine(alegria);
Bonus Antonio = Bonus.bueno;
double bonusAntonio = (double)Antonio;
double salarioAntonio = 1500 + bonusAntonio;
Console.WriteLine(Antonio);
Console.WriteLine(bonusAntonio);
Console.WriteLine(salarioAntonio);
Empleado e1 = new Empleado(Bonus.extra, 1900.50);
Console.WriteLine("El salario es: " + e1.getSalario());
}
public static string ObtenerPlacaCronica(this DateTime fecha, Estaciones estacion)
{
int day = 21;
int mes = 0;
string est = "";
switch (estacion)
{
case Estaciones.Invierno:
est = "el invierno";
mes = 6;
break;
case Estaciones.Primavera:
est = "la primavera";
mes = 9;
break;
case Estaciones.Verano:
est = "el verano";
mes = 12;
break;
case Estaciones.Otonio:
est = "el otonio";
mes = 3;
break;
}
DateTime fechaEvento = new DateTime(fecha.Year, mes, day);
if (fechaEvento < fecha)
{
fechaEvento.AddYears(1);
}
int cantidadDias = (int)(fechaEvento - fecha).TotalDays;
return($"Faltan {cantidadDias} dias para {est}.");
}
public static string ObtenerPlacaCronica(this DateTime instance, Estaciones estacion)
{
Dictionary <Estaciones, DateTime> fechasDeInicioEstacion = new Dictionary <Estaciones, DateTime>()
{
{ Estaciones.Invierno, new DateTime(instance.Year, 06, 21) },
{ Estaciones.Primavera, new DateTime(instance.Year, 09, 21) },
{ Estaciones.Verano, new DateTime(instance.Year, 12, 21) },
{ Estaciones.Otonio, new DateTime(instance.Year, 03, 21) }
};
DateTime fechaInicioEstacion = new DateTime();
fechasDeInicioEstacion.TryGetValue(estacion, out fechaInicioEstacion);
if (fechaInicioEstacion < instance)
{
fechaInicioEstacion = fechaInicioEstacion.AddYears(1);
}
int cantidadDias = (int)(fechaInicioEstacion - instance).TotalDays;
return($"Faltan {cantidadDias} días para {(estacion == Estaciones.Primavera ? "la" : "el")} {estacion}");
}
private void Update()
{
if (!pause) //if game not paused
{
timeIncrement += Time.deltaTime * deltaIncrement; //frame to frame increment
timeSliderUI.fillAmount = (timeIncrement / aYearForMe);
if (timeIncrement < 60)
{
estacion = Estaciones.Primavera;
}
else
{
if (timeIncrement < 120)
{
estacion = Estaciones.Verano;
}
else
{
estacion = Estaciones.Invierno;
}
}
if (centinela != year)
{
preAñoNuevo.Invoke();
centinela = Mathf.RoundToInt(year);
}
if (timeIncrement >= aYearForMe)
{
timeIncrement = 0;
year++;
añoNuevo.Invoke();
}
}
}
public static string ObtenerPlacaCronica(this DateTime fechaInicial, Estaciones estacion)
{
int diaEstacion = 21;
int mesEstacion = default(int);
switch (estacion)
{
case Estaciones.Verano:
mesEstacion = 12;
break;
case Estaciones.Otonio:
mesEstacion = 3;
break;
case Estaciones.Invierno:
mesEstacion = 6;
break;
case Estaciones.Primavera:
mesEstacion = 9;
break;
}
DateTime fechaEstacion = new DateTime(fechaInicial.Year, mesEstacion, diaEstacion);
if (fechaEstacion < fechaInicial)
{
fechaEstacion = fechaEstacion.AddYears(1);
}
TimeSpan tiempoRestante = fechaEstacion - fechaInicial;
int diasRestantes = (int)tiempoRestante.TotalDays;
return(String.Format("Faltan {0} días para el {1}", diasRestantes, Enum.GetName(typeof(Estaciones), estacion)));
}
public void AddEstacion(Product estacion)
{
Estaciones.Add(estacion);
}
private void Cargar_Cajas()
{
MSRegistro RegOut = new MSRegistro();
Crypto DesencriptarTexto = new Crypto();
int valSucursal = Convert.ToInt32(cmbSucursal.SelectedValue.ToString());
Estaciones estacion = new Estaciones();
cbEstacion.DataSource = estacion.ListarEstacionesLogin(valSucursal);
cbEstacion.ValueMember = "EstacionesId";
cbEstacion.DisplayMember = "EstacionesNombre";
}
private void ejecutarCiclo()
{
manejaCiclos(1);
int rs1, rs2;
Estaciones temp;
//Etapa ISS
Instruccion instruccion = null;//será usada para tomar instrucciones de la cola de instrucciones
//tomando instrucción de la cola de instrucciones
if (lb_colaInstrucciones.Items.Count > 0)
{
instruccion = instrucciones[lb_colaInstrucciones.Items.Count - 1];
//verificando tipo de instrucción y si hay estaciones de reserva o buffers disponibles para ella
//Primero verificando a que estación o buffer va
string destino = gInst.verificarDestinoInstruccion(instruccion);
bool asignada = false;
int indiceRegistro;
switch (destino)
{
case "LOAD":
//verificando disponibilidad de buffer de carga
int numBufferCargaDisponible = gBuffer.bufferCargaDisponible(bufferCarga);
if (numBufferCargaDisponible != -1)
{
//indicando que el valor que se trae de memoria aún no está en el registro
indiceRegistro = Convert.ToInt32(instruccion.Rd.Substring(1));
registrosR[indiceRegistro] = "LOAD" + numBufferCargaDisponible;
//se asigna a esa posición del buffer la instrucción
gBuffer.asignarInstruccionABufferCargaDisponible(bufferCarga, instruccion, numBufferCargaDisponible);
//la instrucción guarda el lugar donde se almancena
instrucciones[lb_colaInstrucciones.Items.Count - 1].Ubicacion = "LOAD:" + numBufferCargaDisponible;
asignada = true;
}
break;
case "STORE":
//verificando disponibilidad de buffer de almacenamiento
int numBufferAlmacenamientoDisponible = gBuffer.bufferAlmacenamientoDisponible(bufferAlmacenamiento);
if (numBufferAlmacenamientoDisponible != -1) //No hay riesgo estructural
{
//indicando que el valor aún no está escrito en memoria
indiceRegistro = Convert.ToInt32(instruccion.Rd.Substring(1));
//registrosR[indiceRegistro] = "STORE" + numBufferAlmacenamientoDisponible;
//se asigna a esa posición del buffer la instrucción
gBuffer.asignarInstruccionABufferAlmacenamientoDisponible(bufferAlmacenamiento, instruccion, numBufferAlmacenamientoDisponible);
//la instrucción guarda el lugar donde se almancena
instrucciones[lb_colaInstrucciones.Items.Count - 1].Ubicacion = "STORE:" + numBufferAlmacenamientoDisponible;
asignada = true;
}
break;
case "ADD":
//verificando disponibilidad de Estaciones de reserva
int numEstacionReservaDisponibleAddSub = gEstReserva.estacionReservaDisponibleAddSub(estacionAddSub);
if (numEstacionReservaDisponibleAddSub != -1) //No hay riesgo estructural
{
//se asigna la instrucción a la estación de reserva
//primero se deben obtener los datos de los registros a usar
rs1 = Convert.ToInt32(instruccion.Rs1.Substring(1));
rs2 = Convert.ToInt32(instruccion.Rs2.Substring(1));
temp = new Estaciones();
temp.Operacion = "";
temp.Qj = "";
temp.Qk = "";
temp.S1 = "";
temp.S2 = "";
if (registrosR[rs1].Contains("LOAD") || registrosR[rs1].Contains("STORE") || registrosR[rs1].Contains("ADD") || registrosR[rs1].Contains("MUL"))
{
//el valor no está en el registro, está en algún buffer o estación de reserva
temp.Qj = registrosR[rs1];
}
else
{
//el valor está en el registro
temp.S1 = registrosR[rs1];
}
if (registrosR[rs2].Contains("LOAD") || registrosR[rs2].Contains("STORE") || registrosR[rs2].Contains("ADD") || registrosR[rs2].Contains("MUL"))
{
//el valor no está en el registro, está en algún buffer o estación de reserva
temp.Qk = registrosR[rs2];
}
else
{
//el valor está en el registro
temp.S2 = registrosR[rs2];
}
//asignando operación a la estación
temp.Operacion = instruccion.Op;
//la instrucción guarda el lugar donde se almancena
instrucciones[lb_colaInstrucciones.Items.Count - 1].Ubicacion = "ADD:" + numEstacionReservaDisponibleAddSub;
//indicando que el valor aún no está escrito en el registro de destino
indiceRegistro = Convert.ToInt32(instruccion.Rd.Substring(1));
registrosR[indiceRegistro] = "ADD" + numEstacionReservaDisponibleAddSub;
//se asigna a esa posición del buffer la instrucción
gEstReserva.asignarInstruccionAEstacionReservaAddSub(estacionAddSub, instruccion, numEstacionReservaDisponibleAddSub, temp);
asignada = true;
}
break;
case "MUL":
//verificando disponibilidad de Estaciones de reserva
int numEstacionReservaDisponibleMulDiv = gEstReserva.estacionReservaDisponibleMulDiv(estacionMulDiv);
if (numEstacionReservaDisponibleMulDiv != -1) //No hay riesgo estructural
{
//se asigna la instrucción a la estación de reserva
//primero se deben obtener los datos de los registros a usar
rs1 = Convert.ToInt32(instruccion.Rs1.Substring(1));
rs2 = Convert.ToInt32(instruccion.Rs2.Substring(1));
temp = new Estaciones();
temp.Operacion = "";
temp.Qj = "";
temp.Qk = "";
temp.S1 = "";
temp.S2 = "";
if (registrosR[rs1].Contains("LOAD") || registrosR[rs1].Contains("STORE") || registrosR[rs1].Contains("ADD") || registrosR[rs1].Contains("MUL"))
{
//el valor no está en el registro, está en algún buffer o estación de reserva
temp.Qj = registrosR[rs1];
}
else
{
//el valor está en el registro
temp.S1 = registrosR[rs1];
}
if (registrosR[rs2].Contains("LOAD") || registrosR[rs2].Contains("STORE") || registrosR[rs2].Contains("ADD") || registrosR[rs2].Contains("MUL"))
{
//el valor no está en el registro, está en algún buffer o estación de reserva
temp.Qk = registrosR[rs2];
}
else
{
//el valor está en el registro
temp.S2 = registrosR[rs2];
}
//asignando operación a la estación
temp.Operacion = instruccion.Op;
//la instrucción guarda el lugar donde se almancena
instrucciones[lb_colaInstrucciones.Items.Count - 1].Ubicacion = "MUL:" + numEstacionReservaDisponibleMulDiv;
//indicando que el valor aún no está escrito en el registro de destino
indiceRegistro = Convert.ToInt32(instruccion.Rd.Substring(1));
registrosR[indiceRegistro] = "MUL" + numEstacionReservaDisponibleMulDiv;
//se asigna a esa posición del buffer la instrucción
gEstReserva.asignarInstruccionAEstacionReservaMulDiv(estacionMulDiv, instruccion, numEstacionReservaDisponibleMulDiv, temp);
asignada = true;
}
break;
}
if (asignada)
{
instrucciones[lb_colaInstrucciones.Items.Count - 1].Estado = 1;
lb_colaInstrucciones.Items.RemoveAt(lb_colaInstrucciones.Items.Count - 1);
refrescarDgv();
gestionaRegistros(1);
}
}
//Etapa EX
//se debe verificar que solo 1 instrucción de ADD/SUB se ejecute a la vez y una instrucción de MUL/DIV se ejecute a la vez
int ufSuma, ufMul, ufMemoria;
//0 indica que estan libres
ufSuma = 0;
ufMul = 0;
ufMemoria = 0;
//teniendo en cuenta que las instrucciones LD usan el sumador en su primer ciclo de ejecución para calcular la dirección desde
//donde se cargará el dato y en el segundo ciclo de ejecución cargará el valor en el registro
//las instrucciones de almacenamiento usan el sumador para calcular el lugar de memoria donde se guardarán los datos
//solo necesita 1 ciclo de ejecución para calcular la posición a guardar a diferencia de las instrucciones LD
//por lo tanto no se podrán ejecutar instrucciones LD, ST, ADD Y SUB en un mismo ciclo.
//pero se pueden ejecutar instrucciones LD/ST/ADD/SUB y instrucciones DIV/MUL en un mismo ciclo, una instrucción de cada tipo
//debido a que se tiene una unidad funcional para LD/ST/ADD/SUB y una unidad funcional para DIV/MUL
string[] ubicacion;
int pos;
string[] direccion;
int numRegistro;
for (int i = instrucciones.Count - 1; i >= 0; i--)
{
if (instrucciones[i].Ubicacion == "" || (instruccion != null && instruccion.IdInstruccion == instrucciones[i].IdInstruccion))
{
continue;
}
ubicacion = instrucciones[i].Ubicacion.Split(':');
//posición 0 -> lugar
//posición 1 -> índice
pos = Convert.ToInt32(ubicacion[1]);
//solo se evaluan las instrucciones que se encuentran en el estado 1(ISS) y que tengan todos sus operandos disponibles
//o las instrucciones en estado 5(burbuja) para ver si ya pueden ejecutarse
if (instrucciones[i].Estado == 1 || instrucciones[i].Estado == 5)
{
switch (ubicacion[0])
{
case "LOAD":
direccion = bufferCarga[pos].Direccion.Split('+');
numRegistro = Convert.ToInt32(direccion[0].Substring(1));
if (ufSuma == 1)
{
instrucciones[i].Estado = 5; //unidad funcional ocupada
}
else
{
if (registrosR[numRegistro].Contains("LOAD") || registrosR[numRegistro].Contains("STORE") || registrosR[numRegistro].Contains("ADD") || registrosR[numRegistro].Contains("MUL"))
{
//aún no estan listos los registros a usar
instrucciones[i].Estado = 5;
}
else
{
//valores cargados correctamente en los registros, empezando etapa EX
ufSuma = 1; //usando el sumador
//valor de memoria
int valor = Convert.ToInt32(registrosR[numRegistro]) + Convert.ToInt32(direccion[1]);
if (valor < 0 || valor > 76 || valor % 4 != 0)
{
finalizarProgramaError(instrucciones[i].IdInstruccion, " ha generado una lectura a memoria incorrecta. Programa Finalizado.");
}
bufferCarga[pos].Valor = valor;
instrucciones[i].ContadorLatencia = instrucciones[i].ContadorLatencia + 1;
instrucciones[i].Estado = 2;
}
}
break;
case "STORE":
direccion = bufferAlmacenamiento[pos].Direccion.Split('+');
numRegistro = Convert.ToInt32(direccion[0].Substring(1));
if (ufSuma == 1)
{
instrucciones[i].Estado = 5; //unidad funcional ocupada
}
else
{
if (registrosR[numRegistro].Contains("LOAD") || registrosR[numRegistro].Contains("STORE") || registrosR[numRegistro].Contains("ADD") || registrosR[numRegistro].Contains("MUL"))
{
//aún no estan listos los registros a usar
instrucciones[i].Estado = 5;
}
else
{
int numRegistroAux = Convert.ToInt32(instrucciones[i].Rd.Substring(1));
if (instrucciones[i].ContadorLatencia == instrucciones[i].Latencia &&
(registrosR[numRegistroAux].Contains("LOAD") || registrosR[numRegistroAux].Contains("STORE") ||
registrosR[numRegistroAux].Contains("ADD") || registrosR[numRegistroAux].Contains("MUL")))
{
//aún no estan listos los registros a usar
instrucciones[i].Estado = 5;
continue;
}
if (instrucciones[i].ContadorLatencia == instrucciones[i].Latencia &&
!(registrosR[numRegistroAux].Contains("LOAD") || registrosR[numRegistroAux].Contains("STORE") ||
registrosR[numRegistroAux].Contains("ADD") || registrosR[numRegistroAux].Contains("MUL")))
{
instrucciones[i].Estado = 3;
continue;
}
//valores cargados correctamente en los registros, empezando etapa EX
ufSuma = 1; //usando el sumador
//lugar de memoria donde se guardará el dato
int valor = Convert.ToInt32(registrosR[numRegistro]) + Convert.ToInt32(direccion[1]);
if (valor < 0 || valor > 76 || valor % 4 != 0)
{
finalizarProgramaError(instrucciones[i].IdInstruccion, " ha generado una lectura a memoria incorrecta. Programa Finalizado.");
}
bufferAlmacenamiento[pos].Valor = valor;
instrucciones[i].ContadorLatencia = instrucciones[i].ContadorLatencia + 1;
instrucciones[i].Estado = 2;
}
}
break;
case "ADD":
temp = estacionAddSub[pos];
if (ufSuma == 1)
{
instrucciones[i].Estado = 5; //unidad funcional ocupada
}
else
{
if (temp.Qj == "" && temp.Qk == "")
{
//el valor de los registros ya se encuentra disponible, operando
instrucciones[i].ContadorLatencia = instrucciones[i].ContadorLatencia + 1;
instrucciones[i].Estado = 2;
ufSuma = 1;
}
else
{
//aún no se poseen los valores correctos de los registros, esperando
instrucciones[i].Estado = 5;
}
}
break;
case "MUL":
temp = estacionMulDiv[pos];
if (ufMul == 1)
{
instrucciones[i].Estado = 5; //unidad funcional ocupada
}
else
{
if (temp.Qj == "" && temp.Qk == "")
{
//el valor de los registros ya se encuentra disponible, operando
instrucciones[i].ContadorLatencia = instrucciones[i].ContadorLatencia + 1;
instrucciones[i].Estado = 2;
ufSuma = 1;
}
else
{
//aún no se poseen los valores correctos de los registros, esperando
instrucciones[i].Estado = 5;
}
}
break;
}
refrescarDgv();
continue;
}
//las que estan en estado 2(EX) se verifica si cumplieron su latencia, si la cumplen pasan a estado 3(W)
if (instrucciones[i].Estado == 2)
{
if (ubicacion[0] == "STORE")
{
numRegistro = Convert.ToInt32(instrucciones[i].Rd.Substring(1));
if (registrosR[numRegistro].Contains("LOAD") || registrosR[numRegistro].Contains("STORE") || registrosR[numRegistro].Contains("ADD") || registrosR[numRegistro].Contains("MUL"))
{
//aún no estan listos los registros a usar
instrucciones[i].Estado = 5;
}
else
{
instrucciones[i].Estado = 3;
}
continue;
}
if (instrucciones[i].ContadorLatencia == instrucciones[i].Latencia)
{
instrucciones[i].Estado = 3;
}
else
{
instrucciones[i].ContadorLatencia = instrucciones[i].ContadorLatencia + 1;
}
continue;
}
//Etapa W
//las que estan en estado 3, escriben sus resultados directamente, salvo las instrucciones de almacenamiento
//que deben esperar a que sus registros esten cargados correctamente
//solo una instruccion puede escribir a memoria a la vez
//cuando escribe en memoria o en registro, se debe actualizar en todas las estaciones de espera y buffers
//los valores que se estan esperando
int posMem;
double dato;
string t;
if (instrucciones[i].Estado == 3)
{
switch (ubicacion[0])
{
case "LOAD":
//ir a memoria traer el dato en la posición calculada y ponerlo en el registro indicado
posMem = bufferCarga[pos].Valor;
dato = gMen.cargarDato(posMem);
t = ubicacion[0] + ubicacion[1];
//primero buscando todos los que esperen el valor del RD de la instrucción de carga
for (int k = 0; k < registrosR.Count; k++)
{
if (registrosR[k] == t)
{
registrosR[k] = dato.ToString();
}
}
gEstReserva.actualizarEstacionReservaAddSub(estacionAddSub, dato, t);
gEstReserva.actualizarEstacionReservaMulDiv(estacionMulDiv, dato, t);
gBuffer.liberarBufferCarga(bufferCarga, pos);
instrucciones[i].Estado = 4;
break;
case "STORE":
if (ufMemoria == 0)
{
posMem = bufferAlmacenamiento[pos].Valor;
numRegistro = Convert.ToInt32(instrucciones[i].Rd.Substring(1));
gMen.guardarDato(posMem, Convert.ToDouble(registrosR[numRegistro]));
gBuffer.liberarBufferAlmacenamiento(bufferAlmacenamiento, pos);
instrucciones[i].Estado = 4;
ufMemoria = 1;
}
else
{
instrucciones[i].Estado = 5;
}
gMen.volcarMemoria(dgv_memoria);
break;
case "ADD":
temp = estacionAddSub[pos];
if (temp.Operacion == "ADD")
{
dato = Convert.ToDouble(temp.S1) + Convert.ToDouble(temp.S2);
}
else
{
dato = Convert.ToDouble(temp.S1) - Convert.ToDouble(temp.S2);
}
t = ubicacion[0] + ubicacion[1];
//primero buscando todos los que esperen el valor del RD de la instrucción de carga
for (int k = 0; k < registrosR.Count; k++)
{
if (registrosR[k] == t)
{
registrosR[k] = dato.ToString();
}
}
gEstReserva.actualizarEstacionReservaAddSub(estacionAddSub, dato, t);
gEstReserva.actualizarEstacionReservaMulDiv(estacionMulDiv, dato, t);
gEstReserva.liberarEstacionReservaAddSub(estacionAddSub, pos);
instrucciones[i].Estado = 4;
break;
case "MUL":
temp = estacionMulDiv[pos];
if (temp.Operacion == "MUL")
{
dato = Convert.ToDouble(temp.S1) * Convert.ToDouble(temp.S2);
}
else
{
if (Convert.ToDouble(temp.S2) == 0)
{
finalizarProgramaError(instrucciones[i].IdInstruccion, " ha generado una división entre cero, programa terminado");
}
dato = Convert.ToDouble(temp.S1) / Convert.ToDouble(temp.S2);
}
t = ubicacion[0] + ubicacion[1];
//primero buscando todos los que esperen el valor del RD de la instrucción de carga
for (int k = 0; k < registrosR.Count; k++)
{
if (registrosR[k] == t)
{
registrosR[k] = dato.ToString();
}
}
gEstReserva.actualizarEstacionReservaAddSub(estacionAddSub, dato, t);
gEstReserva.actualizarEstacionReservaMulDiv(estacionMulDiv, dato, t);
gEstReserva.liberarEstacionReservaMulDiv(estacionMulDiv, pos);
instrucciones[i].Estado = 4;
break;
}
refrescarDgv();
continue;
}
}
//actualizando el cauce
gCau.siguienteCiclo(dgv_cauce, instrucciones);
}
