X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/09df7c33240167f462c5cbdf3ba569b03f8f7037..ee98a67093a8f8d008ae7781590c993d341ce642:/doc/informe.lyx diff --git a/doc/informe.lyx b/doc/informe.lyx index b7619bd..f25411c 100644 --- a/doc/informe.lyx +++ b/doc/informe.lyx @@ -49,87 +49,2928 @@ Estructura com \layout Section Tipos +\layout Standard + +Se detallan a continuación los tipos de datos definidos y utilizados en + las distintas implementaciones que conforman nuestro sistema, siendo el + más importante de ellos, la estructura +\family typewriter +EMUFS +\family default + que actúa como interfaz común para el manejo de cualquier tipo de archivo + (no importa que tipo de organización física posea un archivo, esta estructura + prooverá una interfaz (funciones) para su manejo). +\layout Subsection + +EMUFS +\layout Standard + + +\family typewriter +EMUFS +\family default +\emph on + +\emph default +es la estuctura principal que encapsula todas las funciones para el manejo + de un archivo de datos. + Posee punteros a funciones que dependiendo de la organización fisica por + la cual se opte dentro del sistema, serán asignados de acorde. + +\layout Standard + +Su declaración puede ser observada en el archivo +\series bold +emufs.h +\series default +y la misma cuenta con los siguiente campos: +\layout Itemize + + +\family typewriter +EMUFS_Tipo +\family default + que es un tipo enumerado que indica cual es la organización. +\layout Itemize + + +\family typewriter +EMUFS_BLOCK_SIZE +\family default + indica el tamaño del bloque para los tipos 1 y 3. +\layout Itemize + + +\family typewriter +EMUFS_REG_SIZE +\family default + indica el tamaño del registro, para el tipo 3 que posee tamaño constante. +\layout Itemize + + +\family typewriter +void **leer_bloque() +\family default +puntero a la función para leer un bloque. +\layout Itemize + + +\family typewriter +void *leer_bloque_raw() +\family default + puntero a la función para leer un bloque, el anterior y el siguiente. +\layout Itemize + + +\family typewriter +void **leer_registro() +\family default + puntero a la función para leer un registro. +\layout Itemize + + +\family typewriter +void **leer_registro_raw() +\family default + puntero a la función para leer un registro con su encabezado. +\layout Itemize + + +\family typewriter +EMUFS_REG_ID *grabar_registro() +\family default + puntero a la función para grabar un registro. +\layout Itemize + + +\family typewriter +EMUFS_REG_ID *modificar_registro() +\family default +puntero a la función para modificar un registro. +\layout Itemize + + +\family typewriter +int *borrar_registro() +\family default + puntero a la función para borrar un registro. +\layout Itemize + + +\family typewriter +EMUFS_Estadisticas *leer_estadisticas() +\family default + puntero a la función para cargar una estructura con las estadísticas. +\layout Itemize + + +\family typewriter +void *compactar() +\family default + puntero a la función para compactar un archivo. +\layout Itemize + + +\family typewriter +char *nombre +\family default + almacena el nombre del archivo sin extensión. +\layout Standard + +Esta estructura define los valores de sus punteros según el tipo de organización + que se desee manejar y esto se realiza a través del API emufs, implementado + en +\series bold +emufs.c +\series default +, que se describirá posteriormente. +\layout Standard + +Por ejemplo si se desea crear un archivo de nombre +\begin_inset Quotes eld +\end_inset + +facturas +\begin_inset Quotes erd +\end_inset + + organizado de la forma 3, se invoca a la función +\family typewriter +EMUFS *emufs_crear(const char *filename, EMUFS_Tipo tipo,EMUFS_BLOCK_SIZE + tam_bloque, EMUFS_REG_SIZE tam_reg), +\family default +donde +\family typewriter + filename +\family default +es el nombre que tendrán los archivos de datos e índice, +\family typewriter +tipo +\family default + es el tipo de organización - bloques parametrizados y registros constantes + en este caso-, +\family typewriter +tam_bloque +\family default + es el tamaño del bloque, y +\family typewriter +tam_reg +\family default + es el tamaño del registro. +\layout Standard + +Para las diferentes organizaciones puede ser que alguno de estos 2 últimos + valores no tengan sentido almacenarlas y tomaran un valor por defecto igual + a cero. +\layout Standard + +Según el tipo de organización, se inicializan los punteros a las funciones. + Para el ejemplo +\family typewriter +leer_bloque +\family default + se igualará a +\family typewriter +emufs_tipo3_leer_bloque() +\family default +, y lo mismo sucede con los demás. +\layout Subsection + +EMUFS_Tipo +\layout Standard + + +\family typewriter +EMUFS_Tipo +\family default + es un tipo de dato enum, el cual será utilizado en la cabecera de todo + archivo de datos ( +\series bold +.dat +\series default +), para indicar los distintos tipos de organización física. + Su declaración puede verse en el archivo +\series bold +emufs.h. +\layout Standard + +A saberse los valores y significado correspondiente que puede tomar este + tipo de dato son: +\layout Enumerate + +Archivos con registros de longitud variable y bloques parametrizables. +\layout Enumerate + +Archivos con registros de longitud variable sin bloques. +\layout Enumerate + +Archivos con registros de longitud fija y bloques parametrizables. +\layout Subsection + +EMUFS_Estadisticas +\layout Standard + + +\family typewriter +EMUFS_Estadisticas +\family default + es una estructura que almacenará los datos pertinentes a las estadísticas + de un archivo dado, y será utilizada para visualizar dichas observaciones + a través de la GUI. +\layout Standard + +Su declaración puede ser observada en el archivo +\series bold +emufs.h +\series default +y la misma cuenta con los siguiente campos: +\layout Itemize + + +\family typewriter +unsigned long +\family default + tam_archivo: indica el tamaño del archivo de datos (.dat) en bytes. +\layout Itemize + + +\family typewriter +unsigned long +\family default + tam_archivos_aux: indica el tamaño de los archivos auxiliares sumados en + bytes. +\layout Itemize + + +\family typewriter +unsigned long +\family default + tam_info_control_dat: indica la cantidad de bytes en información de control + utilizados para el archivo. +\layout Itemize + + +\family typewriter +unsigned long +\family default + media_fs: promedio de espacio libre en el archivo de datos (por bloque + o gap promedio segun la org) +\layout Itemize + + +\family typewriter +unsigned long +\family default + total_fs: total de espacio libre en el archivo de datos. +\layout Itemize + + +\family typewriter +unsigned long +\family default + max_fs: máximo espacio libre en el archivo de datos (en un bloque o máximo + gap segun la org). +\layout Itemize + + +\family typewriter +unsigned long +\family default + min_fs: idem pero mínimo. +\layout Itemize + + +\family typewriter +unsigned long +\family default + cant_bloques: cantidad de bloques en el archivo de datos (. +\series bold +dat +\series default +) +\layout Itemize + + +\family typewriter +unsigned long +\family default + cant_registros: cantidad de registros en el archivo de datos ( +\series bold +.dat +\series default +) +\layout Standard + +En base a la estructura descripta anteriormente y mediante la utilización + de la función +\family typewriter +emufs_leer_estadisticas() +\family default + disponible en la estructura común +\family typewriter +EMUFS +\family default + handler de cualquier tipo de archivo, podremos obtener una serie de estadística +s que pasamos a detallar (más alla de los datos básicos como cant registros, + cant bloques, tam archivo, etc): +\layout Itemize + + +\emph on +Relación entre espacio libre y el tamaño del archivo de datos ( +\series bold +.dat +\series default +) +\layout Itemize + +Relación entre el espacio ocupado por información de control y el tamaño + del archivo de datos ( +\series bold +.dat +\series default +) +\layout Itemize + +Cantidad promedio de espacio libre (en bloque o gap promedio) +\layout Itemize + +Desviaciones extremas de espacio libre (máximo/mínimo espacio libre en bloque + o mayor/menor gap) +\layout Subsection + +Tipos Comunes +\layout Standard + +En la implementación de cada tipo de organización física, así como tambien + en las API de los archivos auxiliares comunes a ellas, se da la utilización + de tipo definidos para una clara interfaz entre las mismas, los cuales + son brevemente descriptos a continuación y pueden ser hayados en el archivo + +\series bold +emufs.h +\series default +: +\layout Itemize + +typedef +\family typewriter +unsigned long EMUFS_REG_ID +\family default +: usado para representar un +\emph on +Id +\emph default + de un registro. +\layout Itemize + +typdef +\family typewriter +unsigned long EMUFS_REG_SIZE +\family default +: usado para representar el tamaño en bytes de un registro. +\layout Itemize + +typedef +\family typewriter +unsigned long EMUFS_BLOCK_ID +\family default +: usado para representar un número de bloque. +\layout Itemize + +typdef +\family typewriter +unsigned long EMUFS_BLOCK_SIZE +\family default +: usado para representar el tamaño en bytes de un bloque. +\layout Itemize + +typedef +\family typewriter +unsigned long EMUFS_FREE +\family default +: usado para representar espacio libre en bytes. +\layout Itemize + +typedef +\family typewriter +unsigned long EMUFS_OFFSET +\family default +: usado para representar un offset. +\layout Section + + +\begin_inset LatexCommand \label{sec:cabecera_gral} + +\end_inset + +Organización física general de un archivo E +\begin_inset Formula $\mu$ +\end_inset + +FS +\layout Standard + +Todo archivo E +\begin_inset Formula $\mu$ +\end_inset + +FS está compuesto por 4 archivos a nivel de sistema operativo: archivo de + datos (con 3 formatos posibles, ver páginas +\begin_inset LatexCommand \pageref{cha:tipo1} + +\end_inset + +, +\begin_inset LatexCommand \pageref{cha:tipo2} + +\end_inset + + y +\begin_inset LatexCommand \pageref{cha:tipo3} + +\end_inset + +), archivo de índice (ver página +\begin_inset LatexCommand \pageref{sec:idx} + +\end_inset + +), archivo de control de espacio libre (ver página +\begin_inset LatexCommand \pageref{sec:fsc} + +\end_inset + +) y archivo de índices recuperables (ver página +\begin_inset LatexCommand \pageref{sec:did} + +\end_inset + +). +\layout Standard + +El archivo de datos está compuesto por: +\layout Itemize + +Una +\emph on +cabecera general +\emph default + compuesta por un +\family typewriter +int +\family default + (4 bytes en plataformas Linux de 32 bits) que representa el tipo de archivo. +\layout Itemize + +Datos dependientes del tipo de archivo. +\layout Standard + +La +\emph on +cabecera general +\emph default + es utilizada para poder detectar el formato de un archivo al abrirlo. + Los datos dependientes del tipo de archivo serán explicados en sus secciones + correspondientes. +\layout LyX-Code + +archivo +\layout LyX-Code + ++-----------+--------------------------------------------//-+ +\layout LyX-Code + +| tipo | Datos dependientes del tipo de archivo ... + +\backslash + +\backslash + | +\layout LyX-Code + ++-----------+--------------------------------------------//-+ +\layout LyX-Code + +/- 4 bytes -/ +\layout Chapter + +Archivos Auxiliares +\layout Standard + +Acompañando al archivo de datos ( +\series bold +.dat +\series default +) el cual es responsable de la contención de los registros, tendremos tres + archivos auxiliares ( +\series bold +.idx +\series default +, +\series bold +.fsc +\series default + y +\series bold +.did +\series default +) cuya funcionalidad y propósito pasamos a describir a continuación, sin + antes remarcar que los tres archivos poseen una sola implementación para + las distintas formas de organización física que hemos implementado (tres + para ser mas exactos). +\layout Standard + +Entre las ventajas de poseer la misma implementación se encuentra el tener + un API común entre los tres tipos para el manejo de la localización de + sus registros, administración de espacio libre e Id's liberados, sin necesidad + de realizar n-implementaciones para un mismo objetivo final. +\layout Standard + +Además, la obtención de ciertos datos estadísticos como espacio libre, o + cantidad de registros, se realiza a través de la misma interfaz, y también + se ha facilitado en cierto grado la re-organización física de un archivo + (pasar de un tipo a otro), dado el uso de estos tres archivos auxiliares + en común para funciones tan predominantes como índexación, administración + de espacio libre y recuperación de Id's. +\layout Section + + +\begin_inset LatexCommand \label{sec:idx} + +\end_inset + +Archivo índice +\layout Standard + +El archivo índice (.idx), permite la localización de los registros en el + .DAT de forma directa, mediante la obtención de su offset respecto del inicio + del .dat, o nro bloque (segun el tipo de organización física) en donde se + encuentra un registro dado, indicado por su +\emph on +id_reg. +\layout Standard + +Los registros de este archivo se encuentran representados una estructura + que indica un número de registro y el bloque u offset en donde se encuentra + el mísmo. +\layout Standard + +Es necesario que este archivo esté ordenado por +\emph on +id_reg +\emph default +, ya que esto permitirá el acceso directo al mismo, para la rápida obtención + del nro de bloque u offset y posterior búsqueda de un registro en el archivo + de datos. +\layout Subsection + +Organización física +\layout Standard + +Los registros de este archivo se encuentran representados a nivel codigo + por el siguiente tipo de dato interno ( +\family typewriter +EMUFS_IDX +\family default +): +\layout LyX-Code + +typedef unsigned long EMUFS_REG_ID; +\layout LyX-Code + +typedef unsigned long EMUFS_OFFSET; +\layout LyX-Code + +typedef struct emufs_idx_t { +\layout LyX-Code + + EMUFS_REG_ID id_reg; +\layout LyX-Code + + EMUFS_OFFSET location; +\layout LyX-Code + +} EMUFS_IDX; +\layout Standard + + +\begin_inset Float table +placement H +wide false +collapsed true + +\layout Caption + +Ejemplo de registro en archivo índice (.idx), para un archivo de organizacion + Tipo 1 y 3 +\layout Standard + + +\begin_inset Tabular + + + + + + + +\begin_inset Text + +\layout Standard + +id_reg +\end_inset + + +\begin_inset Text + +\layout Standard + +nro_bloque +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + + + +\begin_inset Text + +\layout Standard + +5 +\end_inset + + +\begin_inset Text + +\layout Standard + +54 +\end_inset + + +\begin_inset Text + +\layout Standard + +Indica que el registro de id_reg = 5, se encuentra en el bloque 54 +\end_inset + + + + +\end_inset + + +\end_inset + + +\begin_inset Float table +placement H +wide false +collapsed true + +\layout Caption + +Ejemplo de registro en archivo índice (.idx), para un archivo de organizacion + Tipo 2 +\layout Standard + + +\begin_inset Tabular + + + + + + + +\begin_inset Text + +\layout Standard + +id_reg +\end_inset + + +\begin_inset Text + +\layout Standard + +nro_bloque +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + + + +\begin_inset Text + +\layout Standard + +5 +\end_inset + + +\begin_inset Text + +\layout Standard + +54 +\end_inset + + +\begin_inset Text + +\layout Standard + +Indica que el registro de id_reg = 5, se encuentra en el bloque 54 +\end_inset + + + + +\end_inset + + +\end_inset + + +\layout Standard + + +\series bold +\emph on +Nota: +\series default +\emph default +Como se puede observar, para distintas organizaciones el significado de + los registros en este archivo es diferente y se utilizará de distinta manera + en consecuencia. +\layout Subsection + +Comportamiento +\layout Standard + +Las declaraciones e implementación se pueden encontrar en +\series bold +\emph on +idx.h +\series default +\emph default + y +\series bold +\emph on +idx.c +\series default +\emph default + respectivamente: +\layout List +\labelwidthstring 00.00.0000 + + +\series bold +\emph on +Búsqueda: +\series default +\emph default + Los registros del archivo indice ( +\series bold +.idx +\series default +), poseen una correspondencia 1 a 1, con los Id's de los registros en el + archivo de datos ( +\series bold +.dat +\series default +). + Con esto, queremos decir que el N-ésimo registro del archivo índice, será + aquél que posea la información para localizar al registro cuyo +\family typewriter +id_reg +\family default + es N, dentro del archivo de datos ( +\series bold +.dat +\series default +). +\newline + +\series bold +NOTA: +\series default + Cabe aclarar que por si bien el indice se encuentra ordenado por +\family typewriter +id_reg +\family default +, los registros en el archivo de datos, por lo general no lo estarán. + (ordenados por id). + +\newline +Ver: +\family typewriter +emufs_idx_buscar_registro() +\layout List +\labelwidthstring 00.00.0000 + + +\series bold +Alta: +\series default + Ante la alta de un registro en el archivo de datos, se insetará un nuevo + registro en el archivo índice, con el id_reg del registro en cuestion, + y el offset u bloque donde se lo haya grabado en disco. +\newline +Ver: +\family typewriter +emufs_idx_agregar() +\layout List +\labelwidthstring 00.00.0000 + + +\series bold +Baja: +\series default + Ante el borrado de un registro del archivo de datos, se accederá el registro + correspondiente en el índice, y se actualizara su LOCATION, estableciendolo + en el valor -1 UL, el cual indica que ese registro ha sido eliminado y + por ende no se lo podrá localizar en el futuro. + Como se verá mas adelante, según el tipo de organización física, el registro + puede ser borrado concretamente del . +\series bold +dat +\series default + o nó. + +\newline +Ver: +\family typewriter +emufs_idx_borrar() +\layout List +\labelwidthstring 00.00.0000 + + +\series bold +Modificación: +\series default + Ante la modificación en la posición física de un registro dentro del archivo + de datos (por ejemplo luego del proceso de recompactación, se realizará + la modificación respectiva del campo +\family typewriter +location +\family default +. +\newline +Ver: +\family typewriter +emufs_idx_actualizar() +\layout Section + + +\begin_inset LatexCommand \label{sec:fsc} + +\end_inset + +Archivo de control de espacio libre +\layout Standard + +El archivo de espacio libre ( +\series bold +.fsc +\series default +) (espacio por bloque o gaps en archivo, según el tipo de organización física), + tiene como función la administración del espacio libre, generado por previas + eliminaciones de registros en el archivo de datos. + El mismo, nos indicará donde hay lugar para insertar un nuevo registro. +\layout Standard + +Para el caso de una organización por bloque, nos dirá en que bloque o si + se debe generar un nuevo bloque. + En el caso de la organización sin bloques, nos indicará en que gap o si + al final del archivo. +\layout Standard + +Los registros de este archivo se encuentran representados una estructura + que indica un número de bloque u offset y el espacio libre disponible en + el mismo (o apartir del mismo en el caso del offset). +\layout Standard + + +\series bold +Nota +\series default +: Por requerimiento del algoritmo de compactación el tipo de organización + física con reg long var, sin bloques, los gaps se graban en forma ordenada + en el (.fsc). + (El orden se corresponde con lo que hay en el .dat). +\layout Subsection + +Organización Física +\layout Standard + +Los registros de este archivo se encuentran representados a nivel codigo + por el siguiente tipo de dato interno ( +\family typewriter +EMUFS_FSC +\family default +): +\layout LyX-Code + +typedef struct emufs_fsc_t { +\layout LyX-Code + + unsigned long int marker; +\layout LyX-Code + + unsigned long int freespace; +\layout LyX-Code + +} EMUFS_FSC; +\layout Standard + + +\series bold +\emph on + +\begin_inset Float table +placement H +wide false +collapsed true + +\layout Caption + +Ejemplo de registro en archivo de control de espacio libre para un archivo + con bloques +\layout Standard + + +\begin_inset Tabular + + + + + + + +\begin_inset Text + +\layout Standard + +nro_bloque +\end_inset + + +\begin_inset Text + +\layout Standard + +freespace +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + + + +\begin_inset Text + +\layout Standard + +12 +\end_inset + + +\begin_inset Text + +\layout Standard + +120 +\end_inset + + +\begin_inset Text + +\layout Standard + +Indica que en el bloque 12, hay 120 bytes libres al final del mismo. +\end_inset + + + + +\end_inset + + +\end_inset + + +\begin_inset Float table +placement H +wide false +collapsed true + +\layout Caption + +Ejemplo de registro en archivo de +\emph on +gaps +\emph default + para un archivo sin bloques +\layout Standard + + +\begin_inset Tabular + + + + + + + +\begin_inset Text + +\layout Standard + +offset +\end_inset + + +\begin_inset Text + +\layout Standard + +freespace +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + + + +\begin_inset Text + +\layout Standard + +12 +\end_inset + + +\begin_inset Text + +\layout Standard + +120 +\end_inset + + +\begin_inset Text + +\layout Standard + +Indica que a partir del byte 12 del archivo de datos, hay 120 bytes libres. +\end_inset + + + + +\end_inset + + +\end_inset + + +\layout Standard + + +\series bold +\emph on +Nota: +\series default +\emph default +Como se puede observar, para distintas organizaciones el significado de + los registros en este archivo es diferente y se utilizará de distinta manera + en consecuencia. +\layout Subsection + +Funciones principales +\layout Standard + +Las declaraciones e implementación se pueden encontrar en +\series bold +\emph on +fsc.h +\series default +\emph default + y +\series bold +\emph on +fsc.c +\series default +\emph default + respectivamente: +\layout List +\labelwidthstring 00.00.0000 + + +\series bold +Búsqueda: +\series default + Ante la operación de alta de un registro en el archivo de datos, se realizará + la búsqueda de espacio libre donde este podrá ser insertado. + En el caso de organizaciones con bloques, se buscará en que +\family typewriter +nro_bloque +\family default + se posee espacio suficiente para albergar el nuevo registro. + En el caso de organizacion sin bloque, se buscará un gap o espacio libre + en el archivo, obteniéndose en consecuencia, el +\family typewriter +offset +\family default + hasta el mismo. +\newline +Ver: +\family typewriter +emufs_fsc_buscar_lugar() +\layout List +\labelwidthstring 00.00.0000 + + +\series bold +Alta/Mod: +\series default + Luego de una operación de baja o alta de un registro en el archivo de datos + ( +\series bold +.dat +\series default +), incrementará o decrementará respectivamente el espacio libre en el archivo + de datos, y esto deberá ser registrado, agregando un nuevo registro en + el archivo de espacios libres ( +\series bold +.fsc +\series default +) o bien modificandoló. +\newline + +\newline +En el caso de organizaciónes con bloques, se actualizará el valor del espacio + libre +\family typewriter +freespace +\family default + en el bloque (ya sea incrementandoló o decrementandoló) o bien se insertará + un nuevo registro en caso de que se esté creando un nuevo bloque en el + archivo de datos (en este caso no será debido a un alta o baja de registro + como se mencionó al principio). +\newline + +\newline +Para el caso de organización sin bloques, en el caso de baja de un registro + de datos ( +\series bold +.dat +\series default +) se insertará un nuevo registro en el +\series bold +.fsc +\series default + dando cuenta de la aparición de un nuevo gap en el archivo de datos ( +\series bold +.dat +\series default +), y en caso de estar este lindante con otro gap, se realizará el merge + pertinente. + (esto esta explicado más en profundidad en los casos particulares de organizaci +ón fisica, registros variables sin bloques). + Para el caso de una alta en el archivo de datos ( +\series bold +.dat +\series default +), el valor del gap donde se haya insertado se actualizará. + +\newline +Ver: +\family typewriter +emufs_fsc_agregar(), emufs_fsc_agregar_gap(), emufs_fsc_actualizar(), emufs_fsc_ +actualizar_gap(). +\layout List +\labelwidthstring 00.00.0000 + + +\series bold +Baja +\series default +: Unicamente para el caso de una organización que presente gaps en el archivo, + se podrá dar a lugar la eliminación de un registro del archivo de espacios + libres ( +\series bold +.fsc) +\series default +. + Esta situación tendrá efecto cuando se inserte un registro que entre perfecto + en un gap disponible, y por ende el gap desaparecerá. +\newline +Ver: +\family typewriter +emufs_fsc_borrar_gap() +\layout Section + + +\begin_inset LatexCommand \label{sec:did} + +\end_inset + +Archivo de id's recuperables +\layout Standard + +El archivo de Id's liberado ( +\series bold +.did +\series default +) llevará cuenta de aquellos Id's de registros ( +\family typewriter +id_reg +\family default +) que ya no se encuentran siendo utilizados y fueron liberados por registros + eliminados previamente. + A través del mismo, se podrá realizar la reutilización de Id's ante la + alta de nuevos registros. +\layout Standard + +A nivel físico, este archivo poseerá una secuencia de datos del tipo EMUFS_REG_I +D, y el comportamiento del sistema de recuperación de Id's será el de una + pila. + Es decir, ante el requerimiento de un +\family typewriter +reg_id +\family default + libre por una función del sistema como por ejemplo la alta de un nuevo + registro, el API del archivo ( +\series bold +.did +\series default +), obtendrá el último dato del mismo (el +\emph on +Id +\emph default + que fue liberado mas recientemente), y truncará el archivo eliminando el + +\emph on +Id +\emph default + recuperado de la tabla. + (LIFO, Last in First Out). +\layout Subsection + +Organización Física +\layout Standard + +Este archivo tiene registros de un solo campo, +\family typewriter +EMUFS_REG_ID +\family default + el cual simboliza al id que fue liberado en un proceso de baja de registros. +\layout Subsection + +Funciones principales +\layout Standard + +Las declaraciones e implementación se pueden encontrar en +\series bold +\emph on +did.h +\series default +\emph default + y +\series bold +\emph on +did.c +\series default +\emph default + respectivamente +\layout List +\labelwidthstring 00.00.0000 + + +\series bold +Alta: +\series default +Ante la eliminación de un registro del archivo de datos ( +\series bold +.dat +\series default +) se procederá al agregado del correspondiente +\family typewriter +id_reg +\family default + que fue liberado por dicha operación, al archivo +\series bold +.did +\series default +. +\family typewriter + +\newline + +\family default +Ver: +\family typewriter +emufs_did_agregar() +\layout List +\labelwidthstring 00.00.0000 + +Baja Cuando el sistema desee grabar un nuevo registro en el archivo de datos, + este pedirá un +\family typewriter +id_reg +\family default + disponible para el mismo. + El sistema de administración de Id's libres, obtendrá el último +\emph on +id +\emph default + que se guardó en el archivo (o se eliminó del archivo de datos), y truncará + el archivo eliminandolo. +\family typewriter + +\newline + +\family default +Ver: +\family typewriter +emufs_did_get_last() +\layout Chapter + + +\begin_inset LatexCommand \label{cha:tipo1} + +\end_inset + +Archivo con bloques parametrizados y registros de longitud variable +\layout Standard + +Este tipo de archivo tiene varias complicaciones, al tratarse de un punto + intermedio entre el +\begin_inset LatexCommand \ref{cha:tipo2} + +\end_inset + + y el +\begin_inset LatexCommand \ref{cha:tipo3} + +\end_inset + + (cuenta tanto con bloques como con registros variables), hereda los inconvenien +tes (y ventajas) de ambos, más los propios. + Al implementar este tipo de archivo se puso enfásis en la eficiencia mientras + esta no comprometa la mantenibilidad del código, es por esto que en algunas + circunstancias no se hace un uso óptimo del espacio. +\layout Standard + +La implementación de este tipo de archivo puede ser encontrada en +\family typewriter +emufs/tipo1.c +\family default + mientras que su interfaz pública está disponible en +\family typewriter +emufs/tipo1.h +\family default +. +\layout Section + +Organización física +\layout Standard + +El archivo está compuesto por la +\emph on +cabecera general +\emph default + (ver página +\begin_inset LatexCommand \pageref{sec:cabecera_gral} + +\end_inset + +). + El valor que toma en este tipo de archivo es 0 (o el valor simbólico +\family typewriter +T1 +\family default + del tipo +\family typewriter +EMUFS_Tipo +\family default +). + Luego le sigue una cabecera propia del archivo (un +\family typewriter +EMUFS_BLOCK_SIZE +\family default +, 4 bytes) que almacena el tamaño del bloque que usa el archivo. + De esta menera, al abrir un archivo de este tipo no se necesita tener ninguna + información sobre él. + A esta cabecera le siguen cero o más bloques del tamaño fijo especificado + en la cabecera antes mencionada. +\layout LyX-Code + +archivo +\layout LyX-Code + ++-----------+-----------+------------------------//-+ +\layout LyX-Code + +| tipo | tam bloque| Cero o más bloques ... + +\backslash + +\backslash + | +\layout LyX-Code + ++-----------+-----------+------------------------//-+ +\layout LyX-Code + +/- 4 bytes -/- 4 bytes -/ +\layout Subsection + +Organización física de un bloque +\layout Standard + +Cada bloque no guarda información en sí, sólo se comporta como un contenedor + de registros. + Esto no significa que un bloque no tenga utilidad, el bloque es utilizado + para proveer un acceso semi-aleatorio a los registros. + Para esto se utiliza el archivo de índice (ver página +\begin_inset LatexCommand \ref{sec:idx} + +\end_inset + +), que almacena pares [identificador de registro, número de bloque]. + Para que sea suficiente este único índice para hallar un registro (siendo + que puede haber más de un registro por bloque), es necesario +\emph on +alinear los registros a izquierda +\emph default +. + Esto significa que hay que asegurar que siempre los registros en un bloque + se presenten de forma consecutiva, jamás permitiendo que haya un espacio + libre entre registros (en un mismo bloque). +\layout Standard + +Podemos ver un ejemplo de esto en forma gráfica: +\layout LyX-Code + +bloque N-1 | bloque N | bloque N+1 +\layout LyX-Code + +/----------+------------+------------+---------------+-----------/ +\layout LyX-Code + + +\backslash + | registro 1 | registro 2 | espacio libre | +\backslash + +\layout LyX-Code + +/----------+------------+------------+---------------+-----------/ +\layout LyX-Code + + /------------- tamaño del bloque ---------/ +\layout Standard + +De esta forma, una vez obtenido el número de bloque, se pueda recorrer secuencia +lmente hasta encontrar el registro deseado. + A fin de llevar el conteo de espacio libre se utiliza el archivo de control + de espacio libre (ver página +\begin_inset LatexCommand \ref{sec:fsc} + +\end_inset + +), de forma tal que no sea necesario recorrer secuencialmente en busca de + espacio libre al hacer una inserción. +\layout Standard + +Puede darse un caso excepcional en el que un registro sea más grande que + un bloque, en este caso el registro se almacenará en N bloques consecutivos + (siendo N la cantidad de bloques que necesita el registro), ocupando completos + los todos los bloques a excepción del último, en el que posteriormente + se pueden agregar más registros. +\layout Subsubsection + + +\begin_inset LatexCommand \label{sub:tipo1_reg} + +\end_inset + +Organización física de un registro. +\layout Standard + +El registro es el que representa al dato realmente que se quiere almacenar. + Para representar ese dato se necesita una determinada información de control, + tanto para poder identificar el registro en un bloque (en búsquedas secuenciale +s dentro del bloque) como para saber su longitud (dado que este tipo de + archivo utiliza registros de tamaño variable). +\layout Standard + +Siguiendo la metodología general de E +\begin_inset Formula $\mu$ +\end_inset + +FS, se optó por incluir esta información de control como una cabecera al + comienzo del registro, siguiendo a esta los datos en sí. + La cabecera está compuesta por un identificador ( +\family typewriter +id +\family default +) de registro (EMUFS_REG_ID, 4 bytes) seguido por el tamaño ( +\family typewriter +tamaño +\family default +) del registros (EMUFS_REG_SIZE, 4 bytes). + Podemos ver gráficamente como se se compone un registro: +\layout LyX-Code + +registro id +\layout LyX-Code + ++-----------+-----------+------------------+ +\layout LyX-Code + +| id | tamaño | datos ... + | +\layout LyX-Code + ++-----------+-----------+------------------+ +\layout LyX-Code + +/- 4 bytes -/- 4 bytes -/- [tamaño] bytes -/ +\layout Subsubsection + + +\begin_inset LatexCommand \label{sub:tipo1_reg_multi} + +\end_inset + +Organización física de un registro más grande que un bloque (registro +\emph on +multibloque +\emph default +). +\layout Standard + +Puede darse el caso excepcional en que un registro sea de mayor longitud + que un bloque. + Al ser una situación excepcional, no siempre se resuelve de la forma más + eficiente ni se mínimiza el espacio ocupado por datos de control (como + se dijo anteriormente, se prefirió conservar la simpleza del código, adoptando + algoritmos generales aunque no sea de la forma más eficiente o maximizando + el uso del espacio para no perjudicar la mantenibilidad). +\layout Standard + +Para menejar un registro +\emph on +multibloque +\emph default +se optó por limitarlo a la siguiente estructura (suponiendo que el registro + ocupa N bloques, con N > 1 y que un +\emph on +fragmento +\emph default + es una porción del registro que entra en un bloque): +\layout Itemize + +Los primeros N-1 +\emph on +fragmentos +\emph default + se almacenan en bloques completos consecutivos. +\layout Itemize + +El último fragmento se almacena al comienzo del bloque inmediatamente posterior + al penúltimo. +\layout Itemize + +Cada framento posee las cabeceras mencionadas en la sección +\begin_inset LatexCommand \ref{sub:tipo1_reg} + +\end_inset + +, cuyo contenido es el siguiente: +\begin_deeper +\layout Itemize + +En +\family typewriter +id +\family default + se almacena el identificador único obtenido al hacer el alta. +\layout Itemize + +En +\family typewriter +tamaño +\family default + se almacena el tamaño del +\emph on +fragmento +\emph default + actual más los tamaños de los +\emph on +fragmentos +\emph default + posteriores, quedando en el primer +\emph on +fragmento +\emph default + el tamaño completo del registro y en el último sólo el tamaño del +\emph on +fragmento +\emph default + final. +\end_deeper +\layout Standard + +Como puede observarse, la información de control en los +\emph on +fragmentos +\emph default + intermedios puede ser redundante, pero se conserva para poder realizar + algoritmos genéricos (que se basan en que al principio de un bloque, si + no está vacío, hay una cabecera de un registro) y para facilitar chequeos + de integridad del archivo. +\layout Standard + +A continuación se presenta un ejemplo gráfico de un registro multibloque + de 10 bytes (de contenido +\begin_inset Quotes eld +\end_inset + +1234567890 +\begin_inset Quotes erd +\end_inset + +) almacenado en un archivo con bloques de 4 bytes: +\layout LyX-Code + +| bloque 0 | bloque 1 | bloque 2 +\layout LyX-Code + ++-------------------+-------------------+-------------------+-//-+ +\layout LyX-Code + +| registro 0 - 1/3 | registro 0 - 2/3 | registro 0 - 3/3..| +\backslash + +\backslash + | +\layout LyX-Code + +|+----+-----+------+|+----+-----+------+|+----+-----+----+..| // | +\layout LyX-Code + +|| id | tam | datos||| id | tam | datos||| id | tam |dato|..| +\backslash + +\backslash + | +\layout LyX-Code + +||----+-----+------+||----+-----+------+||----+-----+----+..| // | +\layout LyX-Code + +|| 0 | 10 | 1234 ||| 0 | 6 | 5678 ||| 0 | 2 | 90 |..| +\backslash + +\backslash + | +\layout LyX-Code + +|+----+-----+------+|+----+-----+------+|+----+-----+----+..| // | +\layout LyX-Code + ++-------------------+-------------------+-------------------+- +\backslash + +\backslash +-+ +\layout Section + +Funciones principales +\layout Standard + +Las funciones principales son las necesarias para completar la estructura + EMUFS (ver página +\begin_inset LatexCommand \pageref{sub:EMUFS} + +\end_inset + +). +\layout Subsection + +Lectura de registros +\layout Standard + +Para leer un registro se hace uso del archivo de índice (ver página +\begin_inset LatexCommand \pageref{sec:idx} + +\end_inset + +), obteniéndose el número de bloque en donde está almacenado el registro + a buscar. + Una vez obtenido, se carga en memoria el bloque entero y se busca secuencialmen +te en él (leyendo la cabecera de cada registro y salteando los datos) hasta + encontrar el registro pedido. + Una vez encontrado se lo copia y devuelve. +\layout Standard + +Si se tratara de un registro +\emph on +multibloque +\emph default + (ver sección +\begin_inset LatexCommand \ref{sub:tipo1_reg_multi} + +\end_inset + +), se procede forma similar, sólo que se cargan en memoria uno a uno los + bloques que componen el registro y se van copiando (y uniendo) los +\emph on +fragmentos +\emph default + hasta completarlo. +\layout Standard + +Ver: +\family typewriter +emufs_tipo1_leer_registro() +\layout Subsection + +Altas de registros +\layout Standard + +Para realizar el alta de un registro, lo primero que se obtiene es un identifica +dor, buscando primero en el archivo de identificadores recuperables (pág. + +\begin_inset LatexCommand \ref{sec:did} + +\end_inset + +) y de no haber ninguno, buscando el mayor identificador presente en el + archivo de índice (pág. + +\begin_inset LatexCommand \ref{sec:idx} + +\end_inset + +) y sumándole uno. + El paso siguiente es buscar un bloque con espacio libre suficiente como + para almacenar el registro (y su cabecera) en el archivo de control de + espacio libre (pág. + +\begin_inset LatexCommand \ref{sec:fsc} + +\end_inset + +) y cargarlo completo en memoria. + De no encontrarse, se crea un bloque nuevo al final de archivo. + En el bloque cargado en memoria, se agrega el registro nuevo (con su cabecera) + al comienzo del espacio libre (calculado a partir del tamaño del bloque + y el espacio libre en bloque) y se lo graba en disco. + Finalmente se agrega (o actualiza) el identificador al archivo índice y + el espacio libre en el bloque. +\layout Standard + +Si el registro ocupara más de un bloque (ver sección +\begin_inset LatexCommand \ref{sub:tipo1_reg_multi} + +\end_inset + +), se buscan N bloques consecutivos (todos los que necesite el registro) + absolutamente libres +\begin_inset Foot +collapsed true + +\layout Standard + +Incluso el último bloque debe estar absolutamente libre para cumplir con + las condiciones presentadas en la sección +\begin_inset LatexCommand \ref{sub:tipo1_reg_multi} + +\end_inset + +. +\end_inset + + y graba bloque a bloque cada +\emph on +fragmento +\emph default + del registro (con sus cabeceras intermedias), al último +\emph on +fragmento +\emph default + se lo trata de forma análoga a un registro +\emph on +simple +\emph default +. + Por cada bloque utilizado se actualiza el archivo de control de espacio + libre. +\layout Standard + +Ver: +\family typewriter +emufs_tipo1_agregar_registro() +\layout Subsection + +Bajas de registros +\layout Standard + +Ver: +\family typewriter +emufs_tipo1_borrar_registro() +\layout Subsection + +Modificación de registros +\layout Standard + +Ver: +\family typewriter +emufs_tipo1_modificar_registro() +\layout Subsection + +Obtención de estadísticas +\layout Standard + +Ver: +\family typewriter +emufs_tipo1_leer_estadisticas() +\layout Subsection + +Compactación del archivo de datos +\layout Standard + +Ver: +\family typewriter + emufs_tipo1_compactar() +\layout Section + +Detalles de implementación (funciones internas, ver si lo ponemos o no) +\layout Chapter + + +\begin_inset LatexCommand \label{cha:tipo2} + +\end_inset + +Archivo sin bloques y registros de longitud variable +\layout Standard + +Este tipo de archivo nos traerá a la mesa la particularidad de grabar registros + de longitud variable sin realizar su agrupación en bloques, y como veremos + en la siguiente sección, tambien permitirá la administración de gaps que + queden en el archivo luego de operaciones de baja de registros. +\layout Section + +Organización física +\layout Standard + +Este tipo de archivo realizará el almacenamiento de registros de longitud + variable en disco, su borrado y modificación sin la utilización de bloques + de ningún tipo. + Su implementación se encuentra en los archivos fuente ( +\series bold +tipo2.c +\series default + y +\series bold +tipo2.h +\series default +). +\layout Standard + +Los archivos del tipo 2, presentarán al comienzo del mismo un header compuesto + simplemente por un dato del tipo EMUFS_Tipo (int) el cual indicará el tipo + de archivo en cuestión. +\layout Standard + +Para poder entender mejor la organización fisica de este tipo de archivo, + tomemos el caso hipotético en el que se encuentran grabados +\series bold +dos registros +\series default + (comenzando desde registro 0) de +\series bold +30 bytes +\series default +, y +\series bold +25 bytes +\series default +, respectivamente. + Supongamos también que entre el registro 0 y 1 se encontraba un +\series bold +registro de 10 bytes +\series default + que fue +\series bold +borrado +\series default +, generando un +\series bold +gap +\series default + +\series bold +o freespace +\series default +. + Si miramos al archivo de datos (.dat) en el disco nos encontraremos con + lo siguiente: +\begin_inset Float figure +placement H +wide false +collapsed true + +\layout Caption + +Organización física de los registros en disco +\layout Standard + + +\begin_inset Graphics + filename graphics/Example1.png + width 100text% + +\end_inset + + +\end_inset + + +\layout Standard + +Como se puede observar, a nivel físico cada registro grabado esta compuesto + por un Header cuyo tamaño total es de 8 bytes ( +\series bold +EMUFS_REG_ID +\series default + + +\series bold +EMUFS_REG_SIZE +\series default +), y posteriormente el registro (bloque de datos) en sí. + Luego se encuentra el espacio libre de 18 bytes dejado por el registro + de 10 bytes eliminado (10 bytes de datos + header de 8 bytes) y finalmente + el segundo registro mencionado.dsds +\layout Subsection + +Comportamiento Particular de los Archivos Auxiliares +\layout Standard + +Como fue explicado al inicio de la documentación, la implementación de cualquier +a de las tres organizaciones físicas de archivos presenta la necesidad de + poseer tres archivos auxiliares que actuarán como índice de direcciones + de registro (. +\series bold +idx +\series default +), administrador de espacio libre ( +\series bold +.fsc +\series default +) y administrador de Id's liberados ( +\series bold +.did +\series default +) respectivamente. +\layout Standard + +No obstante, cada tipo de organización presentara sus particularidades respecto + de estos tres archivos, las cuales describiremos a continuación en caso + de haberla. +\layout Subsubsection + +Archivo índice o de posiciones relativas (.idx) +\layout Standard + +El archivo indice ( +\series bold +.idx +\series default +), permite la localizacin de los registros en el .DAT de forma directa, mediante + la obtención de su offset o posición relativa respecto del inicio del +\series bold +.dat +\series default + en donde se encuentra un registro dado, indicado por su ID. +\layout Standard + +Así pues, si tomamos el ejemplo descripto al inicio de este capítudlo, tendremos + las siguientes entradas en el archivo indice +\series bold +.idx +\series default +: +\begin_inset Float table +placement H +wide false +collapsed true + +\layout Caption + +Organización física del archivo de índice o posiciones relativas. +\layout Standard + + +\begin_inset Tabular + + + + + + + +\begin_inset Text + +\layout Standard + + +\emph on +ID_REGISTRO +\end_inset + + +\begin_inset Text + +\layout Standard + + +\emph on +OFFSET +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + + + +\begin_inset Text + +\layout Standard + + +\series bold +0 +\end_inset + + +\begin_inset Text + +\layout Standard + + +\series bold +4 +\end_inset + + +\begin_inset Text + +\layout Standard + +El primer registro (reg0) comienza en el byte 4 +\end_inset + + + + +\begin_inset Text + +\layout Standard + +1 +\end_inset + + +\begin_inset Text + +\layout Standard + + +\series bold +60 +\end_inset + + +\begin_inset Text + +\layout Standard + +El segundo registro (reg1) comienza en el byte 60 +\end_inset + + + + +\end_inset + + +\end_inset + + +\layout Standard + + +\series bold +\emph on +Observación: +\series default +\emph default + LOCATION indica donde comienza el header del registro buscado, y por consiguien +te luego del header tendremos el registro en sí (los datos). +\layout Subsubsection + +Achivo de Gaps / Espacios Libres (.fsc) +\layout Standard + +El archivo de espacios libres o gaps (.fsc), tiene como función la administracion + del espacio libre o gaps (agujeros), generados por previas eliminaciones + de registros en el archivo de datos. + El mismo, nos indicará donde hay lugar para insertar un nuevo registro + (se podrán insertar en algún gap acorde, o bien al final del archivo). + Este archivo será utilizado tambien para el proceso de compactación de + un archivo, explicado luego. +\layout Standard + +Así pues, si tomamos el ejemplo descripto al inicio del documento, tendremos + las siguientes entradas en el archivo índice +\series bold +.fsc +\series default +: +\begin_inset Float table +placement H +wide false +collapsed true + +\layout Caption + +Organización física del archivo de +\emph on +gaps +\emph default +o control de espacio libre. +\layout Standard + + +\begin_inset Tabular + + + + + + + +\begin_inset Text + +\layout Standard + + +\emph on +OFFSET +\end_inset + + +\begin_inset Text + +\layout Standard + + +\emph on +FREESPACE +\end_inset + + +\begin_inset Text + +\layout Standard + +\end_inset + + + + +\begin_inset Text + +\layout Standard + + +\series bold +42 +\end_inset + + +\begin_inset Text + +\layout Standard + + +\series bold +18 +\end_inset + + +\begin_inset Text + +\layout Standard + +18 bytes libres a partir del byte 42 del .dat +\end_inset + + + + +\end_inset + + +\end_inset + + +\layout Standard + + +\series bold +\emph on +Nota: +\series default +\emph default + Por requerimiento del algoritmo de compactación, los gaps se graban en + forma ordenada en el (.fsc). + (El orden se corresponde con lo que hay en el .dat) +\layout Subsubsection* + +GAP Merging +\layout Standard + +Si bien la utilización concreta de los GAPS será explicada posteriormente + en la ALTA y BAJA de registros, debemos remarcar la funcionalidad de MERGING + que posee nuestro sistema FSC. +\layout Standard + +Ante la eliminación de un registro del archivo de datos, se generara por + consiguiente un gap o espacio libre en alguna posición del archivo. + Ese gap deberá ser registrado en el archivo de gaps (.fsc). + Ahora bien, nuestro sistema de gaps, contemplará como es debido, la posibilidad + de que se haya eliminado un registro que posee un GAP por delante, un GAP + por detrás, o bien un GAP por delante y por detrás del mismo. +\layout Standard + +Nuestro sistema actuará en consecuencia, realizando un merge de los espacios + libres, y unificándolos en una UNICA entrada en el archivo .fsc, que contendrá + como dato de freespace, la suma correspondiente de los espacios libres + antes mencionados. +\layout Subsubsection + +Archivo de ID's liberados (.did) +\layout Standard + +El archivo de ID's liberados no presenta ningún aspecto particular en este + tipo de organización. + Remitirse al capítulo correspondiente a los archivos auxiliares para consultar + su estructura y funcionamiento. +\layout Section + +Funciones Principales +\layout Standard + +Dentro de +\series bold +\emph on +tipo2.h +\series default +\emph default + y +\series bold +\emph on +tipo2.c +\series default +\emph default + se encuentran las cabeceras y la implementación de las funciones principales + respectivamente, las cuales dan funcionalidad a esta organización. + +\layout Standard + +A continuación se comentará el funcionamiento algunas de las mas importantes. \layout Subsection -EMUFS +Lectura de registros +\layout Standard + +Como se vió al comienzo, los registros en este tipo de archivo no se encuentran + agrupados en bloques de ninguna índole y estan dispersos a lo largo del + archivo, con la particularidad de que pueden existir gaps o espacio libre, + entre dos registros dados. +\layout Standard + +Por ende la lectura de registros en este tipo de organización es muy simple + y dada la inexistencia de bloques, el procedimiento será el siguiente: +\layout Enumerate + +Se determina el offset en bytes, donde comienza el registro deseado, a través + de su ID, buscando la misma en el archivo índice ( +\series bold +.idx +\series default +) +\layout Enumerate + +Ya determinada la posición física del registro dentro del archivo de datos + ( +\series bold +.dat +\series default +), nos posicionamos en la misma, y leemos el header del registro ( +\series bold +IDReg +\series default + + +\series bold +RegSize +\series default +). + Contando así con el tamaño del registro, procedemos a leer el mismo (los + datos), dando por finalizada la lectura. \layout Standard -callbacks, etc +Ver: +\family typewriter +emufs_tipo2_leer_registro() \layout Subsection -EMUFS_Tipo +Altas de registros +\layout Standard + +En el proceso de alta de registros entrarán en juego dos archivos descriptos + en la +\emph on +sección de archivos auxiliares +\emph default +, siendo estos el archivo índice ( +\series bold +.idx +\series default +), y el archivo de gaps / espacios libres ( +\series bold +.fsc +\series default +). +\layout Standard + +Así pues, a la hora de realizar una inserción de un registro en el archivo + de datos, el procedimiento será el siguiente: +\layout Enumerate + +Calculamos el espacio que necesitaremos para el registro: sizeof( +\series bold +EMUFS_REG_ID +\series default +) + sizeof( +\series bold +EMUFS_REG_SIZE +\series default +) + sizeof(registro). +\layout Enumerate + +Determinamos donde debemos insertar el registro, ya sea un gap donde entre, + o bien al final del archivo. +\layout Enumerate + +Insertamos el registro e información de control ( +\series bold +header +\series default ++ +\series bold +data +\series default +), en la posición indicada en el paso 2. +\layout Enumerate + +En caso de haber utilizado un GAP, actualizamos el espacio libre restante + en el mismo y en caso de que se haya utilizado al totalidad del GAP, se + lo elimina del archivo ( +\series bold +.fsc +\series default +). +\layout Enumerate + +Actualizamos la entrada correspondiente al registro ingresado (determinada + por su RegID), en el archivo índice ( +\series bold +.idx +\series default +), indicando su offset donde podrá ser accedido luego. +\layout Standard + +Ver: +\family typewriter +emufs_tipo2_agregar_registro() \layout Subsection -EMUFS_Estadisticas +Bajas de registros +\layout Standard + +En el proceso de baja de registros entrarán en juego los tres archivos descripto +s en la +\emph on +sección de archivos auxiliares +\emph default +, siendo estos el archivo índice ( +\series bold +.idx +\series default +), el archivo de gaps / espacios libres ( +\series bold +.fsc +\series default +) y el archivo de ID's liberados ( +\series bold +.did +\series default +). +\layout Standard + +Dado que en la implementación de este tipo de organización física contamos + con los gaps o espacios libres entre registros, no se eliminará fisicamente + el registro del archivo de datos ( +\series bold +.dat +\series default +), pues entonces carecería de sentido el archivo anteriormente mencionado + ( +\series bold +.fsc +\series default +). + En cambio, se agrega el gap dejado por la eliminación a dicho archivo, + y se marca fisicamente en el archivo de datos la eliminación mediante un + fill de los bytes correspondientes con un caracter nulo. + (hexa 00 y con el propósito de probar fehacientemente que el sistema funciona). +\layout Standard + +El proceso de baja o eliminación de un registro constará luego de los siguientes + pasos: +\layout Enumerate + +Se obtiene el offset o posición relativa en donde se encuentra grabado el + registro dentro del archivo de datos. +\layout Enumerate + +Se obtiene el tamaño del registro y se realiza un dummyfill del sector del + archivo correspondiente al registro que se está dando de baja. + (Se rellena la zona correspondiente a su header+data). +\layout Enumerate + +Se agrega el GAP generado al archivo de gaps o espacios libres, y en caso + de haberse generado un GAP lindante con otro GAP, se realizará un merge + de los mismos y se los registrará bajo una única entrada en el archivo + de espacios libres (.fsc). +\layout Enumerate + +Se agrega el ID que fue liberado, al archivo de ID's liberados ( +\series bold +.did +\series default +), al final del mismo ( +\emph on +pila +\emph default +). +\layout Enumerate + +Se marca en el archivo índice ( +\series bold +.idx +\series default +) la eliminación, mediante el valor ¨-1¨ en el registro correspondiente + al registro recién eliminado (se le cambia el valor al n-esimo registro, + donde N = IDReg del reg eliminado). +\layout Standard + +Ver: +\family typewriter +emufs_tipo2_borrar_registro() \layout Subsection -EMUFS_BLOCK_ID +Modificación de registros \layout Standard -etc -\layout Chapter +Dada la naturaleza del archivo de ID's liberados, y el manejo de espacio + libre del que consta esta organización de archivo, el proceso de modificación + de un registro se limita a los siguientes pasos: +\layout Enumerate -Archivos Auxiliares +Se realiza la lectura del registro, mediante el respectivo procedimiento + ya desarollado anteriormente. +\layout Enumerate + +Una vez que se cuenta con los nuevos datos modificados, se procede a dar + de baja el registro que ha sido modificado, e inmediatamente después se + realiza una inserción con los nuevos datos. \layout Standard -Por que los 3 tipos usan los mismo. - Ventajas y desventajas. -\layout Section -Archivo de índice (.idx) +\series bold +\emph on +NOTA: +\series default +\emph default + Como fue indicado, dada la naturaleza de PILA del subsistema de administración + de ID liberados, es asegurado que la nueva inserción del registro modificado + se realizará con el mismo RegID. \layout Standard -introduccion +Ver: +\family typewriter +emufs_tipo2_modificar_registro() \layout Subsection -Estructura física +Obtención de estadísticas +\layout Standard + +Se puede tener acceso a las estadísticas generales del archivo, por ejemplo, + cantidad de bloques, cantidad de registros, espacio libre total, espacio + libre promedio, espacio libre máximo y mínimo, etc. +\layout Standard + +Esta información es el resultado de ciertos cálculos realizados tanto en + el archivo de datos como en los archivos índice. +\layout Standard + +Completa una estructura del tipo EMUFS_Estadisticas con las estadísticas + del archivo de datos, espacio libre total, cantidad de registros, cantidad + de bloques, tamaño del archivo en bytes, relaciones entre tamaños y espacios + libres, etc. +\layout Standard + +Ver: +\family typewriter +emufs_tipo2_leer_estadisticas() \layout Subsection -Comportamiento (funciones generales) -\layout Section +Compactación del archivo de datos +\layout Standard -Archivo de control de espacio libre (.fsc) +Asi como los otros dos tipos de datos, el que nos compete también cuenta + con la posibilidad de realizar la compactación de datos cuando el usuario + lo desee, justificando todos los registros a izquierda, eliminando así + los gaps existentes y decrementando el tamaño del archivo en disco (truncandolo +). \layout Standard -idem anterior -\layout Section +Para poder comprender como hemos implementado el proceso de recompactación + en nuestro tipo de archivo 2, nos ayudaremos de esquemas a través de los + cuales iremos describiendo el proceso. + Notemos antes, que el proceso de compactación esta directamente ligado + con el archivo de gaps o espacios libres ( +\series bold +.fsc +\series default +). +\layout Standard -Archivo de índices recuperables (.did) +Comenzemos con el siguiente cuadro situacional: +\begin_inset Float figure +placement H +wide false +collapsed true + +\layout Caption + +Archivo con gaps entre registros previo a compactación \layout Standard -idem anterior -\layout Chapter -Archivo con bloques parametrizados y registros de longitud variable +\begin_inset Graphics + filename graphics/Compact1.png + width 100text% + keepAspectRatio + +\end_inset + + +\end_inset + + \layout Standard -introduccion -\layout Section +Partiendo de esta base, el algoritmo de compactación tomará en su inicio + al primer gap existente dentro del archivo de datos, en este caso llamado + +\series bold +Gap0 +\series default +. + Luego, establecerá que el +\series bold +Source +\series default + a partir de donde se quieren mover datos, sera: +\layout LyX-Code + +StartGap0 + SizeGap0 = EndGap0 = Source +\layout Standard -Organización física -\layout Section +Lo cual no es nada más y nada menos que lo obvio, la fuente a partir de + donde se mueven los datos, sera el fin del primer gap, donde comienzan + datos. + Como destino ( +\series bold +Destination +\series default +) del movimiento, se establece inicialmente, el inicio del gap, o sea +\series bold +StartGap0 = Destination +\series default +. +\layout Standard -Comportamiento (funciones de la interfáz) -\layout Section +Luego, el algoritmo entrara en un bucle while (mientras haya bucles por + levantar), el cual trabajara hasta el final de la compactación de la siguiente + manera: +\layout Standard -Detalles de implementación (funciones internas, ver si lo ponemos o no) -\layout Chapter -Archivo sin bloques y registros de longitud variable +\series bold +Mientras haya Gaps +\series default + { +\layout Enumerate + +Se levanta el proximo gap al levantado en una instancia previa. + En este ejemplo, durante el primer loop del while, se levantará +\series bold +Gap1 +\layout Enumerate + +Luego, se calcula cuantos bytes hay que mover hacia el Destination de la + siguiente manera: +\layout Enumerate + + +\series bold +Mustmove_bytes +\series default + = +\series bold +StartGap1 +\series default + - +\series bold +Source +\series default + = +\series bold +StartGap1 +\series default + - +\series bold +EndGap0 ( +\series default +Lo cual nuevamente es lógico pues querremos mover lo que se encuentra entre + el final del primer gap levantado y el inicio del siguiente). +\layout Enumerate + +Se realiza el movimiento de los datos, utilizando las direcciones +\series bold +Source +\series default + y +\series bold +Destination +\series default +, así como la variable +\series bold +Mustmove_bytes +\series default + que nos indica cuantos bytes transferir. +\series bold + +\newline +IMPORTANTE: +\emph on +La transferencia se hace de a chunks de 25 bytes + un resto segun el valor + de Mustmove_bytes. +\layout Enumerate + +Se establece como gap de referencia, al ultimo gap leido (En este caso se + realiza: +\series bold +StartGap0 +\series default + = +\series bold +StartGap1 +\series default +, +\series bold +Gap0Size = Gap1Size +\series default +) y termina el código de repetición del bucle, dando lugar a la carga del + siguiente gap en el inicio del mismo. \layout Standard -introduccion -\layout Section -Organización física -\layout Section +\series bold +} +\layout Standard + +Luego del primer bucle, el archivo se vera de la siguiente forma: +\begin_inset Float figure +placement H +wide false +collapsed true + +\layout Caption + +Archivo con gaps en disco luego del primer bucle de compactación +\layout Standard + + +\begin_inset Graphics + filename graphics/Compact2.png + width 100text% + +\end_inset + + +\end_inset + + +\layout Standard + +Notemos que al final de la porción de datos de los bytes movidos (donde + quedo apuntando +\series bold +Destination +\series default +), hay basura que será pisada por el próximo movimiento. +\layout Standard + +En el próximo loop, el bucle levantará un nuevo gap, y utilizando el gap + anterior (En esta caso el Gap anterior será +\series bold +Gap1 +\series default +) como referencia, realizará los mismos cálculos, desde donde transferir + y cuantos bytes mover. + (El destino es solo establecido inicialmente por código, y para el resto + del algoritmo es el lugar donde quedo el puntero destination luego de la + última escritura). +\layout Standard + +Una vez que se salga del bucle while, se realizará un último movimiento + preprogramado, donde la fuente ( +\series bold +Source +\series default +) será el final del ultimo gap, y la cantidad de bytes a mover será lo que + se encuentre luego del mismo hasta el fin de archivo. +\layout LyX-Code + +Source = StartLastGap + SizeLastGap = EndLastGap +\layout LyX-Code + +Mustmove_bytes = Datsize - Source +\layout Standard + +Damos por terminada así, la explicación del algoritmo de compresión el cual + para el caso del tipo 2, es realmente bastante sencillo. +\layout Standard -Comportamiento (funciones de la interfáz) +Ver: +\family typewriter + emufs_tipo2_compactar() \layout Section -Detalles de implementación (funciones internas, ver si lo ponemos o no) +Consideraciones y Políticas de Diseño +\layout Standard + +Se han tomado ciertas consideraciones para algunos casos particulares que + se pueden presentar durante el uso/ejecución de la aplicación, así como + tambien politicas respecto del diseño e implementación del sistema: +\layout Itemize + +En la organización física tipo 2 para los registros que se graban en disco + hemos decidido utilizar como encabezado de cada uno de ellos, los datos + [ID_REG][REG_SIZE], los cuales fueron detallados previamente. + Si bien se podría haber descartado el grabado del ID del registro en el + archivo de datos y puede parecer redundante, dado que poseemos el archivo + índice con el offset directo, el mismo se lo graba por distintos motivos: +\newline + +\newline +A) En caso de la corrupción del archivo índice (.idx), podremos gracias a + que poseemos en el archivo de datos, el ID de cada registro, recrear dicho + índice, ayudándonos del archivo de espacios libres ( +\series bold +.fsc +\series default +), para poder saltear los espacios libres y e ir recorriendo secuencialmente + los registros, reconstruyendo así el índice en cuestión. + (esta función de reconstrucción no pudo ser implementada para esta entrega, + pero es una posibilidad real). +\newline + +\newline +B) Luego de un proceso de recompactación, los espacios libres que pudieron + haber existido en el archivo de datos ( +\series bold +.dat +\series default +), son eliminados y los registros han cambiado de posición. + Por ello, recorriendo secuencialmente por única vez el archivo de datos, + se procede a la actualización / reconstrucción del índice de direcciones + u offsets (. +\series bold +idx +\series default +) +\layout Itemize + +Si se desea insertar un registro y no se puede hayar un gap o espacio libre + donde quepa, se los inserta al final del archivo. +\layout Itemize + +Ante una operación de baja de un registro, el mismo no es físicamente borrado + del archivo de datos ( +\series bold +.dat +\series default +), simplemente los bytes que ocupa son llenados con hexa (00). + Paralelamente, se procede a actualiza el archivo índice, insertando como + valor de OFFSET para el registro eliminado, el valor ¨-1¨, indicando así + la inexistencia del registro para el futuro, y por otro lado se genera + la entrada de espacio libre en el archivo de gaps ( +\series bold +.fsc +\series default +). +\layout Itemize + +La reutilización de ID's liberados por previas operaciones de baja de registros, + se ve implementada por el archivo de ID liberados (.did), y su comportamiento + es el de una pila por lo que el último ID liberado, sera el próximo a ser + reutilizado (LIFO). +\layout Itemize + +Como fue explicado en la implementación del archivo índice, existe una correspon +dencia 1 a 1 entre los registros allí presentes (en el .idx) y los ID's de + los registros, por lo cual el registro N-ésimo del archivo índice, será + el correspondiente al registro de datos cuyo ID es igual a N. +\layout Itemize + +El proceso de compactación de archivos, realiza los movimientos de información + requeridos para dicho propósito de a chunks de 25 bytes por vez. + Este valor es fijo, pero se lo podría hacer parametrizable mediante la + GUI en próximas entregas. \layout Chapter + +\begin_inset LatexCommand \label{cha:tipo3} + +\end_inset + Archivo con bloques parametrizados y registros de longitud constante \layout Standard @@ -156,74 +2997,26 @@ As del archivo. \layout Subsection -Archivos Auxiliares +Comportamiento Particular de los Archivos Auxiliares \layout Subsubsection Archivo de Bloques y Registros (.idx) -\layout Standard - -Con la ayuda de un archivo de bloques y registros (de extensión .idx), podremos - ubicar cualquier registro existente dentro del archivo. - -\layout Standard - -El archivo de índice contiene una estructura que contiene el id de un registro - y el número de bloque al que pertenece. - Este archivo esta ordenado por id, de modo que incrementa su tamaño cada - vez que se grabe en el archivo de datos un nuevo registro, excepto que - un registro haya sido borrado con anterioridad lo cual produce que al guardar - un nuevo registro se actualice y no crezca. -\layout Standard - -Si un registro es borrado del archivo de datos, debe actualizarse el índice, - esto se logra colocando un flag que indique que el id no pertenece a ningún - bloque, hemos adoptado poner -1 en el campo location de la estructura EMUFS_IDX. -\layout Standard +\layout Comment -Es necesario que este archivo esté ordenado por id de registro, ya que esto - permitirá el acceso directo para la búsqueda de un registro en el archivo - de datos. +buscar algun caso extraordinario. \layout Subsubsection Archivo de Bloques y Espacio Libre (.fsc) -\layout Standard - -El archivo de de espacios libres permite decidir a la hora de guardar un - registro, donde será guardado. - -\layout Standard - -La estructura de este archivo está formada por un número que indica el bloque - y otro que indica el espacio libre en él. -\layout Standard - -De esta manera al querer guardar un registro este archivo informará donde - cabe el mismo, previa invocación al la función EMUFS_BLOCK_ID emufs_fsc_buscar_ -lugar(EMUFS *, EMUFS_FREE, EMUFS_FREE*) perteneciente a fsc.h, la cual devuelve - el número de bloque donde entra el registro o -1 si no hay un bloque con - lugar suficiente, y toma como parámetros una estructura EMUFS, y dos EMUFS_FREE - donde el segndo parámetro es el tamaño buscado, y el tercero devuelve el - tamaño disponible. -\layout Standard - -De la misma manera, al borrar un registro este archivo debe ser actualizado - colocando el nuevo espacio libre en el bloque. \layout Subsubsection Archivo de Id`s Borrados (.did) \layout Standard -Este archivo funciona como una pila de id`s borrados, es decir, cuando se - borra un registro el id se almacena en este archivo y será recuperado cuando - se desee grabar un registro nuevo, de esta manera se aprovechan todos los - id`s sin necesidad de crear uno nuevo cada vez que se borra y graba un - registro. +El comportamiento de este archivo, es común para todas las organizaciones + y se ha explicado en 3.3.2. \layout Section Funciones Principales -\layout Subsection - -EMUFS Tipo 3 \layout Standard Dento de @@ -238,103 +3031,95 @@ tipo3.c respectivamente, las cuales dan funcionalidad a esta organización. \layout Standard -A continuación se comentará el funcionamiento algunas de las mas importantes. -\layout Subsubsection +A continuación se comentará la descripción de algunas acciones importantes. +\layout Subsection -void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE* - reg_size, int* err) +Leer Registro \layout Standard -Devuelve un puntero con la memoria reservada que contiene al registro solicitado - por el segundo parámetro ( +La lectura de un registro se realiza con la ayuda del archivo . \emph on -ID +idx \emph default - ), y almacena en + el cual contiene la información de la posición del registro dentro del + archivo de datos. + Una vez leida esta información, se recupera el bloque (en su totalidad) + del archivo y se busca secuencialmente el registro con el \emph on -reg_size +ID \emph default -el tamaño del registro leido, que en este caso no es necesario pues es constante - y es conocicdo de antemano. + especificado. \layout Standard -Para realizar esta acción, busca en el archivo -\emph on -.idx -\emph default -el bloque al cual pertenece el registro. -\layout Subsubsection +Ver: +\family typewriter +emufs_tipo3_leer_registro() +\layout Subsection -void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID num_bloque, int* - err) +Grabar Registro \layout Standard -Devuelve un puntero con la memoria reservada que contiene el bloque solicitado - por el segundo parámetro ( -\emph on -num_bloque -\emph default -). - +Graba un registro en un bloque donde haya espacio suficiente, y si no crea + un nuevo bloque y lo agrega al final del archivo. \layout Standard -Como la numeración de los bloques es -\emph on -virtual, -\emph default -el acceso al archivo para levantar un bloque es directo, es decir, se posiciona - directamente en en número de bloque multiplicado por el tamaño del mismo, - salteando antes el encabezado del archivo. -\layout Subsubsection +Luego de grabar un registro, actualiza los archivos de índice .idx y .fsc + para mantener la coherencia. +\layout Standard + +Ver: +\family typewriter +emufs_tipo3_grabar_registro() +\layout Subsection -EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE - tam, int* err) +Borrar Registro \layout Standard -Graba un registro en un bloque donde haya espacio suficiente, y si no crea - un nuevo bloque y lo agrega al final del archivo. +Borra un registro del archivo de datos, para esto levanta el bloque al que + pertenece el archivo y ajusta los demás registros justificandolos hacia + la izquierda. \layout Standard -El registro a grabar es apuntado por el segundo parámetro ( -\emph on -ptr -\emph default -) y el tamaño viene indicado en el tercero ( -\emph on -tam -\emph default - ). +Cabe destacar que para dar de baja un registro no hace falta borrarlo del + archivo de datos, solo es necesario borrar las entradas en los archivos + de índice, pero cuando se realiza el ajuste el algoritmo toma porciones + del bloque del tamaño de un registro mas su encabezado - comenzando desde + el siguiente al que fue borrado - y copia (sobreescribe) sobre el anterior. + De esta manera, la información correspondiente al registro borrado no estará + presente en el archivo de datos. + Esto es una consecuencia del ajuste al borrar un registro, pudiendo no + ser así, si no se realizara el mismo. \layout Standard -Luego de realizar la grabación, actualiza los archivos índice con los valores - correspondientes. -\layout Subsubsection +Ver: +\family typewriter +emufs_tipo3_borrar_registro() +\layout Subsection -int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID) +Leer Estadísticas \layout Standard -Borra el registro indicado por el segundo parámetro ( -\emph on -ID -\emph default - ) del archivo de datos, y actualiza los archivos de índice para mantener - la coherencia en las próximas modificaciones. +Se puede tener acceso a las estadísticas generales del archivo, por ejemplo, + cantidad de bloques, cantidad de registros, espacio libre total, espacio + libre promedio, espacio libre máximo y mínimo, etc. \layout Standard -Al borrar un registro, justifica los demás registros del bloque hacia la - izquierda. -\layout Subsubsection - -EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu) +Esta información es el resultado de ciertos cálculos realizados tanto en + el archivo de datos como en los archivos índice. \layout Standard Completa una estructura del tipo EMUFS_Estadisticas con las estadísticas del archivo de datos, espacio libre total, cantidad de registros, cantidad de bloques, tamaño del archivo en bytes, relaciones entre tamaños y espacios libres, etc. -\layout Subsubsection +\layout Standard -void emufs_tipo3_compactar(EMUFS *emu) +Ver: +\family typewriter +emufs_tipo3_leer_estadisticas() +\layout Subsection + +Compactar el Archivo \layout Standard Esta función intenta reorganizar el archivo de manera que el espacio libre @@ -358,6 +3143,14 @@ que pudieron haberse formado por la eliminaci por otros. \layout Standard +Al estar utilizando recuperación de +\emph on +id`s +\emph default + borrados, esto me asegura que el registro borrado-guardado conservará el + id al grabarse. +\layout Standard + Al finalizar este proceso se verifica si existen bloques vacios para truncar el archivo. Lo mismo se debe hacer con el archivo de espacios libres . @@ -365,6 +3158,11 @@ Al finalizar este proceso se verifica si existen bloques vacios para truncar fsc \emph default el cual disminuye su tamaño también. +\layout Standard + +Ver: +\family typewriter +void emufs_tipo3_compactar() \layout Section Consideraciones y Políticas de Diseño