Archive. Posts from 2004 to 2016, kept as they were written. My current blog is at dariuszparys.com.

Es gibt nun endlich eine Version des Parallel Extensions für das .NET Framework zum runterladen.

Das Paralellisieren von Daten und Aufgaben wird nun einfacher und ist zudem entweder deklarativ oder imperativ möglich. Hier ist ein Beispiel aus dem PLINQ Paket:

private static bool isValidISBN(string s)
{
    int digits = 0, check = 0;
    for (int i = 0; i < s.Length; i++)
    {
        if (s[i] == '-')
        {
            if (digits == 0 || digits == 10) return false;
        }
        else if (Char.IsDigit(s[i]) || s[i] == 'X')
        {
            if (++digits > 10) return false;
            if (s[i] == 'X' && digits != 10) return false;
            int val = ((s[i] == 'X') ? 10 : s[i] - '0');
            check = (check + (11 - digits) * val) % 11;
        }
        else
        {
            return false;
        }
    }

    return digits == 10 && check == 0;
}

Die Funktion isValidISBN prüft ob der übergebene String eine gültige ISBN Nummer ist. Diese Funktion wird nun in einer Schleife aufgerufen. Die Funktion, die das Sequentiell macht, sieht folgendermaßen aus:

public static int CountValidISBNsSequential(IEnumerable<string> source)
{
    return source.Where(s => isValidISBN(s)).Count();
}

Es handelt sich um eine Liste von Strings die entsprechend einzeln an isValidISBN() übergeben werden. Mit PLINQ hat man nun die Möglichkeit diesen Funktionsblock zu parallelisieren. Das ist recht trivial an dieser Stelle, schaut selbst:

public static int CountValidISBNsParallel(IEnumerable<string> source)
{
    return source.AsParallel().Where(s => isValidISBN(s)).Count();
}

AsParallel() kann nun einfach verwendet werden. Es handelt sich um eine Extension Method für IEnumerable<T> die ein IParallelEnumerable<T> zurückgibt. Die Ausführungszeiten zeigen das bei einer gewissen Anzahl Iterationen durchaus Geschwindigkeitsvorteile.

shot1

Ab 100.000 Iterationen lohnt es sich schon auf meiner Maschine, welche Prozessertechnisch gesehen eine Core2 Duo Kiste ist.

Wer also bisher keine großartige Lust gehabt hatte, sich mit dem Threading Modell in .NET herumzuschlagen, der sollte mal PLINQ anschauen, vielleicht ist es ja eine Alternative.