Agregado informe con diagramas

Author: SBen-IV

.gitattributes

@@ -0,0 +1 @@
+diagramas export-ignore

README.md

@@ -4,4 +4,35 @@ Nombre completo: Sebastian Bento Inneo Veiga
 
 Padron: 100998
 
-Link: https://github.com/SBen-IV/tp2
+Link: https://github.com/SBen-IV/tp2
+
+# Descripción
+
+El trabajo práctico presentado corresponde a un programa que puede leer archivos .bpf y analizarlos en búsqueda de ciclos o instrucciones sin usar.
+
+## Lista de clases más importantes
+
+### eBPF
+
+![eBPF class](diagramas/eBPF_class.png)
+
+eBPF es la clase que maneja todo el comportamiento del programa y las demás clases. Es en el método `operator()` donde está el bucle que va tomando los archivos uno a uno y analizándolos para luego guardar los resultados de los mismos.
+
+### Grafo
+
+![Grafo class](diagramas/Grafo_class.png)
+
+Grafo es la clase que contiene las conexiones entre las lineas como nodos y aristas. Implementado a base de un hash para facilitar el acceso a los nodos. Además se encarga de buscar búcles o nodos sin visitar con el método `aplicarDFS()`. Los métodos implementados fueron los que únicamente se necesitaban para este TP.
+
+### Instruccion
+
+![Instruccion class](diagramas/Instruccion_class.png)
+
+Instruccion es una clase contenedora de la linea que se obtiene del archivo y además tiene por separado las partes que componen a la línea como lo son la etiqueta, opcode y los argumentos. `conectar()` agrega aristas desde el último nodo al nodo actual en caso de ser necesario, además si la instrucción actual es un `jmp` lo agrega a vector de `jmps`. Este vector será usado más adelante para buscar las etiquetas a los que los `jmps` saltan.
+
+## Aclaraciones
+
+No se llegó a cumplir la totalidad de los requerimientos de la entrega porque:
+- Se perdió tiempo tratando de hacer el parseo de las líneas
+- El modelo de grafo con Hash no era tan bueno como parecía. Si hay 2 líneas iguales (como en el caso de la prueba icmp) no las distingue y detecta un bucle. Se intentó otra implementación con una clase Nodo pero trajo otros problemas.
+- Con los atrasos anteriores sólo se pudo hacer una implementación básica de los threads.

Repositorio.cpp

@@ -1,22 +1,20 @@
 #include "Repositorio.h"
 
-Repositorio::Repositorio() {}
+Repositorio::Repositorio(std::mutex& _m) : m(_m) {}
 
 void Repositorio::agregar(const std::string& nombre) {
 	this->nombres.push(nombre);
 }
 
-Repositorio::Repositorio(Repositorio&& otro) {
-	this->nombres = otro.nombres;
-}
-
 bool Repositorio::estaVacio() const {
 	return this->nombres.empty();
 }
 
 std::string Repositorio::obtener() {
+	this->m.lock();
 	std::string aux = this->nombres.front();
 	this->nombres.pop();
+	this->m.unlock();
 
 	return aux;
 }

Repositorio.h

@@ -3,13 +3,16 @@
 
 #include <queue>
 #include <string>
