J'ai un processus qui fonctionne sur un grand ensemble de données, traitant les enregistrements dans un Parallel.ForEach
puis stockant les résultats dans un ConcurrentQueue<List<string>>
. Un enregistrement est donc traité et chaque champ de l'enregistrement génère une chaîne, qui est ensuite ajoutée au List
. A la fin de l'enregistrement, List
est alors Enqueued
, et un traitement supplémentaire est effectué sur le ConcurrentQueue
contenant tous les enregistrements traités. Après quelques heures de traitement de l'ensemble, j'ai remarqué que mon utilisation du processeur est passé d'une nouvelle vague à rester assez élevé, et le temps de traiter un groupe d'enregistrements commence à croître.Une collection évolutive pour un grand ensemble de données indéterminé
Mon hypothèse ici est que le List
est rempli à capacité, puis copié dans un nouveau plus grand List
. Au fur et à mesure que la taille du processeur augmente, le cycle d'initialisation augmente. L'ensemble de données sur lequel je travaille est de taille indéterminée, en ce sens que chaque enregistrement a un nombre variable d'enregistrements enfants. Le nombre d'enregistrements parent est généralement de l'ordre de 500k. Donc, ma première pensée est d'initialiser le List
au Count
des enregistrements parent. Le List
devrait encore croître en raison des dossiers des enfants, mais il devrait au moins croître moins souvent. Mais existe-t-il d'autres alternatives de collection à List
qui évolue mieux? Ou une approche différente de mon premier instinct qui me semble meilleur?
Bon à savoir sur la ConcurrentQueue. Je vais vérifier les pourboires sur les cordes elles-mêmes (ceci est une base de code que je viens de mettre en place maintenant qu'il est en difficulté). Le réglage de la capacité sur la liste est définitivement faisable, car le nombre de champs est statique entre les enregistrements. – bcwiniger
Dans ce cas, utilisez un tableau par enregistrement au lieu d'une liste (est légèrement plus rapide) –