Quelquepart

Blog d'un consultant SAP

Vous êtes ici : Accueil>Général

Général

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

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

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 !

Migration BW3 - BI7 : vous reprendrez bien un peu de hash ?

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

Ce matin, j’étais tranquillement en train de m’occuper de ma migration, quand tout à coup l’un de mes chargements dump. Je suis interloqué car le dump apparait lorsque je lance l’infopackage, sur le mode actif. Pas en background comme cela arrive habituellement.

Log du dump :

Category : ABAP Server Resource Shortage
Runtime Errors : TSV_TNEW_PAGE_ALLOC_FAILED

What happened?
You attempted to extend an internal table, but the required space was not available.

Information on where terminated
Termination occurred in the ABAP program "SAPLRSSM_LOAD" - in "RSSM_RSSELDONE_READ". 
The main program was "RSAWBN_START ". 
In the source code you have the termination point in line 245 of the (Include) program "LRSSM_LOADU08".

Allant voir plus loin dans le log je me rend compte que le dump survient sur un select avec des conditions dynamiques.

Me voici donc partit pour débugger le tout. J’arrive rapidement à trouver la valeur des paramètres et après un petit tour dans SE16, je suis catastrophé. 6.8 millions d’entrées correspondent à cette sélection. Voici donc pourquoi le chargement dump. Ca fait un peu beaucoup de lignes à mettre dans une table interne...

En revanche j’ai du mal à m’expliquer pourquoi SAP fait ce chargement. La table RSSELDONE contient les paramètres de chargement de toutes les requests. Quel intérêt d’aller charger en mémoire tout l’historique des paramètres de sélection sur ma source ???

Après arrachage de poignées de cheveux et traitage de noms d’oiseaux des développeurs de Waldorf, j’ai fini par comprendre. SAP a ajouté un hash code dans cette table. Il n’était pas présent sur la version 3.x et se trouve dans la 7.x. Dès qu’on fait un chargement en BI7.x, le hash code correspondant est généré et stocké dans RSSELDONE. Mais quid des entrées 3.x lors d’une migration ? Et bien SAP a décidé que le PREMIER CHARGEMENT serait le parfait moment pour générer LA TOTALITE des hash code de chargement de la source correspondante !

Bon c’est bien, je sais maintenant pourquoi ca dump, mais ça ne m’aide pas à corriger. J'ai fini par trouver un programme standard qui permet de générer les hash code : RSSM_HASH_ENTRIES_CREATE. Malheureusement il a probablement été écrit par un stagiaire... son temps d'exécution est très très très (trop) long. Aussi, pour les besoins du projet, j'ai du faire une version light qui appelle directement la fonction standard de génération de hash, sans appeler des tonnes de fonctions inutiles autour...

2h plus tard, j’ai pu relancer mon infopackage qui a chargé sans problème mes données. Affaire classée !

Au cas où cette mésaventure vous arrive, voici le programme dont je me suis servi.

Télécharger le programme correctif

Afficher un ALV objet sans créer d'écran (screen painter)

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

Lassé de créer un écran ne contenant qu'un custom control, avec PBO et PAI rachitiques uniquement pour afficher votre grid ALV objet ? La classe cl_gui_container contient nativement des attributs qui permettent de s'en passer ! Encore faut-il le savoir, ce qui est maintenant votre cas ;-)
En effet, au lieu de créer tout d'abord un objet container puis d'indiquer cet objet en parent de l'objet alv, utilisez directement cl_gui_container=>screen0 comme parent pour votre ALV !

PROGRAM test.
DATA : o_alv      TYPE REF TO cl_gui_alv_grid,
       t_sflight  TYPE TABLE OF sflight.

* Definition d'un écran de sélection vide
SELECTION-SCREEN : BEGIN OF SCREEN 1001,
                   END OF SCREEN 1001.

* Remplissage de la table de données pour l'ALV
SELECT * FROM sflight INTO TABLE t_sflight.

* Creation de l'objet alv directement rattaché au premier screen
CREATE OBJECT o_alv
  EXPORTING
    i_parent = cl_gui_container=>screen0.

* Passage des données a l'ALV
CALL METHOD o_alv->set_table_for_first_display
  EXPORTING
    i_structure_name = 'SFLIGHT'
  CHANGING
    it_outtab        = t_sflight.

* Affichage de l'écran, l'ALV apparait !
CALL SELECTION-SCREEN 1001.

Cette astuce améliore au passage la portabilité de votre code (pas de screen/status/title à gérer).

Astuce Search-help standard SAP

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

Pour accéder rapidement à une liste de valeur pour une aide à la recherche, il est possible d'utiliser une syntaxe particulière directement dans le champ.
Par exemple sur l'écran d'accueil de SU01, dans le champs User, saisir =...seb puis entrée affichera la liste de tous les utilisateurs dont le prénom commence par "seb".

La syntaxe est la suivante :

  • Commencer par =
  • Ajouter autant de points que la position du champ de recherche a remplir dans le match code
  • Saisir le texte recherché
  • Appuyer sur entrée

Dans l'exemple "=...seb", les 3 points indiquent d'utiliser le 3e champ, donc le prénom

Cette astuce fonctionne avec la plupart des champs standards SAP. Il est également possible de faire une recherche sur plusieurs champs en les enchainant. =...seb.dir pour rechercher tous les "seb*" du département "dir*"

Performances et boucles imbriquées

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

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