**Estrutura do projeto**

[pabloufrn]

Fazer todas as tarefas iniciais que darão base para todas as outras tarefas. Se alguma coisa precisar ser mudada aqui depois que a tarefa for concluida, ela será reaberta

• [x] Criar structs que serão usadas
• [x] Fazer assinaturas de métodos.
• [x] criar .hpp (header file) e Documentar.

Irei fazer e terminar n quinta, a partir daí irei descrever as outras tarefas.

[pabloufrn]

Foram feitas mudanças na estrutura do projeto. Devido à caracteristica da n-way set replacement strategy de trabalhar com a substituição somente em cima de um conjunto, agora às funções de substituição recebem o indice do conjunto (na cache) e o tamanho do conjunto, conforme o exemplo abaixo:

void subs_qualquer(Bloco& novo_bloco, int indice_inicial = 0, int tamanho_conjunto = 0);

Para facilitar o entendimento também foi implementada uma função intermediária com a mesma assinatura acima. Além disso, os contadores da linha da cache foram definidos (eles ainda estavam incertos):

int total_de_usos = 0;
int usos_recentes = 0;

Por consequência a classe ganhou a sobreescrita do operador de atribuição que inicializa os contadores e copia um objeto(bloco) da mémoria:

Linha& operator=(Bloco& bloco)
    {
        this->endereco = bloco.get_endereco();
        this->palavras = bloco.get_palavras();
        total_de_usos = 1;
        usos_recentes = 1;
        return *this;
    }

Sobre a classe pai (Bloco), foram adicionados operadores = e [], além dos métodos setters e getters, a estrutura ficou a seguinte:

class Bloco
{
public:
    Bloco(size_t tamanho)
    {
        palavras.resize(tamanho);
    }
    ~Bloco()
    {
        palavras.clear();
    }
    bool operator==(Bloco& rhs)
    {
       // dois blocos são iguais se eles tiverem o mesmo endereço na memória
       return this->endereco == rhs.endereco;
    }
    int& operator[](unsigned int indice)
    {
        return palavras[indice];
    }
    unsigned int& get_endereco()
    {
        return this->endereco;
    }
    std::vector<int>& get_palavras()
    {
        return palavras;
    }
protected: // *
    unsigned int endereco;
    std::vector<int> palavras;
};

*: Note que antes esses campos eram private, agora foram corrigidos.

O operador [] também foi colocado nas classes Memoria e Bloco para facilitar o acesso aos seus atributos privados:

// Classe Memoria
Bloco& operator[](unsigned int indice)
    {
        return blocos[indice];
    }
// Classe Cache
Linha& operator[](unsigned int indice)
    {
        return linhas[indice];
    }

Por fim, a classe cache recebou um contador, o objetivo dele é resetar o contador de recentemente usado de todas as linhas da cache, inicialmente ele será resetado quando a quantidade de cache misses forem iguais ao tamanho da cache, mas isso pode ser discutido posteriormente, segue o exemplo:

// definição (dentro da classe Cache)
int reinicializar_usos_recentes = tamanho;
// uso
void App::substituir(Bloco& novo_bloco, int indice_inicial, int tamanho_do_conjunto)
{
    // Atualizar usos recentes
    if(this->cache.reinicializar_usos_recentes == 0)
    {
        for(unsigned int i = 0; i < this->cache.tamanho; i++)
        {
            Linha& linha = this->cache[i];
            linha.usos_recentes = 0;
        }
        this->cache.reinicializar_usos_recentes = this->cache.tamanho;
    }
}