ISCTE – ESCOLA DE GESTÃO - Universidade Técnica de Lisboa

tenha sido percorrido. Se o array estivesse armazenado sob a forma de vários chunks, a computação de
AB seria feita não percorrendo um plano completo de dimensão |A||B|, em que |A| e |B| são
respectivamente o tamanho da dimensão A e B, isso seria feito chunk a chunk. Supondo que a dimensão
A num chunk tem tamanho AC e que a dimensão B num chunk tem tamanho BC e que o array é orientado
de tal forma que a face AB do array está de frente para o leitor, o chunk pode ter início na parte superior
esquerda do array e percorrer um plano de dimensão ACBC, agregando todos os valores de C no
processo. Depois de percorrido este chunk na porção superior esquerda, o varrimento deste plano
continua através do chunk imediatamente atrás do que se encontra no topo superior esquerdo e termina
apenas quando o plano foi todo percorrido dentro do array. Neste ponto, a porção do agregado AB
correspondente ao subplano superior esquerdo de dimensão ACBC já foi computada, pelo que este plano
é guardado em disco como a primeira parte do agregado AB e prosseguir com o cálculo do subplano
correspondente a outro chunk. Desta forma, cada chunk apenas é lido uma vez e no fim de serem
percorridos todos os chunks o agregado AB encontrar-se-á em disco como uma colecção de planos de
tamanho ACBC. A memória usada por este processo é a suficiente para conter um chunk e o plano ACBC
à medida que os chunks são varridos [Zhao1997].
Porém, para computar um cubo é necessário computar mais que um agregado do mesmo. Num array
com as dimensões ABC, considere-se agora que é necessário computar AB, BC, AC, A, B, C e o
agregado total. Uma abordagem ingénua consistiria em computar todos estes agregados a patir do array
inicial ABC. Porém, é muito mais eficiente calcular A a partir de AB do que calcular A a partir de ABC. Se
se vir a computação do cubo como uma árvore em que ABC é a raiz, AB, BC e AC descendem de ABC,
A e C descendem de AC e assim sucessivamente. Como as dimensões do array e o tamanho de cada
um dos chunks são conhecidos, é possível determinar exactamente o tamanho do array correspondente
a cada nó da árvore e estimar o espaço necessário para o seu cálculo. Isto significa que é possível
definir a árvore mínima de cobertura (minimum spanning tree) em que o predecessor de cada nó n é o
nó n’ de menor tamanho a partir do qual n pode ser computado. O funcionamento do algoritmo apoia-se
na construção da árvore mínima de cobertura para os agregados do cubo que se pretende computar.
Cada agregado Di1, Di2, ..., Dik+1 é calculado a partir do predecessor Di1, Di2, ..., Dik+1 com tamanho
mínimo; cada chunk de Di1, Di2, ..., Dik+1 é lido segundo a dimensão Dik+1 e agregado para um chunk de
Di1, Di2, ..., Dik. Quando o chunk de Di1, Di2, ..., Dik estiver completo, é guardado em disco e a memória é
libertada para o chunk seguinte de Di1, Di2, ..., Dik [Zhao1997].
O recurso ao chunking assegura a eficiência a nível de carregamento e armazenamento dos valores das
células do cubo, enquanto a eficiência a nível de desempenho é assegurada pelo uso da ordem correcta
no cálculo dos agregados. A ordem das dimensões num chunk pode ser representada como O = (Dj1, Dj2,
... , Djn), assumindo que existem n dimensões D1, D2, ..., Dn. Diferentes ordenamentos de dimensões
implicam diferentes ordens de leitura dos chunks e determinam a quantidade de memória que é
necessária para efectuar a computação. Para mostrar a importância da ordem pela qual são tomadas as
dimensões, considere-se um array de dados 3D com três dimensões (A, B e C), dividido em 64 chunks
31