Arbol B+

Anuncio
Universidad de Buenos Aires
Facultad de Ingeniería
75.06 ORGANIZACIÓN DE DATOS
TRABAJO PRÁCTICO
VOTO ELECTRÓNICO
ETAPA 1
TURNO:
Lunes y miércoles de 19 a 22 Hs
DOCENTE:
TUTOR:
Servetto, Arturo
Ferrer, Alejandro
INTEGRANTES:
Daye, Gisela
Sossich, Mario
Luna, Rodrigo
Rimoldi, Marcos
Shilkov, Igor
GRUPO Leiva
87602
87868
87579
84798
84117
Contenido
Diagrama de clases ....................................................................................................................................... 3
Dominio ................................................................................................................................................. 3
ArbolB+.................................................................................................................................................. 4
Especificación de Clases ................................................................................................................................ 4
GraphicUserInterface ............................................................................................................................ 5
Logger.................................................................................................................................................... 5
Election Manager .................................................................................................................................. 6
Result Manager ..................................................................................................................................... 6
User Manager........................................................................................................................................ 7
Csv Loader ............................................................................................................................................. 7
Bot ......................................................................................................................................................... 7
Arbol B+................................................................................................................................................. 8
Diagramas de secuencia.............................................................................................................................. 12
Diagrama de ingreso del usuario al sistema ....................................................................................... 12
Diagrama de seleccion de la elección del usuario .............................................................................. 13
Diagrama de voto del usuario ............................................................................................................. 14
Diagramas de modificación, alta y baja por parte del administrador ................................................ 15
Diagrama de modificación del votante ............................................................................................... 16
Diagrama de alta del votante del administrador ................................................................................ 17
Diagrama de baja del votante del administrador ............................................................................... 18
Planificación ................................................................................................................................................ 19
Diagrama de clases
Dominio
ArbolB+
Especificación de Clases
GraphicUserInterface
La GUI se relaciona con las clases Election Manager, BPlusTree, Eleccion, Lista, Candidato,
Cargo, Distrito, Votantes
Crea la interfaz gráfica que interactua tanto con el votante, la cual le permite al usuario ingresar
al sistema, votar y confirmar su voto y salir del sistema mediante el UserManager?, como con el
usuario administrador permitiendole dar de alta, modificar o dar de baja un distrito, votante,
eleccion, cargo, listas y/o candidatos en directa relacion el arbol.
void GraphicUserInterface::menu(): Instancia una nueva elección mediante el
ElectionManager, mostrando en pantalla al usuario la opción de seleccionar ingresar al sistema
como usuario votante o como usuario administrador.
void login(ElectionManager* electionManager) : Obtiene por parte del usuario votante su dni y
su contraseña, de los cuales se comprueba su validez mediante el ElectionManager para luego
permitir o no ingresar al sistema
void selectEleccion(ElectionManager* electionManager): Luego de que el usuario haya
ingresado al sistema, se obtiene mediante el ElectionManager la lista de elecciones que posee
el votante para permitirle votar y se invoca al método confirmarVoto(ElectionManager*
electionManager, Lista* lista) que muestra en pantalla el voto seleccionado anteriormente
obtenido de la lista y ofrece al votante confirmar el voto o cambiar su voto
void admin(): Permite al usuario administrador seleccionar si desea modificar, dar de alta o
baja a una elección, lista, votantes, candidato, cargo o distrito. En tales caso el usuario debe
proporcionar los datos necesarios para dicha actividad, los cuales se ponen en un nuevo
registro y son buscandos en el árbol para luego ser modificados, insertados o borrados
Logger
Registra en un archivo de LOG todas las operaciones del votante: acceso, acceso Fallido, voto,
voto ingresado, cambio de voto.
static void createEntryLog(string entryLog, int tipoLog): En el archivo en sistema TP1.log
permite escribir una nueva entrada con el horario de entrada el string entryLog que recibe
como parámetro y un mensaje de error, advertencia o de log según corresponda.
Election Manager
Election Manager se relaciona con las clases ResultManager, UserManager, Eleccion, Lista,
Candidato, Cargo, Distrito, Votantes
Se encarga de administrar la elección, ingresando al usuario votante en el sistema,
determinando a qué distrito pertenece por lo cual a que elección está habilitado para votar
mediante el UserManager. Administra el voto del usuario permitiéndole votar y confirma su
voto mediante el ResultManager, contabilizando el mismo en caso de que el voto del votante
no haya sido ya contabilizado en la lista de conteo que contiene los votos de los usuarios por
elección.
List *ElectionManager::getListasDisponibles(): Instancia un nuevo árbol con el archivo de
Listas, itera el árbol y obtiene una lista con las Listas disponibles para que el usuario vote
int ElectionManager::confirmVote(Lista *lista): Mediante el ResultManager consulta si el
usuario ya voto, en ese caso modifica el voto existente, en caso contrario guarda el voto del
votante a través del ResultManager
Result Manager
Result Manager se relaciona con las clases Conteo y BPlusTree
Se encagar de contabilizar los votos de los votantes por elección
Conteo *ResultManager::getConteoPorLista(Lista *lista): Instancia un nuevo Arbol con el
archivo Conteo, busca mediante el Id de la lista en el árbol su conteo de los votos y lo devuelve
int ResultManager::saveConteo(Conteo *conteo, bool save): Instancia un nuevo Arbol con el
archivo Conteo e inserta o modifica el conteo de los votos a guardar según el bool save
User Manager
User Manager se relaciona con las clases Votantes y BPlusTree
Se encarga de administrar al usuario votante que ingresa al sistema
Votante *UserManager::searchUser(int userDni): ): Instancia un nuevo Arbol con el archivo
Votantes y busca en el el usuario mediante el userDNI, si no lo encuentra devuelve NULL, en
caso contrario devuelve al Votante
Csv Loader
Csv Loader se relaciona con las clases BPlusTree, Eleccion, Lista, Candidato, Cargo, Distrito,
Votantes
Carga desde los archivos en memoria la información de las elecciones, distritos, listas, cargos,
candidatos hacia el árbol. La integridad de los datos en los archivos csv deben ser garantizados
por el usuario adminstrador.
void CsvLoader::loadCsv(string filePath): Carga según el filePath el archivo en cuestión y luego
invoca a loadDistricts, loadVoters, loadPositions, loadLists, loadCandidates o loadElections
según corresponda cargando asi districtos, votantes, cargos, listas, candidatos o elecciones
según sea el caso.
void CsvLoader::loadDistricts(ifstream& stream): Crea una nueva lista de Distritos y la inserta
en el árbol de Distritos. Los métodos loadVoters, loadPositions, loadLists, loadCandidates,
loadElections funcionan de igual manera
Bot
Simula el ingreso del usuario al sistema y su voto de forma aleatoria.
Al comenzar una simulación la clase procede de la siguiente forma:
Se loguea, con fallos en el loggin aleatorios y vota tmabien aleatoreamente.
Especificacion de metodos
El metodo RunSimulation itera al arbol de usuarios, busca uno aleatorio y mediante el metodo
voteOnce lo hace loguear, bien o mal según un metodo que devuelve probabilidades aleatorias.
Luego si ingresa lo hace votar una eleccion y una lista, igual que el usuario puede equivocar el
voto y volver a votar.
Todas las acciones del bot quedan registadas en el Logg diferenciandolas del usuario comun.
Arbol B+
Descripcion de funcionamiento general
El arbol trabaja con las siguientes clases:
BPlusTree, InternalNode, LeafNode, Node,Record.
BPlu
sTre
e
Nod
e
Inter
nalNo
de
Leaf
Nod
e
Rec
ord
El ArbolB+ tiene al nodo raiz y siempre desde ahi carga los nodos siguientes.
Los nodos internos listados con los primeros ids de los listados de registros de los nodosHojas, y
con los ids de los nodosHijos.
Los nodosHojas contienen un listado de registros y el id del nodo de la siguiente hoja.
Descripcion de archivos de trabajo
El ArbolB+ al crearlo crea 2 archivos con los que trabaja, los nombres cambian según el arbol a
cargar, por ejemplo:
Votantes: archivo con información de control para decodificar la info que contiene el archivo
+los nodos del arbol serializados.
Votantes.free: archivo con los ids de los nodos libres.
Luego de creados los archivos, siempre que se le pase ese nombre de archivo al arbol al
instanciarlo carga el archivo existente y se opera sobre el.
El arbol trabaja con la clase FileManager, que se ocupa de leer del archivo y escribir datos en su
archivo de trabajo.
Descripcion de la Persistencia
Arbol:
En el archivo de trabajo se guarda una cabecera con información de control para al levantarlo
poder intepretar los datos, con los siguentes datos:
TAMAÑOBLOQUE+CANTIDADNODOS+CANTIDADNODOSLIBRES+CANTIDADREGISTROS.
Y luego los nodos serializados.
El el archivo de nodos líbres se ingresan numeros enteros de los numeros de nodo liberados.
Nodos:
Interno: NIVEL+ID+CANTIDAD-IDS+ID1+…+IDN+IDHIJO1+…+IDHIJON
Hoja: ID+NIVEL+CANTREGISTROS+REGISTRO1+…+REGISTRON+HOJASIGUIENTE
*los registros van serializados también.
Registros: ID+TAMAÑO+VALOR
Descripción de métodos más relevantes ArbolB+
CrearArbol: BPlusTree::BPlusTree(string filename, int BLOCKSIZE);
Al instanciar un ArbolB+ se le deben pasar un nombre de archivo y el tamaño del bloque.
Para trabajar con el arbol se generan dos archivos con el nombre del archivo: un archivo para
indexar los datos insertados y un archivo con el mismo nombre +”.free” para indexar los nodos
libres.
El tamaño del bloque permite el serializado y el hidratado de los datos guardados en los
archivos.
InsertarRegistro: BPlusTree::insert(Record * record);
Para insertar un registro se procede de la siguiente forma:
Se llama al metodo insert, pasandole el registro, controla que no sea mas grande que el maximo
permitido y luego llama al insert recursivo desde el nodo raiz.
El retorno controla el overflow de la raiz, y si desboda crea un nuevo nodo interno como raiz y lo
linkea al existente que queda como hoja.
El insert recursivo BPlusTree::recursiveInsert(Record * record, Node*currentNode,int *
promotedKey,int *promoteNodeId );
Se le pasa un registro, el nodo actual, y se trata distinto si es nodo hoja o nodo interno.
Nodo interno: Se busca el nodoInterno donde debe ir ese registro y se llama al insertRecursivo
nuevamente hasta encontrarnos con el nodo hoja
Nodo Hoja: se inserta en el nodo y si fallose trata el overflow.
Si hay overflow se pasa la clave del registro que sube y el id del nodo que sube tambien.
OVERFLOW: se tarta distinto al ser hoja y interno
NodoHoja: Se crea un nuevo nodo hoja y con el nodo desbordado se reparten los registros y se
vuelve a guardar el archivo. Se pasa el id del registro al nodoInterno superior.
NodoInterno: Se crea un nuevo nodo interno y con el nodo desbordado se reparten los ids de
los nodos, luego se vuelve a guardar el archivo. Se pasa el id del registro al nodoInterno
superior.
ModificarRegistro: BPlusTree::modify(Record * record);
Al igual que en el insertar se llama a un modificar recursivo, que itera los nodos internos hasta
llegar al nodohoja que contiene el registro y se trata de modificar. Se le pasa al modificar solo el
registro y el nodoactual. BPlusTree::recursiveModify(Record * record, Node*currentNode);
Si hay overflow se elimina el registro y se vuelve a insertar en el arbol.
EliminarRegistro: BPlusTree::remove(Record * record );
Se elimina desde el nodo raiz, si es interno se busca el registro comparando con los ids hasta
encontrar el nodo hoja, se instancia y se hace remove en ese nodo.
Si hay underflow se intenta hacer un merge entre los nodos hermanos (primero intenta con el
izquierdo, después el derecho).
BuscarRegistro: BPlusTree::find(Record * record );
Se llama al search recursivo. BPlusTree::recursiveSearch(Record * record,Node * node)
Se busca desde la raiz y comparando los ids de los registros en los nodos internos hasta las
hojas, recorre los registros de la hoja y si existe devuelve el nodo correspondiente al id del
registro buscado.
IterarArbol BPlusTree::iterate();
Devuelve un registro de cada una de los nodos hojas recorrido en orden.
Constantes
Se utilizo un archivo de constantes para especificar que archivo utilizaremos para cada arbol,
según el tipo de entidad. Tambien contiene las constantes requeridas para controlar el tamaño
de los nodos y registros, y el porcentaje para considerar overflow o underflow.
/* Constantes
#define
#define
#define
#define
Cuestionario
de tamaño */
BLOCKSIZE
256
MAX_PERCENTAGE
0.8
MIN_PERCENTAGE
0.5
MAX_RECORD_PERCENTAGE
0.25
Sequence set:
-¿Cómo delimitan la longitud de un registro y de un campo variable?.
Utilizamos un archivo de bloques (para los nodos) de tamaño fijo 256 caracteres. Siempre que
se guarda o levanta, el tamaño es fijo.
Tambien utilizamos otro archivo con registros de longitud variable. Donde guardamos el registro
serializado con el id de tipo entero, mas el tamaño de los valores y luego los valores, asi siempre
que leemos sabemos el tamaño a levantar del archivo para llenar el registro.
-Mostrar los campos que posee y cuanto espacio ocupa cada uno.
Nodos:
Interno: NIVEL+ID+CANTIDAD-IDS+ID1+…+IDN+IDHIJO1+…+IDHIJON
Hoja: ID+NIVEL+CANTREGISTROS+REGISTRO1+…+REGISTRON+HOJASIGUIENTE
Los nodos ocupan 256 cada uno.
Registros: ID+TAMAÑO+VALOR
Los registros son de longitud variable
-Política utilizada para split / concatenación de bloques. ¿Hacen algún tipo de
redistribución?
Cuando un nodo se desborda, implementamos el siguente procedimiento de split:
Creamos nodo nuevo, y distribuimos el contenido del nodo desbordado con el nuevo nodo. Luego
promovemos el 1er id del nuevo nodo al padre mas el numero de nodo nuevo.
Cuando un nodo queda en underflow, implementamos el siguiente procedimiento:
Nos fijamos si tiene nodo izquierdo, sino cargamos el nodo derecho, tratamos de redistribuir los
nodos, sino se puede hacemos un merge, unimos los nodos y liberamos el nodo con underflow.
Diagramas de secuencia
Diagrama de ingreso del usuario al sistema
Este diagrama representa la interacción del usuario con el sistema al intentar ingresar al mismo
Diagrama de seleccion de la elección del usuario
Este diagrama representa la interacción del usuario con el sistema al seleccionar entre las
posibles elecciones a votar
Diagrama de voto del usuario
Este diagrama representa la interacción del usuario con el sistema al seleccionar entre los
posibles candidatos a votar y luego la confirmación del voto.
Diagramas de modificación, alta y baja por parte del administrador
Hemos diseñado los diagramas de secuencia para dar de alta, baja y modificar a un votante.
El método para realizar dichas acciones coincide tanto para los votantes como para las
elecciones, cargos, distritos, listas y candidatos por lo que los gráficos de secuencia también
coinciden. Hemos decidido ejemplificar con el votante
Diagrama de modificación del votante
Este diagrama representa la interacción del usuario administrador con el sistema para modificar
un votante.
Diagrama de alta del votante del administrador
Este diagrama representa la interacción del usuario administrador con el sistema para dar de
alta a un votante.
Diagrama de baja del votante del administrador
Este diagrama representa la interacción del usuario administrador con el sistema para dar de
baja a un votante.
Planificación
En la primera semana de realización del TP definimos la estrategia a utilizar, las estructuras de
datos de archivos en disco y el modelo de los objetos. Se decidió que estructuras utilizar para el
mejor desarrollo del proyecto, concluyendo que se realizarían un árbol b+ y un hash extensible,
ambos genéricos para que contengan registros de distinto tipo. El árbol b+ encargado de
organizer a los distritos, votantes y listas y el hash extensible a las elecciones, conteo y
candidatos. Luego se comenzó a desarrollar ambas estructuras durante tres semanas pero se
avanzó más con el árbol b+ que con el hash extensible por lo que para optimizar el tiempo
restante decidimos cambiar la estrategia y utilizar únicamente el árbol b+ para organizar todas
las entidades. Se crearon herramientas de utilización común para varias clases como la clase
para crear y manejar registros y archivos. Luego se comenzó a diseñar y desarrollar el Control,
encargado de manejar todo lo que concierne a las elecciones conectando a la interfaz gráfica
con el árbol b+, el Loader , encargado de las altas masivas desde archivos y luego la interfaz
gráfica, encargada de la relación directa con el usuario. Finalmente luego de tener todo bien
definido se pasó a realizar las pruebas de código para corroborar que el funcionamiento del
proyecto sea óptimo para luego realizar la documentación pertinente.
Descargar