TProcura.h

Go to the documentation of this file.

#pragma once
 
#include "TVector.h"
#include <time.h>
#include <stdint.h>
#include <limits.h>
#include <stdio.h>
#include <inttypes.h> 
#include <cstdarg>
#include "compact.h"
 
 
// código para número não lido (não deve ser utilizado num parâmetro)
constexpr int NAO_LIDO = 1024;
 
enum EIndicadoresProcura {
    IND_RESULTADO = 0, 
    IND_TEMPO,         
    IND_ITERACOES,     
    IND_PROCURA        
};
 
enum EParametrosProcura {
    ALGORITMO = 0,        
    NIVEL_DEBUG,          
    SEMENTE,              
    LIMITE_TEMPO,         
    LIMITE_ITERACOES,     
    PARAMETROS_PROCURA    
};
 
enum ENivelDebug {
    NADA = 0,   
    ATIVIDADE,  
    PASSOS,     
    DETALHE,    
    COMPLETO,   
    EXTRA_DEBUG 
};
 
enum EOperacao { GRAVAR = 0, LER };
 
enum ECronometro {
    CONT_ALGORITMO = 0, 
    CONT_TESTE,         
    CONT_REPORTE,       
    CONT_PREPARACAO,    
    CONT_FINALIZACAO,   
    CONT_CHECKPOINT,    
    CONT_NUMERO         
};
 
enum ETagMPI {
    TAG_TRABALHO = 0,  
    TAG_CABECALHO,
    TAG_VALORES
};
 
 
// identificação de todos os indicadores definidos
typedef struct SIndicador {
    const char* nome;
    const char* descricao;
    int indice;
} TIndicador;
 
typedef struct SParametro {
    const char* nome = "Indefinido";
    int valor = 0;
    int min = 0;
    int max = 0;
    const char* descricao = nullptr;
    const char** nomeValores = nullptr;
    TVector<int> dependencia;
} TParametro;
 
 
typedef struct SResultado {
    int instancia = 0, configuracao = 0;
    TVector<int64_t> valor; // valor para cada indicador selecionado (fixos os EIndicadoresProcura, resultado, tempo, iterações)
} TResultado;
 
 
class TProcura
{
public:
    TProcura(void) {}
    virtual ~TProcura(void) {}
 
    virtual void Inicializar(void) {}
 
 
    virtual int ExecutaAlgoritmo() { return -1; }
 
    virtual int64_t Indicador(int id);
 
    virtual void Debug(bool completo = true);
 
    virtual void ResetParametros();
 
    virtual bool Parar(void) {
        return TempoExcedido() || IteracoesExcedido() || memoriaEsgotada;
    }
 
    virtual void TesteManual(const char* nome);
 
    virtual void TesteEmpirico(TVector<int> instancias, char* ficheiro = NULL);
 
    virtual void TesteEmpiricoGestor(TVector<int> instancias, char* ficheiro = NULL);
    virtual void TesteEmpiricoTrabalhador(TVector<int> instancias, char* ficheiro = NULL);
 
    virtual void main(int argc, char* argv[], const char* nome);
 
    virtual void LimparEstatisticas();
    virtual void ExecucaoTerminada();
    virtual void Explorar() {}
    virtual void MostrarSolucao();
    virtual TVector<int64_t> CodificarSolucao() { return TVector<int64_t>(); }
 
    static TParametro instancia;
    static char ficheiroInstancia[256];
    static TVector<TParametro> parametro;
    static TVector<TIndicador> indicador;
    static TVector<int> indAtivo; // lista por ordem dos indicadores a utilizar
    static TVector<TVector<int>> configuracoes;
    static int resultado;
    static double tempo;
    static int iteracoes;
    static clock_t instanteFinal;
    static bool memoriaEsgotada;
    static int mpiID;
    static int mpiCount;
    static int modoMPI; 
 
 
 
    bool TempoExcedido() { return instanteFinal < clock(); }
    bool IteracoesExcedido() {
        return Parametro(LIMITE_ITERACOES) > 0 && Parametro(LIMITE_ITERACOES) < iteracoes;
    }
    // ler um número, ou retorna NAO_LIDO
    static int NovoValor(const char* prompt);
    // ler uma string
    static char* NovoTexto(const char* prompt);
 
    // retorna o valor do parametro, para facilidade de uso (leitura e escrita)
    int Parametro(int id) const { return parametro[id].valor; }
    int& Parametro(int id) { return parametro[id].valor; }
    bool ParametroAtivo(int id, TVector<int>* valores = NULL) const {
        if (parametro[id].dependencia.Empty())
            return true;
        int valor;
        if (valores == NULL)
            valor = Parametro(parametro[id].dependencia.First());
        else
            valor = (*valores)[parametro[id].dependencia.First()];
        return parametro[id].dependencia.Find(valor, true, 1) >= 0;
    }
 
    static bool Debug(ENivelDebug tipo, bool exato, const char* fmt, ...) {
        int nivel = parametro[NIVEL_DEBUG].valor;
        if (exato ? nivel != tipo : nivel < tipo)
            return false;
        va_list args;
        va_start(args, fmt); // último parâmetro fixo é 'fmt'
        vprintf(fmt, args);
        va_end(args);
        return true;
    }
 
    static char *MostraTempo(double segundos);
 
protected:
 
    void ExecutaTarefa(TVector<TResultado>& resultados, int inst, int conf);
 
 
    void InserirRegisto(TVector<TResultado>& resultados, int inst, int conf);
 
    int64_t Registo(TResultado& resultado, int id);
 
    void Registo(TResultado& resultado, int id, int64_t valor);
 
    void MostraParametros(int detalhe = 1, TVector<int>* idParametros = NULL);
 
    void MostraIndicadores();
 
    void MostrarConfiguracoes(int detalhe, int atual = -1);
 
    bool EditarIndicadores();
 
    void EditarParametros();
 
    void EditarConfiguracoes();
 
    void MostraRelatorio(TVector<TResultado>& resultados, bool ultimo = false);
 
    void ConfiguracaoAtual(TVector<int>& parametros, int operacao);
 
    int NovaConfiguracao(TVector<int>& parametros);
 
    int MelhorResultado(TResultado base, TResultado alternativa);
 
    void CalculaTorneio(TVector<TResultado>& resultados);
 
    void MostrarTorneio(TVector<TVector<int>>& torneio, bool jogo = false);
 
    void BarraTorneio(bool nomes);
 
    TVector<TResultado> ExtrairConfiguracao(TVector<TResultado>& resultados, int configuracao);
 
    void SolicitaInstancia();
 
    TVector<int> SolicitaInstancias();
 
    bool RelatorioCSV(TVector<TResultado>& resultados, char* ficheiro);
 
    void InserirConfiguracoes(char* str, TVector<int>& base);
 
    void InserirConfiguracoes(TVector<int>& base, TVector<int>& produto, TVector<TVector<int>>& valores);
 
    void AjudaUtilizacao(const char* programa);
 
    static int Dominio(int& variavel, int min = INT_MIN, int max = INT_MAX);
 
    static void InicializaMPI(int argc, char* argv[]);
    static void FinalizaMPI();
 
    void DebugTabela(ENivelDebug nivel, TVector<int>tabela, const char *tipo = "");
 
    bool JuntarCSV(const char* ficheiro);
 
    static double Cronometro(enum ECronometro id = CONT_ALGORITMO, bool inicialiar = false) {
        static clock_t inicio[CONT_NUMERO] = { 0 }; // até 10 cronómetros
        if (inicialiar)
            inicio[id] = clock();
        return (double)(clock() - inicio[id]) / CLOCKS_PER_SEC;
    }
};