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.
Descargar adjuntos
COMPARTE ESTE TUTORIAL

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
TUTORIAL ANTERIOR

HAY 2 COMENTARIOS
  • Anónimo dijo:

    Donde bajo el algoritmo que entiendo desarrollaste. Si no esta disponible quisiera, apelando a tu buena voluntad, me señalaras donde puedo encontrar info para programar aplicaciones en OPC en cualquier lenguaje, de preferencia Visual ya que tengo la aplicacion para correr los programas ...

  • Anónimo dijo:

    Un atento saludo para el programador de este simulador, mi nombre es Irene soy estudiante de Ingenieria de Sistemas, cursando el VI ciclo, llevando el curso de Sistemas Operativos en el cual tengo pendiente una asignación, el de conseguir un simulador de Memoria con su respectivo codigo, es por ello me atrevo a pedirle me ayude con ello, le comunico que no es con fines lucrativos ni nada por el estilo, es solo academico. Muy atentamente y agradecida de ante mano. Irene

Conéctate o Regístrate para dejar tu comentario.