Lire et traiter des fichiers en parallèle C #

On dirait les performances de votre application est principalement limitée par IO. Cependant, vous avez encore un peu de CPU de travail dans votre code. Ces deux bits de travail sont interdépendants: votre CPU de travail ne peut pas démarrer jusqu'à ce que l'OI a fait son travail, et l'OI ne pas passer à côté de l'élément de travail jusqu'à ce que votre PROCESSEUR a fini avec la précédente. Ils sont à la fois tenant les uns les autres. Par conséquent, il est possible (expliqué au bas de l'écran) que vous verrez une amélioration de débit si vous effectuez votre IO - et le CPU travailler en parallèle, comme suit:

void ReadAndProcessFiles(string[] filePaths)
{
//Our thread-safe collection used for the handover.
var lines = new BlockingCollection<string>();
//Build the pipeline.
var stage1 = Task.Run(() =>
{
try
{
foreach (var filePath in filePaths)
{
using (var reader = new StreamReader(filePath))
{
string line;
while ((line = reader.ReadLine()) != null)
{
//Hand over to stage 2 and continue reading.
lines.Add(line);
}
}
}
}
finally
{
lines.CompleteAdding();
}
});
var stage2 = Task.Run(() =>
{
//Process lines on a ThreadPool thread
//as soon as they become available.
foreach (var line in lines.GetConsumingEnumerable())
{
String pattern = "\\s{4,}";
foreach (String trace in Regex.Split(line, pattern))
{
if (trace != String.Empty)
{
String[] details = Regex.Split(trace, "\\s+");
Instruction instruction = new Instruction(details[0],
int.Parse(details[1]),
int.Parse(details[2]));
Console.WriteLine("computing...");
instructions.Add(instruction);
}
}
}
});
//Block until both tasks have completed.
//This makes this method prone to deadlocking.
//Consider using 'await Task.WhenAll' instead.
Task.WaitAll(stage1, stage2);
}

Je doute fortement que c'est ton CPU à travailler tenir les choses en place, mais si cela arrive à être le cas, vous pouvez également paralléliser étape 2:

    var stage2 = Task.Run(() =>
{
var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount };
Parallel.ForEach(lines.GetConsumingEnumerable(), parallelOptions, line =>
{
String pattern = "\\s{4,}";
foreach (String trace in Regex.Split(line, pattern))
{
if (trace != String.Empty)
{
String[] details = Regex.Split(trace, "\\s+");
Instruction instruction = new Instruction(details[0],
int.Parse(details[1]),
int.Parse(details[2]));
Console.WriteLine("computing...");
instructions.Add(instruction);
}
}
});
});

Rappelez-vous, si votre CPU de travail est négligeable par rapport à la IO composant, vous ne verrez pas beaucoup de vitesse. Plus encore la charge de travail est, au mieux le pipeline va effectuer en comparaison avec le traitement séquentiel.

Puisque nous parlons de la performance note que je ne suis pas particulièrement enthousiasmé par le nombre d'appels de blocage dans le code ci-dessus. Si je faisais ça dans mon projet, je serais allé la async/await route. J'ai choisi de ne pas le faire dans ce cas car je voulais garder les choses faciles à comprendre et facile à intégrer.

Essayer le traitement de l'lignes en parallèle à la place. Par exemple:

var q = from file in files
from line in File.ReadLines(file).AsParallel()    //for smaller files File.ReadAllLines(file).AsParallel() might be faster
from trace in line.Split(new [] {"    "}, StringSplitOptions.RemoveEmptyEntries)  //split by 4 spaces and no need for trace != "" check
let details = trace.Split(null as char[], StringSplitOptions.RemoveEmptyEntries)  //like Regex.Split(trace, "\\s+") but removes empty strings too
select new Instruction(details[0], int.Parse(details[1]), int.Parse(details[2]));
List<Instruction> instructions = q.ToList();  //all of the file reads and work is done here with .ToList

L'accès aléatoire à un non-disque dur SSD (lorsque vous essayez de lire/écrire des fichiers différents en même temps ou un fichier fragmenté) est généralement beaucoup plus lent que l'accès séquentiel (par exemple, lecture unique la défragmentation de fichiers), donc j'attends de traitement de fichier unique en parallèle pour être plus rapide avec des fichiers défragmentés.

Aussi, le partage des ressources entre les threads (par exemple, la Console.Écrire ou en ajoutant un "thread-safe" le blocage de la collection) peuvent ralentir ou bloquer/blocage de l'exécution, parce que certains des fils va avoir à attendre pour les autres threads pour accéder à cette ressource.