{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.
Simul_Desfrag
Algoritmo que presenta en forma sencilla algunos metodos de ordenacion y tecnicas para fragmentar archivos utilizando vectores.
Descargar adjuntos
COMPARTE ESTE TUTORIAL
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN LINKEDIN
COMPARTIR EN WHATSAPP