Bonjour à tous,


J'essaie d'optimiser un soft. J'ai grandement réussi à optimiser la partie SQL (MySQL et SQlite), mais en parallèle j'ai mis en place la capture des requêtes SQL.
Reprenant un logiciel existant avec peu d'information, j'essais de comprendre l'ancienne logique de synchronisation, qui ne semble pas top, puisqu'il y a parfois des pertes de données.

Bref, j'ai donc ajouté la capture des requêtes que j'écris dans un fichier texte. La 1er synchronisation contient prés de 5000 requêtes. Ajouter l'écriture dans le fichier texte en même temps ralentit vraiment beaucoup la synchro.

Ce que j'ai fait:

Je créé une list qui contient les requêtes, et d'un autre coté j'ai un timer à 1ms qui interroge la list, récupère et supprime le 1er de cette list, toutes les 100 requêtes ou lorsque la liste est vide je sauvegarde le fichier, le tout protégé par un sémaphore. pour éviter les collisions sur la list.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
        List<string> ListWrite;
        Semaphore Sem_SecureList = new Semaphore(initialCount: 1, maximumCount: 1, name: "Sem_SecureList");
        private void AddListWrite(Dictionary<int,string> Dic)
        {
            if (ListWrite == null) ListWrite = new List<string>();
            if (Dic.Count > 0)
            {
                Sem_SecureList.WaitOne();
                foreach (int key in Dic.Keys)
                {
                    if(Dic[key] != "")
                        ListWrite.Add(Dic[key]);
                }
                Sem_SecureList.Release();
            }
        }
        private string GetListWrite()
        {
            string ret = "";
            Sem_SecureList.WaitOne();
            if(ListWrite.Count > 0)
            {
                ret = ListWrite[0];
                ListWrite.RemoveAt(0);
            }
            Sem_SecureList.Release();
            return ret;
        }
        //Le timer que j'arrête et redémarre à chaque fois
        private void OnTimerLoop_Tick(object state)
        {
            TimerLoopStop();
            string line = GetListWrite();
            if (line != "")
            {
                WriteLogDebug(line);
 
            }else
            {
                if (sr != null)
                {
                    sr.Close();
                    sr = null;
                }
            }
            TimerLoopStart();
        }

Cela fonctionne bien, mais la partie écriture du texte est toujours très lente, ou du moins elle me "semble" anormalement lente. Au moins la partie SQL n'est pas affectée et va bien plus vite, c'est ce qui importe, car cette partie d'écriture du texte est là que pour du débogage et pour le moment mieux comprendre la synchronisation.

Je pensais à une limitation du basculement du sémaphore, mais cela bloquerais aussi le thread des requêtes SQL, ce qui n'est pas le cas.


Pour info, le traitement de la synchro dur (à la louche) 10 / 15 secondes pour la partie SQL, mais la partie texte cela dur bien 45 secondes, le fichier fait 1700ko à la fin de la lecture des trames de la 1ere synchro.


Pour lancer le débogage, le logiciel vérifie si un fichier texte est présent. Si ce fichier texte est présent, mais vide le débogage enregistre toutes les requêtes. Si ce fichier texte contient des lignes, il filtre et enregistre uniquement les requêtes qui contiennent ces lignes, ou si la ligne est précédé de ! il enregistre toutes les requêtes, sauf celle qui contiennent la ligne.

Comment optimiser cela? J'ai cherché sans rien trouver, ou je donne pas les bons termes.

Merci