コード例 #1
0
ファイル: FileSim.cs プロジェクト: ayrton30/FileSym
        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);
        }
コード例 #2
0
ファイル: FileSim.cs プロジェクト: ayrton30/FileSym
        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);
        }
コード例 #3
0
ファイル: FileSim.cs プロジェクト: ayrton30/FileSym
        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);
        }
コード例 #4
0
ファイル: FileSim.cs プロジェクト: ayrton30/FileSym
        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);
        }
コード例 #5
0
ファイル: FileSim.cs プロジェクト: ayrton30/FileSym
        //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);
        }
コード例 #6
0
ファイル: FileSim.cs プロジェクト: ayrton30/FileSym
        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);
        }
コード例 #7
0
ファイル: FileSim.cs プロジェクト: ayrton30/FileSym
        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);
        }