FIXPARALLEL

English (Español a continuación)

This command allows to set for a specific section of the calculation script the number of threads that Essbase will use in its parallel calculation and the dimension (or specific members of the outline) that Essbase will use to identify the tasks that are going to be performed in parallel.

  • This number of threads and these dimensions / members defined for this structure will prevail over those set by the CALCPARALLEL command (in the configuration file essbase.cfg or in the calculation script).

Its structure is similar to that of a FIX … ENDFIX, and consists of:

  • FIXPARALLEL(n, list of members)
    • Calculation
  • ENFIXPARALLEL

Being:

n: number of threads for the parallel calculation to be executed within this structure.

Member list: can be a member, a multidimensional member, a list of members, a function that generates a list of members, a sparse dimension….

  • Essbase only generates tasks from sparse dimension members that are not dynamic or shared, so there must be at least one member from a sparse dimension in this list.
  • If the list is very long, the tasks get smaller: if the tasks are very small, it can generate an overhead (by monitoring the tasks) that negatively impacts efficiency.
  • If the tasks are very large, there may not be enough tasks for the threads.

Avoid generating too many tasks:

  • In the FIXPARALLEL should be included only those members / combination of sparse members for which to create tasks.
  • The rest of the sparse members to be calculated must be included in a FIX inside or outside the FIXPARALLEL.

Let’s look at an example:

  • FIXPARALLEL(4,@RELATIVE(Products,0),@LIST(Germany,France,Italy,Spain))
    • “Target_sales” = sales * 1.15;
  • ENDFIX PARALLEL

