public int Close(string nameArchivo, int processID)
{
int posArch = BuscaArch(nameArchivo);
int tOP = 0;
// Si el archivo se encuentra en la tabla, y si el num de proceso que quiere cerrarlo es el que lo tiene
// abierto, lo cierro cambiando el estado a -1
if (posArch != -1 && TablaArchivos[posArch].getEstado() == processID)
{
Indicadores indicador = new Indicadores();
indicador.tGestionTotal = disp.GetTprocesamient(); //DUDA lu: no se si esto esta bien!
indicador.tipoOp = 'C';
indicador.tEspera = tSimulacion - TablaOperaciones[getOpActual()].Tarribo;
indicador.tLectoEscritura = 0;
indicador.tSatisfaccion = indicador.tEspera + indicador.tLectoEscritura + indicador.tGestionTotal;
tOP = indicador.tGestionTotal + indicador.tLectoEscritura;
indicadoresOP.Add(indicador);
TablaArchivos[posArch].setEstado(-1);
}
else if (TablaArchivos[posArch].getEstado() != -processID) // si el archivo lo tiene abierto otro proceso, agrego esta operacion a la cola de espera
{
if (!Find(ColaEspera, GetContadorOp()))
{
ColaEspera.Add(GetContadorOp()); // Si no es asi, lo agrego a la cola de espera
}
}
return(tOP);
}
public int Open(string nameArchivo, int processID)
{
int posArch = BuscaArch(nameArchivo);
int tOP = 0;
// Si el archivo se encuentra en la tabla, y si el estado es -1, lo abro cambiando el numero de estado por
// el numero de proceso que lo quiere abrir.
if (posArch != -1 && TablaArchivos[posArch].getEstado() == -1)
{
Indicadores indicador = new Indicadores();
indicador.tGestionTotal = disp.GetTprocesamient(); //DUDA lu: no se si esto esta bien!
indicador.tipoOp = 'O';
indicador.tEspera = tSimulacion - TablaOperaciones[getOpActual()].Tarribo;
indicador.tLectoEscritura = 0;
indicador.tSatisfaccion = indicador.tLectoEscritura + indicador.tGestionTotal + indicador.tEspera;
tOP = indicador.tLectoEscritura + indicador.tGestionTotal;
indicadoresOP.Add(indicador);
TablaArchivos[posArch].setEstado(processID);
}
else if (TablaArchivos[posArch].getEstado() != -1) // Si el archivo ya se encuentra abierto, agrego esta operacion a la cola de espera
{
if (!Find(ColaEspera, GetContadorOp()))
{
ColaEspera.Add(GetContadorOp()); // Si no es asi, lo agrego a la cola de espera
}
}
return(tOP);
}
public int Create(int idProc, int cant_uA, string name)
{
int tOP = 0;
if (BuscaArch(name) == -1) //comprueba que el archivo no este creado ya
{
Archivo archivo = new Archivo(name, cant_uA);
if (disp.GetLibres(cant_uA, GetOrganizacionFisica(), ref archivo))
{
Indicadores indicador = new Indicadores();
TablaArchivos.Add(archivo); //agregamos el nuevo archivo a la tabla
indicador.tGestionTotal = disp.TprocesamientoBloquesLibres(GetAdminEspacio(), cant_uA);
indicador.tLectoEscritura = 0;
indicador.tEspera = tSimulacion - TablaOperaciones[getOpActual()].Tarribo;
indicador.tipoOp = 'N';
indicador.tSatisfaccion = indicador.tLectoEscritura + indicador.tGestionTotal + indicador.tEspera;
tOP = indicador.tGestionTotal + indicador.tLectoEscritura;
indicadoresOP.Add(indicador);
}
}
else //si el archivo ya esta creado
{
Console.WriteLine("Error: El archivo ya se encuentra creado!");
}
return(tOP);
}
public int Delete(string nameArchivo)
{
int numBloque = 0;
int tOP = 0;
int posArch = BuscaArch(nameArchivo); //busca si existe el arhivo
// Corroboro que el archivo se encuentre en la tabla (por nombre) y que se encuentre cerrado
if (posArch != -1 && TablaArchivos[posArch].getEstado() == -1) //Estado -1 significa que el archivo está cerrado
{
// Dejo cada bloque como libre
for (int j = 0; j < TablaArchivos[posArch].getTablaDireccion().Count; j++)
{
numBloque = TablaArchivos[posArch].getTablaDireccion()[j];
disp.CambiarEstadoOcupado(numBloque, 0);
if (organizacionFisica == Org.Contigua)
{
disp.CambiarEstadoBurocracia(numBloque, 0);
}
else
{
disp.CambiarEstadoBurocracia(numBloque, 0);
}
disp.CambiarEstadoReserva(numBloque, false);
}
Indicadores indicador = new Indicadores();
indicador.tLectoEscritura = 0;
indicador.tGestionTotal = disp.GetTprocesamient();
indicador.tEspera = tSimulacion - TablaOperaciones[getOpActual()].Tarribo;
indicador.tSatisfaccion = indicador.tLectoEscritura + indicador.tEspera + indicador.tGestionTotal;
indicador.tipoOp = 'D';
indicadoresOP.Add(indicador);
tOP = indicador.tLectoEscritura + indicador.tGestionTotal;
// Lo quito de la tabla de archivos
TablaArchivos.RemoveAt(posArch);
}
else if (TablaArchivos[posArch].getEstado() != -1) // Si el archivo se encuentra abierto por algun proceso, lo agrego a la cola de espera
{
if (!Find(ColaEspera, GetContadorOp()))
{
ColaEspera.Add(GetContadorOp()); // Si no es asi, lo agrego a la cola de espera
}
}
return(tOP);
}
//bloquesRealocar son los bloques totales!!!!
public bool realocar(ref Archivo arch, int BloquesRealocar, int BloquesAntes, ref Indicadores indicador)
{
bool aux = false;
int uArealocar = BloquesRealocar * disp.GetTamBloques();
if (disp.GetLibres(uArealocar, GetOrganizacionFisica(), ref arch))
{
indicador.tGestionTotal = BloquesAntes * (disp.GetTprocesamient() + disp.GetTseek()) + disp.TprocesamientoBloquesLibres(GetAdminEspacio(), uArealocar);
aux = true;
}
return(aux);
}
public int Read(string name, int idProc, int offset, int cant_uA)
{
int tOP = 0;
int posArch = BuscaArch(name);
if (posArch != -1) // Verifico que el archivo este creado
{
if (TablaArchivos[posArch].getEstado() == idProc) // Verifico que el proceso que abrio el archivo sea el que lo quiere leer
{
Archivo arch = TablaArchivos[posArch]; //busco archivo en la tabla
Indicadores indicador = new Indicadores();
int inicio = (int)Math.Floor((decimal)(offset) / (decimal)(disp.GetTamBloques())); //bloque donde comienza a leerse
int fin = (int)Math.Ceiling((decimal)(offset + cant_uA) / (decimal)(disp.GetTamBloques()));
if (fin > arch.getTablaDireccion().Count) // Control de cuanto se quiere leer
{
throw new Exception("Se quiere leer mas de lo que hay");
}
switch (GetOrganizacionFisica())
{
case Org.Contigua:
{
indicador.tGestionTotal = disp.GetTseek(); //el t de gestion es el t en ir al primer bloque
break;
}
case Org.Enlazada:
{
int bloqueLeido = -1;
for (int i = 0; i < fin; i++)
{
if (arch.getTablaDireccion()[i] != bloqueLeido - 1) //comprueba si los bloques son contiguos
{
indicador.tGestionTotal += disp.GetTseek();
}
bloqueLeido = arch.getTablaDireccion()[i];
}
indicador.tGestionTotal += inicio * disp.GetTlectura();
break;
}
case Org.Indexada:
{
indicador.tGestionTotal = (2 * disp.GetTseek() + disp.GetTprocesamient()) * (fin - inicio);
break;
}
}
indicador.tEspera = tSimulacion - TablaOperaciones[getOpActual()].Tarribo;
indicador.tLectoEscritura = (fin - inicio) * disp.GetTlectura();
indicador.tSatisfaccion = indicador.tGestionTotal + indicador.tEspera + indicador.tLectoEscritura;
indicador.tipoOp = 'R';
tOP = indicador.tSatisfaccion - indicador.tEspera;
indicadoresOP.Add(indicador);
}
else // Si el archivo esta abierto x otro proceso --> lo agrego a la cola de espera
{
if (!Find(ColaEspera, GetContadorOp()))
{
ColaEspera.Add(GetContadorOp()); // Si no es asi, lo agrego a la cola de espera
}
}
}
return(tOP);
}
public int Write(string name, int idProc, int offset, int cant_uA)
{
int tOP = 0;
int posArch = BuscaArch(name);
if (posArch != -1) // Verifico que el archivo este creado
{
if (TablaArchivos[posArch].getEstado() == idProc) // Verifico que el proceso que abrio el archivo sea el que lo quiere leer
{
int inicio = (int)Math.Floor((decimal)(offset) / (decimal)(disp.GetTamBloques())); //bloque donde comienza a leerse
int fin = (int)Math.Ceiling((decimal)(offset + cant_uA) / (decimal)(disp.GetTamBloques()));
Indicadores indicador = new Indicadores();
Archivo arch = TablaArchivos[posArch]; //busco archivo en la tabla
if (fin > arch.getTablaDireccion().Count&& GetOrganizacionFisica() == Org.Contigua) //solo se realoca si es contigua
{
if (!realocar(ref arch, fin, arch.getTablaDireccion().Count, ref indicador)) //PROBAR SI MODIFICA ARCH ASI!!!!!!!
{
throw new Exception("No se pudo realocar.");
}
}
else if (fin > arch.getTablaDireccion().Count) //para enlazada e indexada
{
indicador.tGestionTotal = disp.TprocesamientoBloquesLibres(GetAdminEspacio(), fin - arch.getTablaDireccion().Count);
}
switch (GetOrganizacionFisica())
{
case Org.Contigua:
{
indicador.tGestionTotal += disp.GetTseek(); //el t de gestion es el t en ir al primer bloque
break;
}
case Org.Enlazada:
{
int bloqueLeido = -1;
for (int i = 0; i < fin; i++)
{
if (arch.getTablaDireccion()[i] != bloqueLeido - 1) //comprueba si los bloques son contiguos
{
indicador.tGestionTotal += disp.GetTseek();
}
bloqueLeido = arch.getTablaDireccion()[i];
}
indicador.tGestionTotal += inicio * disp.GetTlectura();
break;
}
case Org.Indexada:
{
indicador.tGestionTotal += (2 * disp.GetTseek() + disp.GetTprocesamient()) * (fin - inicio);
break;
}
}
indicador.tEspera = tSimulacion - TablaOperaciones[getOpActual()].Tarribo;
indicador.tLectoEscritura = (fin - inicio) * disp.GetTescritura();
indicador.tSatisfaccion = indicador.tGestionTotal + indicador.tEspera + indicador.tLectoEscritura;
indicador.tipoOp = 'W';
tOP = indicador.tSatisfaccion - indicador.tEspera;
indicadoresOP.Add(indicador);
}
else
{
if (!Find(ColaEspera, GetContadorOp()))
{
ColaEspera.Add(GetContadorOp()); // Si no es asi, lo agrego a la cola de espera
}
}
}
return(tOP);
}
