English (Español a continuación)

ASO databases use the aggregate storage cache during:

  • The data load.
  • Aggregations.
  • Consultations.

When the application starts, Essbase allocates a cache to it; if it needs more cache, it increases until it reaches the maximum cache allocated to the application.

  • By default, Essbase allocates 32 MB but it can be increased.

In the console you can check the size of the cache: right-click on the database and select “Edit” / “Properties”. In the window opened select “Statistics”.

  • Size of the current cache (the cache used).
  • Current cache size limit (maximum available cache).

Also, the current cache size limit can be queried using Maxl:

  • query application ‘Application name’ get cache_size;

Adjust cache size

The optimal cache size depends on several variables:

  • Data volume.
  • Outline.
  • Formulas.
  • Data distribution.

Adjusting the size of the cache can have a positive impact on efficiency.

Different benchmarks can be used to estimate the optimal cache size:

a) First reference

For a database with an input-level data size of 2 GB the default cache size (32 MB) may be correct.

If your database has an input-level data size greater than 2 GB, you should increase the cache size by a percentage equal to the square root of the database size divided by 2 GB.

Let’s look at an example:

  • Database with an input-level data size of 5 GB.
  • Percent increase: square root of (5 / 2) = 1.5811
  • Recommended cache size: 32 * 1.5811 = 50.6 GB.

b) Second reference

Recommended cache size for data upload:

  • For small databases (up to 2 million cells-input): 32 MB is enough.
  • For larger databases (up to 20 million input-cells) the cache should be between 64-128 MB.
  • For very large databases (with more than 1,000 million cells-input) the cache should be set to 512 MB, and even 1 GB (if memory is available).

This size is generally appropriate for performing aggregations and queries.

However, to materialize aggregations, the number of threads for parallel calculations must be considered.

  • The number of threads can be increased using the CALCPARALLEL command.
  • Increasing the number of threads may require an increase in the cache. Each thread requires its own cache, so the size of the cache should be increased in the same proportion as the number of threads.

c) Also, for queries, another reference can be used:

  • A 32 MB cache may be sufficient for queries involving up to 90,000 cells of data.
  • A 64 MB cache may be sufficient for queries involving up to 180,000 cells of data.

You can consider increasing the cache so that Essbase can store all queried cells in memory.

  • However, increasing the cache offers a limited improvement (no more than 10-15%).

Other considerations:

  • The size of the aggregate storage cache should not be increased beyond what is necessary. There is a size when the differential improvement is very small.
  • A change in cache size takes effect when the application is restarted.
  • To calculate the optimal size it is convenient to perform tests with different cache sizes and compare results.
  • For machines with less than 4 GB of physical memory, it is advisable that the size of the cache does not exceed 50% of the available physical memory.

To change the cache size:

From the console: right-click on the application and in the window opened, select «Edit properties». In the “General” tab you can modify the pending cache size limit; then click on “Apply”:

  • The value is entered in MB.
  • The application must be restarted for the new value to take effect.

From Maxl:

  • alter application ‘Application name’ set cache_size xxMB;


Las bases de datos ASO utilizan el caché de almacenamiento agregado durante:

  • La carga de datos.
  • Agregaciones.
  • Consultas.

Cuando se inicia la aplicación Essbase le asigna un caché; si necesita más caché, este se va incrementando hasta alcanzar el máximo caché asignado a la aplicación.

  • Por defecto Essbase asigna 32 MB, pero se puede incrementar.

En la consola se puede consultar el tamaño del caché:  se hace click con el botón derecho sobre la base de datos y se selecciona “Editar “ / “Propiedades”. En la ventana que se abre se selecciona “Estadísticas”.

  • Tamaño del caché actual (la memoria caché utilizadas).
  • Límite del tamaño del caché actual (máxima memoria caché utilizable).

También el límite del tamaño del caché actual se puede consultar mediante Maxl:

  • query application ‘Nombre aplicación’ get cache_size;

Ajustar el tamaño del cache

El tamaño óptimo del caché depende de diversas variables:

  • Volumen de datos.
  • Outline.
  • Fórmulas.
  • Distribución de los datos.

Ajustar el tamaño del caché puede tener un impacto positivo en eficiencia.

Se pueden utilizar distintas referencias para estimar el tamaño óptimo del caché:

a) Primera referencia

Para una base de datos con un tamaño de datos de nivel-input de 2 GB el tamaño del caché por defecto (32 MB) puede ser el correcto.

Si la base de datos tiene un tamaño de datos de nivel-input superior a 2 GB conviene incrementar el tamaño del caché en un porcentaje equivalente a la raíz cuadrada del tamaño de la base de datos dividido entre 2GB.

Veamos un ejemplo:

  • Base de datos con un tamaño de datos de nivel-input de 5 GB.
  • Porcentaje de incremento: raíz cuadrada de (5 / 2) = 1.5811
  • Tamaño del cache recomendado: 32 * 1.5811 = 50,6 GB.

b) Segunda referencia

Tamaño recomendado del caché para carga de datos:

  • Para bases de datos pequeñas (hasta 2 millones de celdas-input): 32 MB es suficiente.
  • Para bases de datos mayores (hasta 20 millones de celdas-input) el caché debería situarse entre 64-128 MB.
  • Para bases de datos muy grandes (con más de 1.000 millones de celdas-input) el caché debería situarse en 512 MB, e incluso 1 GB (si hay memoria disponible).

Este tamaño suele ser apropiado para realizar agregaciones y consultas.

No obstante, para materializar agregaciones hay que considerar el número de threads para cálculos paralelos.

  • Se puede incrementar el número de threads mediante el comando CALCPARALLEL.
  • El incremento del número de threads puede requerir un incremento del caché. Cada thread requiere su propio cache por lo que habría que incrementar el tamaño del caché en la misma proporción en que se incrementa el número de threads.

c) También para consultas, se puede utilizar otra referencia:

  • Un caché de 32 MB puede ser suficiente para consultas que impliquen hasta 90.000 celdas con datos.
  • Un caché de 64 MB puede ser suficiente para consultas que impliquen hasta 180.000 celdas con datos.

Se puede valorar incrementar el caché de forma que Essbase pueda almacenar en memoria todas las celdas consultadas.

  • No obstante, el incremento del caché ofrece una mejora limitada (no más de un 10-15%).

Otras consideraciones:

  • No se debe incrementar el tamaño del cache de almacenamiento agregado más allá de lo que es necesario. Llega un momento en el que la mejora diferencial es muy pequeña.
  • Un cambio en el tamaño del caché entra en vigor cuando se reinicia la aplicación.
  • Para calcular el tamaño optimo es conveniente realizar tests con diferentes tamaños del cache y comparar resultados.
  • Para máquinas con menos de 4 GB de memoria física es conveniente que el tamaño del cache no supere el 50% de la memoria física disponible.

Para cambiar el tamaño del caché:

Desde la consola: se hace click con el botón derecho sobre la aplicación y en la ventana que se abre se abre se selecciona “Editar propiedades”. En la pestaña “General” se puede modificar el límite del tamaño del caché pendiente; a continuación se hace click en “Aplicar”:

  • El valor se introduce en MB.
  • Hay que reiniciar la aplicación para que el nuevo valor entre en vigor.

Desde Maxl:

  • alter application ‘Nombre aplicación’ set cache_size xxMB;