Instituto de Matemática e Estatística - USP MAC Organização de Computadores EP1. Experimentos com o cache. Tiago Andrade Togores

Transcrição

1 Instituto de Matemática e Estatística - USP MAC Organização de Computadores EP1 Experimentos com o cache Tiago Andrade Togores de setembro de 2010

2 Sumário 1 Introdução O que é o Cache Funcionamento do Cache Associatividade Níveis de Cache Testes Hardware Utilizado Teste 1 - Percorrendo Matrizes O problema Tempo Aproveitamento do cache Teste 2 - Somando Vetores O problema Tempo Aproveitamento do cache Teste 3 - Memória Compartilhada entre Cores

3 1 Introdução 1.1 O que é o Cache O cache é uma memória menor e mais rápida, usada pelo processador, que guarda cópias de dados dos endereços de memória mais utilizados. Como a maioria dos acessos à memória são feitas a endereços que estão no cache, a latência média do acesso à memória é mais próxima da latência do cache do que da latência da memória principal. Os processadores mais modernos possuem principalmente 2 tipos independentes de cache: Cache de Instrução (apenas leitura) Cache de Dados (leitura e escrita) Cada local da memória principal é constituída de: Endereço: identificador único do local Dados Já cada local do cache: Endereço: identificador único do local Tag: endereço da memória que foi colocada no cache Figura 1: Esquema do Cache Dados: cópia dos dados de um certo endereço de memória 1.2 Funcionamento do Cache Quando o processador precisa escrever (ou ler) num endereço da memória principal, ele primeiro checa se esse endereço está no cache, comparando-o com todas as tags do cache que podem contê-lo. Quando o processador acha um local de memória no cache, ocorre um cache hit. Caso contrário, um cache miss. A proporção de cache hit e acessos é chamada de hit rate e é uma medida da eficiência do cache para um certo programa ou algoritmo. O aproveitamento da velocidade da memória cache do CPU é essencial para que um programa seja rápido. O hit rate será analisado nos testes a seguir. No caso de um cache hit, o processador imediatamente lê do cache. Se a operação requisitada for de escrita, existem diferentes políticas que podem ser utilizadas. Toda escrita no cache pode causar uma escrita imediata à memória (write-through); Uma alternativa é marcar o bloco do cache com um dirty bit. Quando este bloco for removido do cache e o dirty bit for 1, a escrita é realizada (write-back). Podemos ter outras políticas intermediárias também. No caso de um cache miss, uma nova entrada é alocada no cache, contendo o endereço de memória que anteriormente não estava numa das tags e uma cópia dos dados associados. Se for uma operação de leitura de instrução, há um atraso na execução, pois é preciso esperar uma transferência de dados de uma memória mais lenta. Se for leitura de dados, há um atraso menor, já que instruções que não dependem desse dado podem continuar a ser executadas. Diferentemente da escrita, que pode ser feita em background. 2

4 Para alocar um novo bloco no cache, um existente tem de ser removido. Para isso há várias políticas diferentes. Uma popular é a de substituir a entrada mais antiga. Alguns trechos de memória também podem ser definidos de modo que não possam ser colocados no cache, melhorando a performance, se aplicado a trechos que quase nunca são usados. Neste caso, cache misses são ignorados. Os dados na memória principal podem ser modificados por outros cores, fazendo com o que a cópia armazenada no cache se torne desatualizada. Por isso, devem existir protocolos de comunicação entre gerenciadores de cache em sistema multi-core. 1.3 Associatividade Cada trecho de memória pode ser associado a uma ou mais posições no cache, isto é, pode ser guardado em apenas certas posições (não pode aparecer em mais de uma simultaneamente). Quanto mais associações, mais tempo de busca no cache, porém menor chance de ocorrer um cache miss. Tipos de Associação: Direct: cada trecho de memória pode ser associado a uma única posição no cache; 2-Way: cada trecho de memória pode ser associado a duas posições no cache; 4-Way: cada trecho de memória pode ser associado a quatro posições no cache; 8-Way: cada trecho de memória pode ser associado a oito posições no cache; Full: cada trecho de memória pode ser associado a qualquer posição no cache; Figura 2: Quantidade de Cache Misses em função da associatividade e do tamanho do cache 3

