Simul_Desfrag

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.