Discussion :

[kurul1]

Bonjour à tous

Je viens de lire le tutorial sur les thread dans Borland C++ et cela m'a pas mal éclairé.

N'ayant jamais utilisé de thred, je ne sais pas comment faire pour mon application.

Je travaille avec des fichiers excel, j'extrait tout d'abord les données de ce fichier. Il contient plusieurs feuilles et dans chaques feuilles il y a plusieurs séries de données. Je stocke chaque série de données dans un objet (TCalculs qui est une classe de ma création), que j'ajoute dans une TList pour avoir accès à chaque série.

Ensuite pour chaque série, j'effectue des calculs et j'exporte les résultats dans un fichier Excel (Un fichier par série).

Mon problème est que les séries sont énormes et donc le traitement est super long.

Ce que j'aimarais faire, c'est utiliser des thread pour faire des calculs en parallèle sur plusieurs séries en même temps.

Ma question est, jusqu'à combien de thread peut-on créer simultanément. Je me doute que je ne vais pas en créer trop non plus d'un coup mais pour avoir un ordre d'idée.

Et deuxième question, Etant donnée que j'ouvre une instance d'excel pour l'écriture, est-ce que cela ne pause pas de problème d'en ouvrir plusieurs en même temps.

Merci d'avance pour votre aide.

[Altau]

Sans entrer dans les détails, je ne crois pas que ton projet de faire tourner en parallèle plusieurs threads gourmands apporte quelque chose, à moins de disposer d'un processeur multi-coeur ou de plusieurs processeurs. Le temps de traitement global sera le même, peut être même supérieur. L'intérêt d'utiliser des threads, à mon avis, est de garder la main pendant un traitement d'une certaine durée, surtout si cette durée n'est pas due essentiellement à une charge processeur.

[kurul1]

C'est ce que je pensais mais étant donné que mon traitement est super long même avec un double coeur puisque le PC sur lequel je développe en est un, je pensais pouvoir gagner du temps

Je vais quand même essayer juste pour voir.

Merci pour ta réponse.

[yarp]

Il n'y a pas de limite au nombre de thread que tu peux utiliser, un thread est un process donc la limite est combien de process gourmands ta machine peux supporter et aussi bien sur le gestionnaire de threads que tu doit écrire pour manager tout ça.

En ce qui concerne Excel je ne connais pas mais je sais que le modèle COM (rien à voir avec Excel à priori mais les 2 sont cousins, au moins en terme de lourdeur à besoin de messages pour certaines interfaces et étant donné que les threads de la VCL n'ont pas de boucle de message cela pose problème pour ces interfaces.
Peut-être en est-il de même avec Excel, peut-être pas, je te signale un pb potentiel.

J'ai aussi ce lien avec des classes de Thread très intéressantes pour Delphi/CBuilder:
http://www.midnightbeach.com/jon/pub.../MsgWaits.html
Plus évolués que le basic TThread, car justement avec message loop et aussi arrêt propre. Si tu commence avec TThread c'est mieux de partir de ça.

yarp
www.senosoft.com

[blondelle]

Salut kurul1:
yarp a raison quand il dit que Ole a une gestion lourde mais aussi lente, et il faut faire attention a l'optimisation du code, surtout dans les boucles comme par exemple dans le code qui suit, pour gagner du temps, on code qu'une fois la variable "vTable" le gain de temps est reellement important

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
    vTable = vMSword.OlePropertyGet("ActiveDocument").
    OleFunction("Range").OlePropertyGet("Tables").OleFunction("Item", 1);
    // 
    for(int i=0; i<nColCount; i++)
    {
    int nColWidth = GridCustomers->Columns->Items[i]->Width;
    vTable.OlePropertyGet("Columns").OleFunction("Item", i + 1)
    .OlePropertySet("PreferredWidthType", 3); // wdPreferredWidthPoints
    vTable.OlePropertyGet("Columns").OleFunction("Item", i + 1)
    .OlePropertySet("PreferredWidth", nColWidth);
    }

[kurul1]

Merci à vous pour toutes ces informations

[Neilos]

Il n'y a pas de limite au nombre de thread que tu peux utiliser, un thread est un process donc la limite est combien de process gourmands ta machine peux supporter et aussi bien sur le gestionnaire de threads que tu doit écrire pour manager tout ça.

Mouais il faut garder en tête qu'un thread consomme tout des mêmes des ressources. Et qui si tu en as trop tu perdras du temps à switcher entre tous les thread.

J'avais développé un petit moteur de lancé de rayon multi-thread. J'ai fait au plus simple :

1. détecter le nombre de CPU
2. créer un thread par CPU
3. forcer chaque thread à tourner sur un autre CPU

C'est à mon avis le seul moyen de bien exploiter les threads et ça marchais très bien !
Attention cependant à l'écriture dans les variables que les threads utilisent...elles sont à limiter au maximum car tu as besoin d'une semaphore dessus, ce qui peux bloquer un peu les threads...

[kurul1]

Je crois que je vais laisser tomber car vue toutes les contraintes que cela engendre, cela risque de ne pas être réalisable vue la configuration du mon exportation, et en plus, compliquer à mettre en oeuvre.

De plus les personnes qui vont utiliser le logiciel n'ont pas de Dual Core donc ca va pas servir a grand chose. Tant pis, ils patianteront.

Merci à tous pour votre aide.