Discussion :

[rocaldo]

bonjour,

je recherche de l'aide pour gerer x traitements listés dans une table (gerant les status de lancement)

ces traitements (Run) sont par lot (la cle est la societe)

actuellement on parallelise par 8 ou 10 (variable dans contexte)
(Tloop -> iterate (parametrer selon la variable) TRUNJOB )

pas du tout optimisé car il faut attendre que tous se finissent pour en relancer 8 (ou 10)

en le dev est foireux, il passe par 3 sous job pour reussir un semblant de boucle...

je cherche donc a pouvoir lancer un lot MAIS des des qu'un thread est terminé, il en reprenne un ...

ex :
Societe 1 run1 run2 run3 ... => fin => S5
S2 R1 R2 R3 R4 R5 => S6
S3 .....
S4 ....
...

la table est donc de type
job_id / nom(run) / societe / status / date


voila j'espere avoir ete clair

Merci bcp de votre aide

[DevNico]

Hello,

Je pars avec l'hypothèse que tu utilises la version TOS ?

Je n'ai pas vraiment compris comment tu gérais les lots...
Je comprends que tu as plusieurs traitements génériques que tu lances pour chaque société ?

Voici ce que je ferais techniquement :
Une source qui liste les sociétés à traiter (tFixedFlowInput ou fichier), avec un tFlowToITerate à la suite.
Suite à ce tFlowToIterate tu enchaînes les tRunJobs nécessaires (avec des onComponentOK), en passant en paramètre le code société que tu as récupéré du tFlowToIterate.
Et tu gères le parallélisme avec le flux Iterate qui sort du tFlowToIterate vers le premier tRunJob (tu peux gérer le niveau de parallélisme en variable de contexte).

Avec ce fonctionnement, les itérations s'enchaînent en utilisant le nombre de thread que tu as indiqué au niveau du flux iterate

Nicolas

[rocaldo]

merci de ta reponse rapide !!

mais je ne pense pas que ca reponde a ma problematique de "quand un iterate a fini" il en reprend un , il doit dans ton exemple certainement attendre son 1er lot nan ?



le insert :

select PARTITION_KEY, REPORTING_DATE, NAME, CONTEXT_ID, JOB_ID_FLC, SCENARIO_NAME, STATUS, START_TIME, END_TIME, NOMBRE_LANCEMENT FROM SUIVI

reporting_dat = mois
scenario_name = nom param du programme
context_id = entite

tu en x 10aine de nom ventilé sur x entite

donc il me faut une "boucle" sur les entites qui bouclent sur les scenario_name en parallélisant sur 8 canaux (jusqu'a epuisement des societes)
les scenario_name d'une meme entite sont obligatoirement lancé 1 par 1

ou alors dans ton exemple, y a plusieurs TrunJob ?

[rocaldo]

bonjour a tous

personne pour m'aider ?

Nico, ta solution va dans ce sens ou va me gerer des "lots" ?

Merci encore

Bonne semaine

[rocaldo]

Hello,

Je pars avec l'hypothèse que tu utilises la version TOS ?

Je n'ai pas vraiment compris comment tu gérais les lots...
Je comprends que tu as plusieurs traitements génériques que tu lances pour chaque société ?

Voici ce que je ferais techniquement :
Une source qui liste les sociétés à traiter (tFixedFlowInput ou fichier), avec un tFlowToITerate à la suite.
Suite à ce tFlowToIterate tu enchaînes les tRunJobs nécessaires (avec des onComponentOK), en passant en paramètre le code société que tu as récupéré du tFlowToIterate.
Et tu gères le parallélisme avec le flux Iterate qui sort du tFlowToIterate vers le premier tRunJob (tu peux gérer le niveau de parallélisme en variable de contexte).

Avec ce fonctionnement, les itérations s'enchaînent en utilisant le nombre de thread que tu as indiqué au niveau du flux iterate

Nicolas

peut etre pour etre plus claire ...

imaginons un repertoire avec x fichiers de x format de fichiers.

imaginons que ce dossier puissent s'agrandir pendant le traitement.

imaginons qu'il faut zipper differement selon le type de fichier

il faudrait que le job puisse lire la liste des fichiers de ce dossier => lancer en parallele (selon la variable de parallelisation) le programme zip avec en parametre le type de fichier et boucler pour chaque fichier de ce meme type

et que la boucle puisse s'agrandir si le dossier s'est agrandit

en gros que la boucle se gere selon le buffer du dossier

[rocaldo]

Hello,

Je pars avec l'hypothèse que tu utilises la version TOS ?

Je n'ai pas vraiment compris comment tu gérais les lots...
Je comprends que tu as plusieurs traitements génériques que tu lances pour chaque société ?

Voici ce que je ferais techniquement :
Une source qui liste les sociétés à traiter (tFixedFlowInput ou fichier), avec un tFlowToITerate à la suite.
Suite à ce tFlowToIterate tu enchaînes les tRunJobs nécessaires (avec des onComponentOK), en passant en paramètre le code société que tu as récupéré du tFlowToIterate.
Et tu gères le parallélisme avec le flux Iterate qui sort du tFlowToIterate vers le premier tRunJob (tu peux gérer le niveau de parallélisme en variable de contexte).

Avec ce fonctionnement, les itérations s'enchaînent en utilisant le nombre de thread que tu as indiqué au niveau du flux iterate

Nicolas

ah oui , c'est la version entreprise que j'ai .. je developpe en local et deploiement ensuite sur serveur ..