1. Entendendo a Frequência da CPU

A frequência de operação de um processador, comumente chamada de clock, representa a quantidade de ciclos que o hardware executa por segundo, sendo medida em Hertz (Hz). O cálculo básico é definido por: Frequência Final = Clock Base (BCLK) × Multiplicador. Enquanto o Clock Base sincroniza a CPU com a placa-mãe, o multiplicador define a escala interna de processamento. Em CPUs modernas, o multiplicador é dinâmico para economizar energia ou aumentar o desempenho (Turbo Boost).

2. Instruções e Ciclos de Clock

Uma instrução é a menor unidade de comando que um processador pode processar, composta por um opcode (operação) e operandos (dados). O conjunto dessas instruções forma a ISA (Instruction Set Architecture).

• CISC (Complex Instruction Set Computer): Instruções robustas que realizam múltiplas tarefas, comuns em arquiteturas x86, mas que exigem vários ciclos de clock para serem concluídas.
• RISC (Reduced Insrtuction Set Computer): Instruções simplificadas e otimizadas para execução em um único ciclo, predominantes em arquiteturas ARM.

A relação entre elas é medida pelo IPC (Instruções Por Ciclo). Instruções aritméticas simples podem levar apenas um ciclo, enquanto divisões ou operações de ponto flutuante complexas exigem múltiplos ciclos ou o uso de pipelines.

3. Memória e Hierarquia de Armazenamento

A frequência da memória RAM indica a taxa de transferência de dados. Com a tecnologia DDR (Double Data Rate), a transferência ocorre tanto na subida quanto na descida do sinal de clock, dobrando a eficiência em relação à frequência real de oscilação.

Pirâmide de Memória

1. Registradores: Dentro do núcleo da CPU, acesso em 1 ciclo.
2. Cache L1: Dividida em instrução e dados, latência mínima (1-4 ciclos).
3. Cache L2: Maior que a L1, serve como buffer intermediário.
4. Cache L3: Compartilhada entre núcleos, reduz gargalos de acesso à RAM.
5. Memória Principal (RAM): Gigabytes de espaço, mas com latência significativamente maior (centenas de ciclos).
6. Armazenamento Secundário (SSD/HDD): Persistência de dados com acesso via barramentos de I/O.

4. Cache Suja (Dirty Cache) e Coerência

O termo "Cache Suja" refere-se a uma linha de cache que foi modificada pela CPU, mas cujas alterações ainda não foram refletidas na memória RAM. Isso ocorre na estratégia de Write-back. Para gerencira isso em sistemas multicore, utiliza-se o protocolo MESI (Modified, Exclusive, Shared, Invalid), garantindo que um núcleo não leia dados obsoletos enquanto outro mantém uma cópia modificada (suja).

5. Detecção de Endianness em C++

Para identificar se um sistema é Little Endian (byte menos significativo no menor endereço) ou Big Endian, podemos utilizar ponteiros ou uniões.

// Abordagem via ponteiro
bool isLittleEndian() {
    unsigned int valor = 0x01;
    unsigned char* bytePtr = reinterpret_cast<unsigned char*>(&valor);
    return (*bytePtr == 1);
}

// Abordagem via Union
union Detector {
    uint32_t inteiro;
    uint8_t bytes[4];
};

bool checkEndian() {
    Detector d;
    d.inteiro = 0x01020304;
    return (d.bytes[0] == 0x04); // Verdadeiro se Little Endian
}

6. Conversão de Tipos (Casting) em C++

• static_cast: Utilizado para conversões seguras em tempo de compilação, como entre tipos primitivos ou downcasting em hierarquias de classes conhecidas.
• dynamic_cast: Exclusivo para polimorfismo, realiza verificações em tempo de execução (RTTI) para garantir a segurança entre tipos de uma mesma hierarquia.
• const_cast: Adiciona ou remove o qualificador const de uma variável.
• reinterpret_cast: Realiza conversões de baixo nível, tratando um padrão de bits como se fosse outro tipo, comum em programação de drivers ou manipulação de buffers brutos.

7. Implementação Recursiva do QuickSort

O QuickSort baseia-se na estratégia de divisão e conquista. Abaixo, uma implementação em C++:

#include <vector>
#include <algorithm>

int particionar(std::vector<int>& dados, int inicio, int fim) {
    int pivo = dados[inicio];
    int i = inicio + 1;
    int j = fim;

    while (i <= j) {
        if (dados[i] <= pivo) i++;
        else if (dados[j] > pivo) j--;
        else std::swap(dados[i], dados[j]);
    }
    std::swap(dados[inicio], dados[j]);
    return j;
}

void quicksort(std::vector<int>& v, int i, int f) {
    if (i < f) {
        int posPivo = particionar(v, i, f);
        quicksort(v, i, posPivo - 1);
        quicksort(v, posPivo + 1, f);
    }
}

No pior caso, a profundidade da recursão chega a N (quando o pivô é sempre o maior ou menor elemento). Isso ocorre em listas já ordenadas ou com elementos idênticos, caso a escolha do pivô seja ineficiente (como escolher sempre o primeiro elemento).

8. Sistema Operacional: Processos e Interrupções

Um Processo é uma instância de um programa em execução, isolado em seu próprio espaço de endereçamento virtual. Ele contém threads, descritores de arquivos e pilhas de execução.

Mecanismo de Interrupção

As interrupções permitem que o hardware ou eventos de software sinalizem à CPU a necessidade de atenção imediata.

• Hardware: Salva o estado atual (registradores) na pilha do kernel.
• Vetor de Interrupção: O processador consulta uma tabela para encontrar o endereço da rotina de tratamento (ISR).
• Troca de Contexto: O SO decide se retoma o processo anterior ou escala um novo após o tratamento.

9. Memória Virtual e Paginação

A mapeação entre endereços virtuais e físicos é feita pela MMU (Memory Management Unit) usando tabelas de páginas (Page Tables).

• TLB (Translation Lookaside Buffer): Um cache especiailzado que armazena as traduções recentes de endereços para acelerar o processo.
• Page Fault: Ocorre quando um endereço virtual acessado não possui uma página correspondente carregada na RAM física, forçando o SO a buscá-la no disco (swap).

10. Programação de Redes com Sockets

Para comunicação via rede, utilizamos a API de Sockets.

• Servidor: Utiliza socket(), bind() (associa IP/Porta), listen() (aguarda conexões) e accept().
• Cliente: Utiliza socket() e connect() para estabelecer o link.

O TCP garante a entrega ordenada e confiável através de confirmações (ACK) e controle de fluxo, enquanto o UDP foca em baixa latência, enviando pacotes sem garantia de entrega ou ordem, sendo ideal para jogos multiplayer e streaming.