In this example we apply a FIXPARALLEL structure with 4 threads to calculate the “Target_sales” for the level 0 of all products (dense dimension) for 4 markets (sparse dimension.

  • Essbase will divide the calculation into tasks considering these 4 members.

There can be a FIXPARALLEL inside a FIX:

  • FIXPARALLEL(n, list of members)
    • FIX()
      • Calculation
    • ENDFIX
  • ENFIXPARALLEL

Or vice versa:

  • FIX()
    • FIXPARALLEL(n, list of members)
      • Calculation
    • ENFIXPARALLEL
  • ENDFIX

When calculations are performed in parallel, the tasks are executed simultaneously but without determining whether one task is executed before another or not:

  • There is no guarantee that one task will be executed before another, so in the section in which this calculation is executed there should be no dependencies.

A FIX structure can be converted into a FIXPARALLEL structure seeking to gain efficiency.

  • The highest profits can be achieved in FIX structures that involve a high workload.

The command “SET CALCDIAGNOSTICS {LOGSIZE n;};” provides statistical information on the «n» longest tasks carried out within FIXPARALLEL.

Advantages and limitations of FIXPARALLEL

In certain cases, FIXPARALLEL may be preferable to CALCPARALLEL:

  • It is not limited by the order of the outline: while CALCAPARALLEL starts with the last sparse dimension to divide the calculations into tasks, in FIXPARALLEL there is freedom to choose which sparse members are to be used for the division into tasks:
    • This selection can be in some cases more efficient: for example, in those cases where CALCPARALLEL generates many empty tasks.
  • When temporary variables are used during the calculation.
  • Sometimes with the DATACOPY, DATAEXPORT and CLARBLOCK commands, and with the @XREF and @WRITE functions.

In any case, the possible convenience of using FIXPARALLEL must be verified by carrying out tests.

  • With both FIXPARALLEL and CALCPARALLEL the size of the calculation cache is important.

Some limitations of FIXPARALLEL:

  • Cannot run in partitioned databases.
  • Cannot be used with the structure EXCLUDE … ENEXCLUDE
  • Supports up to 8 threads.

POSTFIXPARALLEL

Within the FIXPARALLEL structure, an additional substructure can be included that allows to work with specific variables of the parallel calculation (THREADVAR), then passing the value to a VAR variable.

  • The occasions of use, in any case, are limited.

Its structure is:

  • VAR “Variable”;
  • FIXPARALLEL(n, list of members)
    • Calculation
    • THREADVAR “Parallel calc. variable»;
    • POSTFIXPARALLEL(“Variable” = ACCUMULATEVAR(“Parallel calc. variable”));
  • ENFIXPARALLEL

Let’s look at an example:

  • VAR Sum_incr = 0;
  • FIXPARALLEL(4,”2017”,”2018”,”2019”,”2020”)
    • THREADVAR Incr;
    • Obj_sales(
      • Incr = Sales + 5;
    • );
    • POSTFIXPARALLEL (Sum_Incr = ACCUMULATEVAR(Incr););
  • ENDFIX PARALLEL

In this example:

  • We define a VAR variable “Sum_Incr”.
  • We establish a FIXPARALLEL structure with 4 threads and with 4 members of the sparse dimension “Years”.
  • We define within the FIXPARALLEL structure a variable THREADVAR “Incr” that will take the value of sales increased by 5: each of the 4 threads will create its own variable.
  • The POSTFIXPARALLEL command allows to assign to the variable “Suma_Incr” the sum of the value of the THREADVAR variables «Incr» created in each thread (a total of 4 temporary variables).
  • The VAR variable “Suma_Incr” can be used outside the FIXPARALLEL structure (this cannot be done with the THREADVAR variables “Incr”, which are only operative within this structure). 

Español

Este comando permite establecer para una sección concreta del script de cálculo el número de threads que Essbase va a utilizar en su cálculo paralelo y la dimensión (o miembros determinados del outline) que Essbase va a utilizar para identificar las tareas que se van a ejecutar de forma paralela.

  • Este número de threads y estas dimensiones / miembros definidos para esta estructura predominarán sobre las fijadas por el comando CALCPARALLEL (en el fichero de configuración essbase.cfg o en el scritp de cálculo).

Su estructura es similar a la de un FIX … ENDFIX, y consiste en:

  • FIXPARALLEL(n, lista de miembros)
    • Cálculo
  • ENFIXPARALLEL

Siendo:

n:  número de threads para el cálculo paralelo que se va a ejecutar dentro de esta estructura.

Lista de miembros: puede ser un miembro, un miembro multidimensional, una lista de miembros, una función que genera una lista de miembros, una dimensión dispersa….

  • Essbase únicamente genera tareas a partir de miembros de dimensiones dispersas que no sean dinámicos ni compartidos, por lo que en esta lista al menos debe haber un miembro de una dimensión dispersa.
  • Si la lista es muy amplia las tareas se hacen más reducidas: si las tareas son muy pequeñas puede generar un overhead (por seguimiento de las tareas) que impacte negativamente en eficiencia.
  • Si las tareas son muy grandes puede que no haya tareas suficientes para los threads.

Hay que evitar generar demasiadas tareas:

  • En el FIXPARALLEL se deben incluir únicamente aquellos miembros /combinación de miembros dispersos para los cuales crear tareas.
  • El resto de los miembros dispersos que se van a calcular se deben incluir en un FIX dentro o fuera del FIXPARALLEL.

Veamos un ejemplo:

  • FIXPARALLEL(4,@RELATIVE(Productos,0),@LIST(Alemania,Francia,Italia,España))
    • “Obj_ventas” = ventas * 1,15;
  • ENDFIXPARALLEL

En este ejemplo aplicamos una estructura FIXPARALLEL con 4 threads para calcular el objetivo de ventas del nivel 0 de todos los productos (dimensión densa) de 4 mercados (dimensión dispersa.

  • Essbase va a dividir el cálculo en tareas a partir de estos 4 miembros.

Puede haber un FIXPARALLEL dentro de un FIX:

  • FIXPARALLEL(n, lista de miembros)
    • FIX()
      • Cálculo
    • ENDFIX
  • ENFIXPARALLEL

O viceversa:

  • FIX()
    • FIXPARALLEL(n, lista de miembros)
      • Cálculo
    • ENFIXPARALLEL
  • ENDFIX

Cuando se realizan cálculos en paralelos las tareas se van ejecutando simultáneamente pero sin determinar si una tarea se ejecuta antes que otra o no:

  • No hay garantía de que una tarea se ejecute antes que otra por lo que en la región en la que se ejecuta este cálculo no debe haber dependencias.

Una estructura FIX se puede convertir en una estructura FIXPARALLEL buscando ganar en eficiencia.

  • Las mayores ganancias se pueden conseguir en estructuras FIX que conlleven una elevada carga de trabajo.

El comando “SET CALCDIAGNOSTICS {LOGSIZE n;};” facilita información estadística sobre las “n” tareas de mayor duración realizadas dentro del FIXPARALLEL.

Ventajas y limitaciones de FIXPARALLEL

En ciertos casos FIXPARALLEL puede ser preferible a CALCPARALLEL:

  • No está limitado por el orden del outline: mientras que CALCAPARALLEL comienza por la última dimensión dispersa para dividir los cálculos en tareas, en FIXPARALLEL hay libertad para elegir aquellos miembros dispersos que se van a utilizar para la división en tareas:
    • Esta selección puede ser en algunos casos más eficiente: por ejemplo, en aquellos casos en los que CALCPARALLEL genera muchas tareas vacías.
  • Cuando se utilizan variables temporales durante el cálculo.
  • En ciertas ocasiones con los comandos DATACOPY, DATAEXPORT y CLARBLOCK, y con las funciones @XREF Y @WRITE.

En todo caso, la posible conveniencia de utilizar FIXPARALLEL hay que verificarla realizando tests.

  • Tanto con FIXPARALLEL como con CALCPARALLEL es importante el tamaño del caché de cálculo.

Algunas limitaciones de FIXPARALLEL:

  • No se puede ejecutar con bases de datos con particiones.
  • No se puede utilizar con la estructura EXCLUDE … ENEXCLUDE
  • Soporta hasta 8 threads.

POSTFIXPARALLEL

Dentro de la estructura FIXPARALLEL se puede incluir una subestructura adicional que permite funcionar con variables específicas del cálculo paralelo (THREADVAR), pasándole luego el valor a una variable VAR.

  • Las ocasiones de uso, en todo caso, son bastante limitadas.

Su estructura es:

  • VAR “Variable”;
  • FIXPARALLEL(n, lista de miembros)
    • Cálculo
    • THREADVAR “Variable cálc. paral.”;
    • POSTFIXPARALLEL (“Variable” = ACCUMULATEVAR(“Variable cálc. paral.”));
  • ENFIXPARALLEL

Veamos un ejemplo:

  • VAR Suma_incr = 0;
  • FIXPARALLEL(4,”2017”,”2018”,”2019”,”2020”)
    • THREADVAR Incr;
    • Obj_ventas(
      • Incr = Ventas + 5;
    • );
    • POSTFIXPARALLEL (Suma_Incr = ACCUMULATEVAR(Incr););
  • ENDFIXPARALLEL

En este ejemplo:

  • Definimos una variable VAR “Suma_Incr”.
  • Establecemos una estructura FIXPARALLEL con 4 threads y con 4 miembros de la dimensión dispersa “Años”.
  • Definimos dentro de la estructura FIXPARALLEL una variable THREADVAR “Incr” que va a tomar el valor de las ventas incrementadas en 5: cada una de las 4 threads va a crear su propia variable dándole un valor.
  • El comando POSTFIXPARALLEL permite llevar a la variable “Suma_Incr” la suma del valor de las variables THREADVAR “Incr” creada en cada Thread (en total 4 variables temporales).
  • La variable VAR “Suma_Incr” se puede utilizar fuera de la estructura FIXPARALLEL (lo que no se puede hacer con las variables THREADVAR “Incr” que sólo son operativas dentro de esta estructura).