Discussion :

[kurt225]

Bonjour,

J'ai un bout de code qui contient une Queue<Tuple<IPort, List<IPort>>>().

Au bout d'un certain temps, je me retrouve avec 2 millions d'items, ce qui sature la RAM.

Y aurait-il une possible optimisation ? Merci

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
 
 
            var m_Stacks = new Queue<Tuple<IPort, List<IPort>>>();
            m_Stacks.Enqueue(new Tuple<IPort, List<IPort>>(starting, new List<IPort>()));
 
 
            while (m_Stacks.Count > 0)
            {
                var args = m_Stacks.Dequeue();
                var cursor = args.Item1;
                var path = args.Item2;
 
                 if (dropIfAbsorbing && cursor.absorbing)
                {
                    _cntAbs = _cntAbs + 1;
                    continue;
                }
 
 
 
                path.Add(cursor);
 
                if (cursor.fum_activating || cursor.activating)
                {
                    //combined = string.Join("^", path.Select(i=>i.owner.name.ToString()));
                    combined = string.Join("^", path.Select(i => i.ToString()));
                    if (!list_visit.Contains(combined))
                    {
                        list_visit.Add(combined);
                        yield return path;
                    }
                }
 
 
 
 
                foreach (var topPort in topPorts(cursor))
                {
                    m_Stacks.Enqueue(
                        new Tuple<IPort, List<IPort>>(
                            topPort,
                            new List<IPort>(path)
                        )
                    );
                }

[Noxen]

Comment se fait-il que tu cumules 2 millions d'items sans jamais les vider ?

Sinon la première idée qui me vient c'est de ne pas tout garder en mémoire mais "dumper" une partie des items sur le disque, soit dans un fichier, soit dans une base de données.

[kurt225]

Comment se fait-il que tu cumules 2 millions d'items sans jamais les vider ?

Sinon la première idée qui me vient c'est de ne pas tout garder en mémoire mais "dumper" une partie des items sur le disque, soit dans un fichier, soit dans une base de données.

C'est une longue histoire haha. Disons que je dois parcourir des blocs, et ces ensembles de blocs forment des chemins et les possibilités de combinaisons pour ces chemins sont conséquentes.

Le code fonctionne bien, mais c'est juste niveau performance ou ça foire.

J'avais pensé à Sérialiser et à mettre le contenu de l'objet dans une base de donnée. Ensuite je mime le comportement de la Queue en faisant des accès à cette base, en désérialisant, en supprimant le premier item dans la base etc..

Mais le probleme, c'est que dans le Tuple à l'intérieur de la queue j'ai une List<IPort>. Cette liste peut atteindre 90 items.

Ca ne risque pas de poser probleme d'avoir 90 items multiplé par 2,000,000 ? le fichier risque d'être gros.

Tu en penses quoi ?

En tout cas merci pour l'aide