Simul_Desfrag

Autor: Moisés Brenes Valerin

Algoritmo que presenta en forma sencilla algunos metodos de ordenacion y tecnicas para fragmentar archivos utilizando vectores.

{Programa: Simulador de desfragmentador de Estructuras Dinamicas
 en Memoria Estatica.
 Desarrollado por : Moises Brenes Valerin
                    Guapiles,Limon,Costa Rica 1/Mar/04
 Objetivo:
   Desarrollo del uso del razonamiento
    para ser aplicado al Manejo de Datos, y uso de Memoria.
 Curso:
   Estructura de  Datos
   Facultad de Ingenieria.
   Escuela de Informatica.
   Colegio Leonardo Da Vinci,U.A.C.A.

}

PROGRAM Sim_Desfrag;

USES
    DOS,CRT;

CONST
    top = 10;
{top indicara la maxima capacidad de memoria fisica disponible}
 TYPE
    ARREGLO = ARRAY[1..top] OF CHAR;

VAR
    Mem  :ARREGLO;
    i    :INTEGER;
    empty:INTEGER;
    full :INTEGER;
    opc  :CHAR;
    Avail:INTEGER;
{***********************************************************************}
PROCEDURE MostrarPos(VAR i:INTEGER);
   VAR
    x:INTEGER;
   BEGIN
     TEXTCOLOR(15);
     GOTOXY(2,2);WRITE(\'Elemento \');{Es el valor del campo INFO del Nodo}
     GOTOXY(2,4);WRITE(\'P.Fisico \');
     {Para efectos didacticos seran las posiciones
     que tomen los datos dentro del vector(memoria fisica)}
     GOTOXY(2,6);WRITE(\'P.Logico \');
     {Estara representado por el valor ASCII
      de cada caracter\"A...Z\"}
     TEXTCOLOR(14+BLINK);
     GOTOXY(11,2);WRITE(\'¯¯¯¯\');
     GOTOXY(11,4);WRITE(\'¯¯¯¯\');
     GOTOXY(11,6);WRITE(\'¯¯¯¯\');
        i:=1;
        x:=20;
        WHILE i<=top DO BEGIN
              TEXTCOLOR(15);
              GOTOXY(x,1);WRITE(\'ÚÄÄÄ¿\');
              GOTOXY(x,2);WRITE(\'³   ³\');
              GOTOXY(x,3);WRITE(\'ÀÄÄÄÙ\');
        i:=i+1;
        x:=x+5;
        END;

i:=1;
        x:=22;
        WHILE i<=top DO BEGIN
              GOTOXY(x,2);WRITE(Mem[i]);
              GOTOXY(x,4);WRITE(i);
              GOTOXY(x,6);WRITE(ORD(Mem[i]));
        i:=i+1;
        x:=x+5;
        END;
END;
{***********************************************************************}
{Este procedimiento actuara como un centinela en el vector
 para informar al siguiente proceso con cuanta memoria dispone}
PROCEDURE DetectEspM(VAR empty,full,Avail:INTEGER);
   VAR
    i:INTEGER;
   BEGIN
   i    :=1;
   empty:=0;
   full :=0;
   Avail:=1;
         WHILE i<=top DO BEGIN
               IF Mem[i]=#10 THEN BEGIN
                  empty:=empty+1;
{empty
 Guardara el valor de memoria disponible;
en otras palabras cuantos posiciones sin datos existen
full
 Contiene la memoria reservada u ocupada por datos
 }
               END ELSE BEGIN
                  full:=full+1;
               END;
         i:=i+1;
         END;
               IF full=top THEN BEGIN
                  Avail:=0;{No existe de disponibilidad de memoria para
                   desfragmentar}
               END ELSE BEGIN
                  Avail:=1;{Existen suficiencia de memoria}
               END;
END;
{***********************************************************************}
{Este proceso sera empleado dentro y luego de cada proceso de
ordenamiento fisico, ya que el manejo de estructuras dinamicas estan
en funcion del orden fisico o real, luego el virtual o logico.
 }
PROCEDURE OrdenarLog(VAR i,full:INTEGER);
   VAR
    Aux:CHAR;
   BEGIN
   i:=1;
      WHILE i<=(full-1) DO BEGIN
            IF ORD(Mem[i]) > ORD(Mem[i+1]) THEN BEGIN
               Aux     :=Mem[i];
               Mem[i]  :=Mem[i+1];
               Mem[i+1]:=Aux;
            END;
     i:=i+1;
     END;
END;
{***********************************************************************}
PROCEDURE OrdenarFis(VAR i,empty,full,Avail:INTEGER);
   VAR
     flag:INTEGER;
     aux :INTEGER;
   BEGIN
{Esta subrutina mueve los elementos con datos a
las primeras posiciones, induciendo asi la fragmentacion fisica}
   IF Avail=1 THEN BEGIN
              flag:=0;
              WHILE flag=0 DO BEGIN
                    i:=1;
                    WHILE i<=top DO BEGIN
                          IF Mem[i]=#10 THEN BEGIN
                             Mem[i]  :=Mem[i+1];
                             Mem[i+1]:=#10;
                          END;
                    i:=i+1;
                    END;
                    aux:=full;
                    WHILE aux<=top DO BEGIN
                          IF Mem[i]=#10 THEN BEGIN
                             flag:=0;
                          END ELSE BEGIN
                             flag:=1;
                          END;
                    aux:=aux+1;
                    END;
              END;
        OrdenarLog(i,full);
   END ELSE BEGIN
{Si no existe capacidad para la desfragmentacion
se da un mensaje de error de overflow}
              GOTOXY(30,10);WRITE(\'MEMORIA INSUFICIENTE\');
   END;
      MostrarPos(i);
      GOTOXY(2, 8);WRITE(\'Espacio Libre     ... \',empty);
      GOTOXY(2, 9);WRITE(\'Espacio Reservado ... \',full);
      GOTOXY(2,10);WRITE(\'Capacidad Memoria ... \',top);
END;
{***********************************************************************}
BEGIN
CLRSCR;
   TEXTMODE(Lo(LastMode)+Font8x8);
{Se puede trabajar con las posiciones de memoria, y los
valores de los INFO}
   Mem[ 1]:=#10;
   Mem[ 2]:=\'C\';
   Mem[ 3]:=#10;
   Mem[ 4]:=\'H\';
   Mem[ 5]:=#10;
   Mem[ 6]:=\'D\';
   Mem[ 7]:=#10;
   Mem[ 8]:=\'C\';
   Mem[ 9]:=#10;
   Mem[10]:=#10;

GOTOXY(2,12);WRITE(\'1 Mostrar posiciones\');
   GOTOXY(2,13);WRITE(\'2 Desfragmentar\');
   GOTOXY(2,14);WRITE(\'3 Salir\');

WHILE  opc<>\'3\' DO BEGIN
      opc:=\' \';
      WHILE (opc<#49) OR (opc>#51) DO BEGIN
         GOTOXY(20,14);WRITE(\' \');opc:=READKEY;GOTOXY(20,14);
      END;

IF opc=\'1\' THEN BEGIN
            MostrarPos(i);
         END;
            IF opc=\'2\' THEN BEGIN
               DetectEspM(empty,full,Avail);
               OrdenarFis(i,empty,full,Avail);
            END;
               IF opc=\'3\' THEN BEGIN
                  WRITELN(\'Elijio salir\');
                END;
   END;
END.

Utilidades

	Leer comentarios (3)
	Escribir comentario
	Puntuación: No disponible
	Votar
	Recomendar este código
	Estadísticas

Patrocinados

Hospedaje web y servidores dedicados linux por Ferca Network