Quelquepart

Blog d'un développeur ABAP

Vous êtes ici : Accueil>Mots clés>performances

performances

Activation de DSO un peu longue ? Quelques conseils...

Rédigé par Sébastien Hermann dans Général -

Un DSO (ou ODS pour BW3.x) qui s'active en 5 minutes, un autre avec la même volumétrie qui met plus de 2 heures... Ca ne vous est jamais arrivé ?

Voici quelques pistes pour essayer de résoudre ce problème.

  • En premier lieu, même si ca peut sembler une évidence, s'assurer que les statistiques de l'ODS sont bien à jour (transaction DB20).
  • Si cet ODS n'est pas utilisé pour le reporting, s'assurer que le flag "Reporting Bex" est décoché (ou l'option "SID Generation" n'est pas sur "during activation" en BI7). Dans le cas contraire, BW profite de l'activation des données pour générer/vérifier les SID de toutes les masterdata utilisées, ce qui peut prendre beaucoup de temps !
  • L'activation peut être longue si les tables de batch sont trop grosses car elles sont utilisées lors de l'activation. Pour s'en assurer il suffit de compter le nombre d'entrées sur la table TBTCO via SE16. Si plus de 100 000 entrées sont trouvées, il est conseillé de nettoyer ces tables via le programme RSBTCDEL2 (tcode SM65). Les admins sont sensés être au courant de cette procédure.
  • En dernier lieu, il est aussi possible de faire quelques ajustements de paramétrage des ODS, via la transaction RSODSO_SETTINGS. Ces ajustements peuvent être globaux pour le serveur ou restreint au seul ODS concerné. Cette transaction n'est accessible que sur SAP BI7.x. En version BW3.x, une version primitive existe toutefois : RSCUSTA2, mais elle ne permet que des réglages globaux.
    A noter : Il est aussi possible de modifier le nombre de processus en parallele pour l'activation directement depuis la variante dans la process chain (bouton "parallel processing")

Si les problèmes persistent, alors une analyse plus poussée sera nécessaire. La note OSS 1392715 pourra alors s'avérer utile. Bon courage dans votre chasse aux performances !

Performances et boucles imbriquées

Rédigé par Sébastien Hermann dans Général -

Je suis régulièrement sollicité pour résoudre des problèmes de performance sur des reports ou des interfaces.
En premier lieu, j'analyse les requêtes SQL, puis je vérifie la manière dont l'algorithme de traitement des données est implémenté.

Parmi les erreurs les plus classiques, on retrouve la gestion des boucles imbriquées. Prenons un exemple.
Nous voulons lister des données imputation de commande d'achat.
Une première table interne t_ekko contient les données d'en-tête (1000 commandes). Une seconde t_epko contient les données de poste (10 postes par commande = 10 000 postes). Une 3e t_ekkn contient les données imputations (2 imputations par poste = 20 000 imputations).
La manière simple (et anti performante) d'écrire le traitement serait :

LOOP AT t_ekko.
  LOOP AT t_ekpo WHERE ebeln = t_ekko-ebeln.
    LOOP AT t_ekkn WHERE ebeln = t_ekko-ebeln AND ebelp = t_ekpo-ebelp.
*     traitement imputation
    ENDLOOP.
*   traitement poste
  ENDLOOP.
* traitement commande
ENDLOOP.

Si cette syntaxe est rapide à écrire et simple à relire, elle présente l'inconvénient majeur que le LOOP AT txx WHERE fait un "full scan" de la table interne. Chaque ligne sera lue par le moteur pour voir si elle correspond aux critères WHERE.
Ainsi pour un report sur 1000 commandes, ayant chacune 10 postes avec 2 imputations, la table t_ekkn (20 000 entrées) est parcourue 10 000 fois, soit 200 millions de lignes lues !

Pour ce genre de tables, la lecture peut etre synchronisée entre les 3 tables via l'utilisation d'index

DATA : l_index_ekpo TYPE i,
       l_index_ekkn TYPE i.

