Discussion :

[jacco]

Bonjour,

Je suis un vieux Pascalien et j'ai développé une application qui procède à l'analyse de séries temporelles. Dans le cadre de cette application je dois réaliser des calculs à l'aide de boucles imbriquées.
Ces calculs par définition répétitifs en nombre important entre 10⁶ et 10⁷ sont réalisés par un seul cœur et donc très couteux en temps. Je cherche donc à convertir mon application en Free POO de façon à réaliser un répartition multithreading des calculs.
Ma question est : Existe-t-il un logiciel qui me permettrait de convertir mon application en Free POO sans que j'ai à réécrire complètement 3200 lignes de code.

Merci pour vos conseils.

[Guesset]

Bonjour,

Le pascal objet est un pascal donc a priori qui peut le plus peut le moins...

Mais (il y a toujours un mais) la gestion de l'interface homme machine peut grandement différer d'un outil à l'autre. Ce n'est pas tant la couche objet que le changement de bibliothèques impliqué par le changement d'outils qui demande des adaptations parfois importantes.

Si l'application est avec une IHM minimaliste comme le mode console, ça peut tomber en marche sans rien faire (sinon croiser les doigts).

Dans les autres cas, si la couche présentation a été bien isolée du code fonctionnel le coût de migration devrait être assez limité. Mais si le code mélange allègrement présentation, traitement et accès aux données, la réécriture intégrale de l'équivalent de 3200 lignes sera plus rapide que la technique des petits pas qui sera plus longue et gardera la structure de programme qui pose problème.

Salutations

[jacco]

Bonjour M. Guesset,

Tout d'abord merci pour votre réponse et votre temps.
Je voudrais rajouter quelques éléments sur la nature de mon application qui est comme vous allez le voir, assez simple ce qui permettra j'espère, de préciser la solution optimale.
L'application de type FPC lie en entrée un fichier text de données assez volumineuses de 100000 A 500000 lignes. Ce fichier est stocké en mémoire et réaccéder à l'aide d’une variable de type pointeur.
n calculs sont effectués en parcourant le fichier (10⁶ < n < 10⁷) faisant intervenir plusieurs fonctions et procédures de type Pascal standard.
Dans l'état actuel de l'application n est le produit 3 boucles imbriquées. Apres chaque calcule si le résultat rempli certaines conditions il est stocké dans un fichier text (il y a très peu de résultats qui satisfont les conditions donc peu d'écritures (entre 1 et 10).
Ce qui serait souhaitable dans un premier temps c'est de paralléliser les calculs contrôles par la boucle la plus interne par le jeu d'un index a l'aide par exemple d'une procédure telle que
procedure DoSomethingParallel(Index: PtrInt; Data: Pointer; Item: TMultiThreadProcItem); ou l'index evidemment controlerait la boucle.
Mais dès que j'introduis ce type de POO il me semble que le compilateur va hurler car les calculs de la boucle utilisent évidemment mes fonctions et procédures Pascal standard mentionnées plus haut ...
Voilà merci pour votre conseil sur la base de ces nouveaux éléments. (surtout s’il y a une possibilité d’éviter la réécriture complète)

[Guesset]

Bonjour,

Apparemment, Si je comprends bien, la POO ne serait utile que pour gérer les threads. Il n'y aurait donc pas une réécriture complète.

C'est un programme en mode console (ligne de commande) ? Sinon il y a de forte chance qu'il utilise nombre de composants qui sont des instanciations d'objets. Auquel cas vous faites déjà de la POO sans le savoir

L'histoire d'un pointeur m'interpelle. Cela évoque un traitement purement séquentiel car c'est le domaine d'excellence des pointeurs. Or le parallélisme suppose qu'il est possible de découper en traitements décorrélés. Est-ce le cas ?

Il faudrait voir le code pour se faire une idée (au moins les trois boucles).

Salutations

[jacco]

Bonjour POO,

Tout d'abord merci pour la réponse.
Oui effectivement il y a des instanciations d'objets dans mon programme.
Par ailleurs le pointeur fait effectivement référence a une lecture séquentielle d'un fichier texte. Mais le découpage se ferait au niveau des paramètres d'optimisation sur lesquels je fais une recherche par balayage. Donc l'idée serait de découper/repartir la boucle extérieure sur n cœurs / threads et on pourrait même pousser plus loin et faire un découpage de 2eme et 3eme niveau pour les boucles internes.
D'où la question : pour ceci dois-je réécrire la totalité de mon pgm ?
(Un bon nombre d'instanciations objets sont évidemment en dehors des 3 boucles).

Bien cordialement,

[Guesset]

Bonjour,

La réécriture devrait se limiter à celle des boucles pour tirer partie du parallélisme. Mais cette réécriture sera d'autant plus difficile si les boucles actuelles ne sont pas intrinsèquement indépendantes (par exemple, si l'itération i+1 d'une boucle dépend de l'itération i, alors ces deux itérations ne peuvent être parallélisées en l'état).

Il n'est pas nécessaire de multiplier les threads à outrance. Pour une machine à n cœurs, le nombre de threads devrait être limité entre n et 1.3 n (si SMT ou HT) au delà il n'y aura pas de gain voire même une légère diminution de performances.

Salutations