5 1.4 Níveis de Cache Uma questão importante é a latência do cache contra seu hit rate. Maiores caches possuem maiores hit rates porém maior latência. Para atenuar esse problema, os computadores mais modernos usam diversos níveis de cache. Há uma pirâmide do cache menor e mais rápido até maior e mais lento. A busca por um endereço de memória no cache começa no menor e prossegue até que ele seja achado, seja em alguns dos níveis do cache ou na memória principal. Os níveis são: L1: interno, pode ser dividido em dois independentes: I1: cache de instrução D1: cache de dados L2: interno, cache unificado de instruções e dados L3: geralmente externo a CPU Nota-se também que podemos definir os registradores de uma CPU como sendo o cache mais rápido do sistema. 4

6 2 Testes 2.1 Hardware Utilizado Processador: Intel Core 2 Duo T6500 Cores: 2 Clock: 2.1 GHz I1: 32KB, 8-way, 64B lines D1: 32KB, 8-way, 64B lines L2: 2MB, 8-way, 64B lines 2.2 Teste 1 - Percorrendo Matrizes O problema Cada linha da matriz é alocada dinâmica e separadamente. Logo, quando se percorre a matriz por linhas, cada linha (segmento de memória) é percorrida de uma vez e sequencialmente. Quando se percorre por colunas, na n-ésima iteração olha-se para os n-ésimos elementos de cada linha. Do ponto de vista do cache, percorrer a matriz por linhas significa guardar cada linha no cache de uma vez, e percorrê-la de forma rápida. Já para percorrer por colunas, a cada iteração o cache tem que ser atualizado vários vezes, para pegar os elementos de cada linha. Daí a diferença de tempo Tempo Dimensão da Matriz Tempo por Linha Tempo por Coluna 100 x x x x x x x Tabela 1: Relação do tempo de execução do programa (em segundos) com a dimensão da matriz Observação: Foram feitas 10 amostras para cada dimensão da matriz observada na tabela A partir de 500, fica perceptível a diferença de tempo Aproveitamento do cache Dados do Valgrind: Dimensão: 500 Por linhas ==7678== I refs: 3,120,268 ==7678== I1 misses: 707 ==7678== L2i misses: 704 ==7678== I1 miss rate: 0.02% 5

7 ==7678== L2i miss rate: 0.02% ==7678== ==7678== D refs: 1,933,542 (1,630,481 rd + 303,061 wr) ==7678== D1 misses: 18,810 ( 2,386 rd + 16,424 wr) ==7678== L2d misses: 17,315 ( 1,425 rd + 15,890 wr) ==7678== D1 miss rate: 0.9% ( 0.1% + 5.4% ) ==7678== L2d miss rate: 0.8% ( 0.0% + 5.2% ) ==7678== ==7678== L2 refs: 19,517 ( 3,093 rd + 16,424 wr) ==7678== L2 misses: 18,019 ( 2,129 rd + 15,890 wr) ==7678== L2 miss rate: 0.3% ( 0.0% + 5.2% ) Por colunas ==7689== I refs: 3,120,256 ==7689== I1 misses: 708 ==7689== L2i misses: 705 ==7689== I1 miss rate: 0.02% ==7689== L2i miss rate: 0.02% ==7689== ==7689== D refs: 1,933,542 (1,630,481 rd + 303,061 wr) ==7689== D1 misses: 137,276 ( 11,804 rd + 125,472 wr) ==7689== L2d misses: 17,315 ( 1,425 rd + 15,890 wr) ==7689== D1 miss rate: 7.0% ( 0.7% % ) ==7689== L2d miss rate: 0.8% ( 0.0% + 5.2% ) ==7689== ==7689== L2 refs: 137,984 ( 12,512 rd + 125,472 wr) ==7689== L2 misses: 18,020 ( 2,130 rd + 15,890 wr) ==7689== L2 miss rate: 0.3% ( 0.0% + 5.2% ) Dimensão: 1000 Por linhas ==7750== I refs: 11,552,026 ==7750== I1 misses: 706 ==7750== L2i misses: 703 ==7750== I1 miss rate: 0.00% ==7750== L2i miss rate: 0.00% ==7750== ==7750== D refs: 7,275,552 (6,194,309 rd + 1,081,243 wr) ==7750== D1 misses: 66,842 ( 2,949 rd + 63,893 wr) ==7750== L2d misses: 65,413 ( 2,062 rd + 63,351 wr) ==7750== D1 miss rate: 0.9% ( 0.0% + 5.9% ) ==7750== L2d miss rate: 0.8% ( 0.0% + 5.8% ) ==7750== ==7750== L2 refs: 67,548 ( 3,655 rd + 63,893 wr) ==7750== L2 misses: 66,116 ( 2,765 rd + 63,351 wr) ==7750== L2 miss rate: 0.3% ( 0.0% + 5.8% ) Por colunas 6