SORT t_ekko BY ebeln.
SORT t_ekpo BY ebeln ebelp.
SORT t_ekkn BY ebeln ebelp.

LOOP AT t_ekko.
  LOOP AT t_ekpo FROM l_index_ekpo.
    IF t_ekpo-ebeln > t_ekko-ebeln.
      l_index_ekpo = sy-index.
      EXIT.
    ELSEIF t_ekpo-ebeln < t_ekko-ebeln.
       CONTINUE.
     ELSE.
       LOOP AT t_ekkn FROM l_index_ekkn.
         IF t_ekkn-ebeln > t_ekko-ebeln
        OR ( t_ekkn-ebeln = t_ekko-ebeln AND t_ekkn-ebelp > t_ekpo-ebelp ).
          l_index_ekpo = sy-index.
          EXIT.
        ELSEIF t_ekpo-ebeln < t_ekko-ebeln
        OR ( t_ekkn-ebeln = t_ekko-ebeln AND t_ekkn-ebelp < t_ekpo-ebelp ).
          CONTINUE.
        ELSE.
*         traitement imputation
        ENDIF.
      ENDLOOP.
*     traitement poste
    ENDIF.
  ENDLOOP.
* traitement commande
ENDLOOP.

Grâce aux index, chacune des 3 tables n'est parcourue qu'une seule fois, minimisant ainsi au maximum le travail de lecture du moteur ABAP. (soit 30 000 lignes lues pour t_ekkn [Les 2 lignes d'imputations + la première ligne d'imputation du poste suivant])
Néanmoins cette solution présente l'inconvénient d'être assez indigeste (peu lisible) et peut facilement introduire des bugs si elle est mal maitrisée. De plus, il faut que les 3 tables soient triées selon le même axe, ce qui n'est pas forcément possible dans tous les cas.

Aussi il existe une méthode intermédiaire, largement utilisée par SAP. Il s'agit de faire une recherche de la première ligne répondants aux critères, puis une lecture directe par index.

DATA : l_index_ekpo TYPE i,
       l_index_ekkn TYPE i.

SORT t_ekpo BY ebeln.
SORT t_ekkn BY ebeln ebelp.

LOOP AT t_ekko.
  READ TABLE t_ekpo WITH KEY ebeln = t_ekko-ebeln
                    BINARY SEARCH
                    TRANSPORTING NO FIELDS.
  IF sy-subrc = 0.
    l_index_ekpo = sy-tabix.
    LOOP AT t_ekpo FROM l_index_ekpo.
      IF t_ekpo-ebeln NE t_ekko-ebeln.
        EXIT.
      ENDIF.
      READ TABLE t_ekkn WITH KEY ebeln = t_ekko-ebeln
                                 ebelp = t_ekpo-ebelp
                        BINARY SEARCH
                        TRANSPORTING NO FIELDS.
      IF sy-subrc = 0.
        l_index_ekkn = sy-tabix.
        LOOP AT t_ekkn FROM l_index_ekkn.
          IF t_ekkn-ebeln NE t_ekko-ebeln OR t_ekkn-ebelp NE t_ekpo-ebelp.
            EXIT.
          ENDIF.
*         traitement imputation
        ENDLOOP.
      ENDIF.
*     traitement poste
    ENDLOOP.
  ENDIF.
* traitement commande
ENDLOOP.

Un peu moins performante que la syntaxe précédente, cette manière est néanmoins un peu plus simple à écrire (et à relire/comprendre).
Le read table binary search est très performant (recherche dichotomique). Pour t_ekkn contenant 20 000 entrées, seulement 14 lignes sont lues pour trouver la bonne entrée. Le moteur va donc lire 170 000 lignes sur t_ekkn au total (14 pour trouver l'imputation + 2 imputations + la première imputation du poste suivant).

Méthode Lignes t_ekkn parcourues Complexité
Loop at ... where 200 000 000 Simple
Loop from index 30 000 Complexe
Read table + Loop from index 170 000 Moyenne