5.3 Découverte du flot de contrôle
5.3.2 Découverte des dépendances élémentaires
5.3.2.3 Découverte des dépendances indirectes
À cause du comportement concurrentiel, l'exécution d'une activité pourrait ne pas dépendre
de son prédécesseur immédiat dans l'
EventStream, mais elle pourrait dépendre d'autres activités
qui la précèdent indirectement. Par exemple dans l'
EventStream1 donné dans le tableau 5.1, la
terminaison de VD arrive entre ER et MJR. Par conséquence, ER ne se termine pas toujours juste
avant MJR dans les traces d'exécutions du workow. Ainsi, nous avonsP(M JR/ER) = 0.67qui
présente une fréquence de dépendance sous estimée. En fait, la bonne valeur doit être égale à 1
parce que l'exécution de MJR dépend exclusivement de ER. De même, les valeurs en gras dans
la TDS initiale rapportent un comportement similaire à ce que nous venons de décrire.
Définition 5.4 (Fenêtre d'activités concurrentes)
Une fenêtre d'activités concurrentes dénit une tranche (intervalle) d'événements dans un
EventS-treamS : stream (bStream, eStream, sLog, workowocc). Formellement, on dénit la fenêtre de
concurrence comme un triplet window(wLog, bWin, eWin) :
(bWin :
TimeStamp) et (eWin :
TimeStamp) sont les moments de début ou de n de la fenêtre
(avec bStream≤bWin et eWin ≤eStream)
wLog⊂ sLog et∀e : event ∈S.sLog où bWin ≤e.TimeStamp≤eWin⇒ e ∈wLog.
Nous dénissons la fonction width(window) qui retourne la taille de la fenêtre d'activités
concur-rentes window.
Entrées : T DSM : Table de dépendances statistiques marquées
Sorties : TTFC : la table de tailles des FAC
Données : T DSM
size: int ;
début
1
T DSM
size= Size-tab(TDSM) ; /*retourne la taille de TDSM*/
2
pour int i=0 ; i<T DSM
size; i++ ; faire
3
ACWT[i]=1 ;
4
pour int i=0 ; i<T DSM
size; i++ ; faire
5
pour int j=0 ; j<T DSM
size; j++ ; faire
6
si TDSM[i][j] =-1 alors
7TTFC[i]++ ;
8TTFC[j]++ ;
9pour int k=0 ; k<T DSM
size; k++ ; faire
10
si TDSM[k][i] >0 alors
11TTFC[k]++ ;
12n
13Algorithme 2 : Calcul de la taille de la fenêtre de Concurrence
Pour découvrir ces dépendances indirectes, nous spécions la notion de fenêtre d'activités
concurrentes (c.f. dénition 5.4). Une fenêtre d'activités concurrentes (FAC) est liée à l'activité
correspondant à son dernier événement et couvre les événements des activités qui la précédent
directement et indirectement. Au début, la largeur de la FAC d'une activité est égale à 1. Chaque
fois que cette activité est en concurrence avec une autre activité nous ajoutons 1 à la taille de
la fenêtre. Si cette activité n'est pas en concurrence avec d'autres activités et a des activités
concurrentes qui la précédent, alors nous ajoutons leur nombre à la taille de sa FAC. Par exemple,
l'activité RD est en concurrence avec VD alors la largeur de sa FAC est égale à 2. Se Basant sur
ceci, l'algorithme 2 calcule pour chaque activité la taille de FAC qui les regroupe dans la table
de tailles des FAC (TTFC) qui indique pour chaque activité la taille de sa FAC. Cet algorithme
scanne la TDS marquée, calculée dans la dernière section, et met à jour TTF en fonction du
comportement concurrentiel.
Ensuite, nous procédons par une partition (c.f. gure 5.3) de chaque
EventStreamqui construit
un ensemble de fenêtres se chevauchant partiellement en se basant sur la TTFC. La dénition
5.5 spécie que chaque fenêtre partage l'ensemble de ses éléments avec la fenêtre qui la précède
sauf le dernier événement qui contient l'activité référence de la fenêtre.
Définition 5.5 (Partition)
Une partition construit un ensemble de fenêtres qui se chevauchent partiellement au dessus d'un
EventStream
.
Partition :
WorkflowLog→ (
Window)*
S :
EventStream(sLog, workowocc, bStream, eStream)→ {w
i:
Window; 0≤i<n} :
w
1.bWin = bStream andw
n.eWin = eStream,
∀w : window ∈ partition, e :
Event= le dernier événement dans w, width(w)=
ACWT[e.ActivityID],
∀0≤i<n ;w
i+1.wLog - {le dernier événement e :
Eventdansw
i+1.wLog}⊂w
i.wLog∧w
i+1.wLog
6
= w
i.wLog.
Dans le schéma 5.6, nous avons appliqué une partition au-dessus de l'
EventStream2 du tableau
5.1. Par exemple, la taille de la FAC de VD est égale à 4 parce que cette activité est en concurrence
avec trois activités précédentes en concurrenceAE,V SC etRD. Et, la taille de la FAC deRD
est égale à 2 parce que cette activité est en concurrence seulement avec V D. Notons que pour
chaque activité dans cet
EventStreamson FAC lui permet de couvrir toutes, et seulement toutes,
les activités qui sont dans ses pré-conditions d'exécution.
Figure 5.6 Une partition d'
EventStreamFinalement, l'algorithme 3 calcule la TDS nale. Pour chaque FAC, il calcule pour sa dernière
activité les fréquences des activités qui la précèdent. La TDS nale est calculée en divisant les
entrées de chaque rangée par la fréquence de l'activité qui lui est relative.
Maintenant, en appliquant ces algorithmes, nous pouvons calculer la TDS nale (c.f. tableau
5.3) qui sera utilisée dans la section suivante pour découvrir les patrons de workow.
Notons que notre approche s'adapte dynamiquement au comportement concurrentiel, à travers
la taille du FAC. En eet, cette taille est sensible au comportement concurrentiel : elle augmente en
cas de concurrence et elle est neutre (égale à 1) en cas d'absence de comportement concurrentiel.
Entrées : Wlog :
WorkflowLog;
# : Table d'occurrences des activités ;
T DSM : Table de dépendances statistiques marquées ;
Sorties : T DSM F :Table de dépendances statistiques nale
Données : a
ref erence: int ;
a
preceded: int ;
fWin :
window;
depFreq :int[][] ; /*initialisé à 0 ;*/
freq :int ;
début
1
T DSM
size= Size-tab(TDSM) ;
2
pour tout win :window dans partition(Wlog) faire
3
a
ref erence= last-activity(win) ; /* la fonction last-activity renvoie la dernière
4
activité du dernier événement de win*/ win = preceded-events(win) ; /* la
fonction last-activity renvoie win sans le dernier événement*/
pour int i=0 ; i<T DSM
size; i++ ; faire
5
a
preceded= e.activityId ; si TDSM[a
ref erence, a
preceded]>0 alors
6
depFreq[a
ref erence,a
preceded]++ ;
7
/*dernière étape : construction de la table de dépendances nale */
8
pour int t
ref=0 ; t
ref<T DSM
size; t
ref++ ; faire
9
pour int t
pr=0 ; t
pr<T DSM
size; t
pr++ faire
10
T DSM F[t
ref,t
pr]= T DSM[t
ref,t
pr]/#t
ref;
11
n
12
Algorithme 3 : Calcul de la table de dépendances nale
Ainsi, notre algorithme adapte son comportement au contexte concurrent. Cette stratégie
permet l'amélioration de la complexité de l'exécution et du temps d'exécution de l'algorithme
par rapport à une approche similaire de découverte de patrons fréquents [MTV97] qui utilise une
taille xe de la fenêtre de concurrence.
P(x,y) STP VSC ER MJR AE RP RD VD LD
STP 1 0 0 0 0 0 0 -1 0
VSC 0 1 0 0 0 0 0 -1 0
ER 0 0 1 0 0 0 0 -1 0
MJR 0 1 0 0 0 0 0 -1 0
AE 0 1 0 0 0 0 0 -1 0
RP 0 1 0 0 0 0 0 -1 0
RD 0 0 0 0.58 0.23 0.19 0 -1 0
VD 1 -1 -1 -1 -1 -1 -1 0 0
LD 0 0 0 0 0 0 1 1 0
#ST P = #V SC= #V D= #RD= #LD= 100
#ER= #M JR= 69; #AE = 21;#RP = 10
Dans le document
La Découverte de Workflow<br />Transactionnel pour la Fiabilisation des<br />Exécutions
(Page 106-109)