8 ==7766== I refs: 11,552,014 ==7766== I1 misses: 707 ==7766== L2i misses: 704 ==7766== I1 miss rate: 0.00% ==7766== L2i miss rate: 0.00% ==7766== ==7766== D refs: 7,275,552 (6,194,309 rd + 1,081,243 wr) ==7766== D1 misses: 1,067,150 ( 65,886 rd + 1,001,264 wr) ==7766== L2d misses: 65,393 ( 1,645 rd + 63,748 wr) ==7766== D1 miss rate: 14.6% ( 1.0% % ) ==7766== L2d miss rate: 0.8% ( 0.0% + 5.8% ) ==7766== ==7766== L2 refs: 1,067,857 ( 66,593 rd + 1,001,264 wr) ==7766== L2 misses: 66,097 ( 2,349 rd + 63,748 wr) ==7766== L2 miss rate: 0.3% ( 0.0% + 5.8% ) Dimensão: 2500 Por linhas ==7795== I refs: 70,031,320 ==7795== I1 misses: 719 ==7795== L2i misses: 716 ==7795== I1 miss rate: 0.00% ==7795== L2i miss rate: 0.00% ==7795== ==7795== D refs: 44,411,072 (37,956,799 rd + 6,454,273 wr) ==7795== D1 misses: 398,516 ( 4,680 rd + 393,836 wr) ==7795== L2d misses: 397,960 ( 4,347 rd + 393,613 wr) ==7795== D1 miss rate: 0.8% ( 0.0% + 6.1% ) ==7795== L2d miss rate: 0.8% ( 0.0% + 6.0% ) ==7795== ==7795== L2 refs: 399,235 ( 5,399 rd + 393,836 wr) ==7795== L2 misses: 398,676 ( 5,063 rd + 393,613 wr) ==7795== L2 miss rate: 0.3% ( 0.0% + 6.0% ) Por colunas ==7787== I refs: 70,031,308 ==7787== I1 misses: 720 ==7787== L2i misses: 717 ==7787== I1 miss rate: 0.00% ==7787== L2i miss rate: 0.00% ==7787== ==7787== D refs: 44,411,072 (37,956,799 rd + 6,454,273 wr) ==7787== D1 misses: 6,649,913 ( 397,023 rd + 6,252,890 wr) ==7787== L2d misses: 4,544,049 ( 13,515 rd + 4,530,534 wr) ==7787== D1 miss rate: 14.9% ( 1.0% % ) ==7787== L2d miss rate: 10.2% ( 0.0% % ) ==7787== ==7787== L2 refs: 6,650,633 ( 397,743 rd + 6,252,890 wr) ==7787== L2 misses: 4,544,766 ( 14,232 rd + 4,530,534 wr) 7