+#include <mutex>
 
 class Repositorio {
 private:
 	std::queue<std::string> nombres;
+	std::mutex& m;
 public:
 	Repositorio();
-	Repositorio(Repositorio&& otro);
+	Repositorio(std::mutex& _m);
+	Repositorio(Repositorio&& otro) = delete;
 	void agregar(const std::string& nombre);
 	bool estaVacio() const;
 	std::string obtener();

Resultado.cpp

@@ -5,14 +5,15 @@
 #define BUCLE 1
 #define NODOS_SIN_VISITAR 2
 
-const std::string MENSAJE_GOOD = " GOOD";
-const std::string MENSAJE_CYCLE = " FAIL: cycle detected";
-const std::string MENSAJE_UNUSED = " FAIL: unused instructions detected";
+const char MENSAJE_GOOD[] = " GOOD";
+const char MENSAJE_CYCLE[] = " FAIL: cycle detected";
+const char MENSAJE_UNUSED[] = " FAIL: unused instructions detected";
 
-Resultado::Resultado() {}
+Resultado::Resultado(std::mutex& _m) : m(_m) {}
 
 void Resultado::agregar(const std::string& nombre_archivo,
 						const int resultado) {
+	this->m.lock();
 	switch (resultado) {
 		case OK:
 			this->resultados[nombre_archivo] = MENSAJE_GOOD;
@@ -24,6 +25,7 @@ void Resultado::agregar(const std::string& nombre_archivo,
 			this->resultados[nombre_archivo] = MENSAJE_UNUSED;
 		break;
 	}
+	this->m.unlock();
 }
 
 void Resultado::imprimir() {

Resultado.h

@@ -4,14 +4,16 @@
 #include <map>
 #include <string>
 #include <iterator>
+#include <mutex>
 
 typedef std::map<std::string, std::string> HashOrdenado;
 
 class Resultado {
 private:
 	HashOrdenado resultados;
+	std::mutex& m;
 public:
-	Resultado();
+	Resultado(std::mutex& m);
 	void agregar(const std::string& nombre_archivo, const int resultado);
 	void imprimir();
 	~Resultado();

diagramas/Grafo_class.png

@@ -1,13 +1,16 @@
+#include <iterator>
 #include "eBPF.h"
 #include "Grafo.h"
 #include "AnalizadorInstruccion.h"
-#include <iterator>
+#include "Repositorio.h"
+#include "Resultado.h"
 
 #define VACIO ""
 
-eBPF::eBPF() {}
+eBPF::eBPF(Repositorio& _nombres_archivos, Resultado& _resultados) :
+			nombres_archivos(_nombres_archivos), resultados(_resultados) {}
 
-int eBPF::analizar(const std::string& nombre_archivo) {
+static int analizar(const std::string& nombre_archivo) {
 	Archivo archivo(nombre_archivo, std::fstream::in);
 	std::string linea;
 	std::vector<Instruccion> instrucciones, jmps;
@@ -31,11 +34,21 @@ int eBPF::analizar(const std::string& nombre_archivo) {
 
 	std::vector<Instruccion>::iterator it_jmps = jmps.begin();
 
-	for(; it_jmps != jmps.end(); ++it_jmps) {		
+	for(; it_jmps != jmps.end(); ++it_jmps) {	
 		(*it_jmps).saltoA(instrucciones, grafo);
 	}
 
 	return grafo.aplicarDFS();
 }
 
+void eBPF::operator()() {
+	while (!this->nombres_archivos.estaVacio()) {
+		std::string nombre_archivo_actual = this->nombres_archivos.obtener();
+
+		int resultado = analizar(nombre_archivo_actual);
+
+		resultados.agregar(nombre_archivo_actual, resultado);
+	}
+}
+
 eBPF::~eBPF() {}

diagramas/Instruccion_class.png

@@ -4,11 +4,18 @@
 #include <string>
 #include <vector>
 #include "Archivo.h"
+#include "Grafo.h"
+#include "AnalizadorInstruccion.h"
+#include "Repositorio.h"
+#include "Resultado.h"
 
 class eBPF {
+private:
+	Repositorio& nombres_archivos;
+	Resultado& resultados;
 public:
-	eBPF();
-	int analizar(const std::string& nombre_archivo);
+	eBPF(Repositorio& _nombres_archivos, Resultado& _resultados);
+	void operator()();
 	~eBPF();
 };
 

diagramas/eBPF_class.png

@@ -1,38 +1,40 @@
 #include <iostream>
 #include <string>
+#include <vector>
+#include <thread>
+#include <mutex>
 #include "Repositorio.h"
 #include "eBPF.h"
 #include "Resultado.h"
 
 #define POS_INICIAL 2
 
-static void desarrollar_ebpf(Repositorio& nombres_archivos,
-							Resultado& resultados) {
-	while (!nombres_archivos.estaVacio()) {
-		std::string nombre_archivo_actual = nombres_archivos.obtener();
-
-		eBPF filtro;
-
-		int resultado = filtro.analizar(nombre_archivo_actual);
-
-		resultados.agregar(nombre_archivo_actual, resultado);
-	}
-}
-
 int main(int argc, char const *argv[]) {
 	if (argc < 3) {
 		std::cout << "./tp <num hilos> <archivo> [<archivo>...]" << std::endl;
 		return 0;
 	}
 
-	Repositorio nombres_archivos;
+	int cant_hilos = std::stoi(argv[1]);
+
+	std::mutex m_repositorio, m_resultado;
+
+	Repositorio nombres_archivos(m_repositorio);
 
 	for (int i = POS_INICIAL; i < argc; i++) {
 		nombres_archivos.agregar(argv[i]);
 	}
-	
-	Resultado resultados;
-	desarrollar_ebpf(nombres_archivos, resultados);
+
+	std::vector<std::thread> threads;
+	Resultado resultados(m_resultado);
+
+	for (int i = 0; i < cant_hilos; ++i) {
+		threads.push_back(std::thread {eBPF(nombres_archivos, resultados)});
+	}
+
+	for (int i = 0; i < cant_hilos; ++i) {
+		threads[i].join();
+	}
 
 	resultados.imprimir();