9 ==7787== L2 miss rate: 3.9% ( 0.0% % ) Dimensão: Por linhas ==7808== I refs: 1,104,715,447 ==7808== I1 misses: 721 ==7808== L2i misses: 718 ==7808== I1 miss rate: 0.00% ==7808== L2i miss rate: 0.00% ==7808== ==7808== D refs: 702,429,273 (601,667,877 rd + 100,761,396 wr) ==7808== D1 misses: 6,276,952 ( 13,835 rd + 6,263,117 wr) ==7808== L2d misses: 6,276,597 ( 13,525 rd + 6,263,072 wr) ==7808== D1 miss rate: 0.8% ( 0.0% + 6.2% ) ==7808== L2d miss rate: 0.8% ( 0.0% + 6.2% ) ==7808== ==7808== L2 refs: 6,277,673 ( 14,556 rd + 6,263,117 wr) ==7808== L2 misses: 6,277,315 ( 14,243 rd + 6,263,072 wr) ==7808== L2 miss rate: 0.3% ( 0.0% + 6.2% ) Por colunas ==7820== I refs: 1,104,715,435 ==7820== I1 misses: 722 ==7820== L2i misses: 719 ==7820== I1 miss rate: 0.00% ==7820== L2i miss rate: 0.00% ==7820== ==7820== D refs: 702,429,273 (601,667,877 rd + 100,761,396 wr) ==7820== D1 misses: 106,284,781 ( 6,273,208 rd + 100,011,573 wr) ==7820== L2d misses: 98,399,803 ( 94,498 rd + 98,305,305 wr) ==7820== D1 miss rate: 15.1% ( 1.0% % ) ==7820== L2d miss rate: 14.0% ( 0.0% % ) ==7820== ==7820== L2 refs: 106,285,503 ( 6,273,930 rd + 100,011,573 wr) ==7820== L2 misses: 98,400,522 ( 95,217 rd + 98,305,305 wr) ==7820== L2 miss rate: 5.4% ( 0.0% % ) Uma matriz 500x500 de inteiros em C ocupa um espaço de memória de aproximadamente 1MB, e como o cache tem 2MB, o cache miss ratio ainda é baixo nesse caso. Se observamos um valor de dimensão 1000, por exemplo, vemos que o D1 miss rate é bastante perceptível: 15.1%. 2.3 Teste 2 - Somando Vetores O problema Se percorremos vetores sequencialmente, podemos colocar grandes blocos deles no cache de cada vez (não importa o quão grande ele seja), e fazer instruções necessárias sequencialmente, sem ter que recolocar blocos iguais no cache mais de uma vez. 8

10 Entretanto, se percorremos com pulos, blocos terão que ser recolocados no cache mais de uma vez, pois voltamos ao início do vetor mais de uma vez (até que ele termine), causando uma perda de eficiência Tempo Offset Tempo Tabela 2: Relação do tempo de execução do programa (em segundos) com o offset Observação: Foram feitas 10 amostras para cada dimensão da matriz observada na tabela Aproveitamento do cache Offset = 1 ==7911== I refs: 2,320,188,579 ==7911== I1 misses: 687 ==7911== L2i misses: 684 ==7911== I1 miss rate: 0.00% ==7911== L2i miss rate: 0.00% ==7911== ==7911== D refs: 1,339,448,551 (869,423,021 rd + 470,025,530 wr) ==7911== D1 misses: 3,127,045 ( 1,251,840 rd + 1,875,205 wr) ==7911== L2d misses: 3,126,713 ( 1,251,524 rd + 1,875,189 wr) ==7911== D1 miss rate: 0.2% ( 0.1% + 0.3% ) ==7911== L2d miss rate: 0.2% ( 0.1% + 0.3% ) ==7911== ==7911== L2 refs: 3,127,732 ( 1,252,527 rd + 1,875,205 wr) ==7911== L2 misses: 3,127,397 ( 1,252,208 rd + 1,875,189 wr) ==7911== L2 miss rate: 0.0% ( 0.0% + 0.3% ) Offset = 600 ==8187== ==8187== I refs: 2,320,195,646 ==8187== I1 misses: 702 ==8187== L2i misses: 699 ==8187== I1 miss rate: 0.00% ==8187== L2i miss rate: 0.00% ==8187== ==8187== D refs: 1,339,452,730 (869,426,414 rd + 470,026,316 wr) 9

11 ==8187== D1 misses: 31,252,050 ( 20,001,846 rd + 11,250,204 wr) ==8187== L2d misses: 31,251,715 ( 20,001,527 rd + 11,250,188 wr) ==8187== D1 miss rate: 2.3% ( 2.3% + 2.3% ) ==8187== L2d miss rate: 2.3% ( 2.3% + 2.3% ) ==8187== ==8187== L2 refs: 31,252,752 ( 20,002,548 rd + 11,250,204 wr) ==8187== L2 misses: 31,252,414 ( 20,002,226 rd + 11,250,188 wr) ==8187== L2 miss rate: 0.8% ( 0.6% + 2.3% ) O desempenho fica pior para valores em torno de Teste 3 - Memória Compartilhada entre Cores O tempo para rodar o programa foi de segundos. Como ele possui dois processos que utilizam memória compartilhada, cada vez que modificam um valor dela, os caches dos 2 cores tem que ser atualizados, causando uma perda de eficiência. 10