Silverlight, .NET Framework 4.0, Parallel, Performances, Linq, ASP.NET, Exception Handling, ASP.NET 4.0, Beta, Visual Studio 2010, MVC, OrangeDotNet, Windows 7, Eventi, Community, DotDotNet, Book, Review

L’utilizzo del Parallel Programming in .NET 4.0 va oltre a quanto già detto qui: di fatto all’interno del namespace System.Threading.Tasks esiste una classe Parallel che permette di effettuare cicli sfruttando più Threads, in modo da abbassare il tempo necessario all’iterazione.

Lo snippet seguente mostra un semplicissimo ciclo di 50 elementi con e senza il Parallel For, con risultati nettamente a vantaggio dell’istruzione Parallel.For.

static void Main(string[] args)
{
    Console.WriteLine("MTID={0}", Thread.CurrentThread.ManagedThreadId);

    ParallelMethod();
    NonParallelMethod();
    
    Console.WriteLine("\nFinished...");
    Console.ReadKey(true);
}

static void NonParallelMethod()
{
    Stopwatch sw = Stopwatch.StartNew();

    for (int i = 0; i < 50; i++)
    {
        Console.WriteLine("ThreadID={0}, i={1}", Thread.CurrentThread.ManagedThreadId, i);
        SimulateProcessing();
    }

    sw.Stop();

    Console.WriteLine("It Took {0} ms with simple for", sw.ElapsedMilliseconds);
}

static void ParallelMethod()
{
    Stopwatch sw = Stopwatch.StartNew();

    Parallel.For(0, 50, i =>
    {
        Console.WriteLine("ThreadID={0}, i={1}", Thread.CurrentThread.ManagedThreadId, i);

        SimulateProcessing();
    });

    sw.Stop();

    Console.WriteLine("It Took {0} ms with Parallel For", sw.ElapsedMilliseconds);
}

static void SimulateProcessing()
{
    Thread.SpinWait(80000000);
}

Dallo screenshot seguente è possibile capire come l’utilizzo del Parallel ci permette di sfruttare a meglio l’hardware a disposizione in quanto utilizza entrambi i processori, a differenza del classico ciclo for che ne sfrutta uno solo.

Ovviamente la classe Parallel non offre soltanto metodi per il ciclo for ma anche per il ForEach che funziona allo stesso modo, come mostrato di seguito:

static void ParallelForEach()
{
    int[] values = Enumerable.Range(1,50).ToArray();

    Parallel.ForEach<int>(values, i =>
    {
        Console.WriteLine("ThreadID={0}, i={1}", Thread.CurrentThread.ManagedThreadId, i);

        SimulateProcessing();
    });
}

Anche questo, come il precedente, resta un test dimostrativo della semplicità con cui si può sfruttare il Parallel Programming con il .NET Framework 4.0 e del fatto che i risultati ottenibili sono influenzabili dall’hardware che si ha a disposizione, numero di processori in primis.

Parallel.Ciauz()

This entry was posted on Tuesday, 27 October, 2009 and is filed under .NET . You can follow any responses to this entry through here . You can leave a response.

Il mio primo test della Beta 2 di Visual Studio 2010 non riguarda ASP.NET ma il mondo del Parallel Programming, e, nello specifico, del Parallel Linq, ossia la possibilità di utilizzare il Parallel Framework tramite la sintassi Linq.

L’utilizzo è semplicissimo e le prestazioni sono da paura se viene fatto un confronto con la stessa operazione ma senza l’utilizzo del Parallel. Ovviamente il test che riporto è banalissimo, ma serve a rendere l’idea di quanto semplice sia l’implementazione di Parallel Linq con il .NET Framework 4.0 e di che tipo di vantaggio si può trarre da un approccio di questo genere.

Come potete vedere dal codice seguente, l’unica differenza nella sintassi Linq è l’utilizzo dell’apposito Extension Method AsParallel() sull’oggetto da ciclare (Items in questo caso).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Parallel;
using System.Diagnostics;
using System.Threading;
using System.Collections;

namespace Imperugo.Test.ParallelLINQ
{
    class Program
    {
        private static IList items = new List();

        static void Main(string[] args)
        {
            PrepareData();

            ParalelTest();
            ClassicTest();

            Console.WriteLine("\nFinished...");
            Console.ReadKey(true);
        }

        private static void ParalelTest()
        {
            var results = from i in items.AsParallel() where i.SubValues.Contains(new Random(1000).Next()) select i;

            Stopwatch sw = Stopwatch.StartNew();
            IList resultsList = results.ToList();
            Console.WriteLine("{0} items", resultsList.Count());
            sw.Stop();

            Console.WriteLine("It Took {0} ms with parallel Linq", sw.ElapsedMilliseconds);
        }

        private static void ClassicTest()
        {
            var results = from i in items where i.SubValues.Contains(new Random(1000).Next()) select i;

            Stopwatch sw = Stopwatch.StartNew();
            IList resultsList = results.ToList();
            Console.WriteLine("{0} items with Linq", resultsList.Count());
            sw.Stop();

            Console.WriteLine("It Took {0} ms", sw.ElapsedMilliseconds);
        }

        static bool IsDivisibleByFive(int i)
        {
            return i % 5 == 0;
        }

        private static void PrepareData()
        {
            for (int i = 0; i < 1000000; i++)
            {
                var item = new DemoEntity
                                                {
                                                    Title = "New Title " + i,
                                                    SubValues = Enumerable.Range(1, 1000)
                                                };

                items.Add(item);
            }
        }
    }
}

Nel test è stata eseguita la stessa operazione due volte, una utilizzando il Parallel Linq (quadrato blu), ed una utilizzando Linq normalmente (quadrato rosso) su di una collection con 1.000.000 di elementi. I tempi richiesti per completare l’operazione sono ovviamente a vantaggio di Parallel Linq che conclude il ciclo con 9276 millisecondi, a differenza dei 16440 richiesti da Linq.

Un aspetto molto interessante può essere lo scenario di utilizzo. Di fatto, per poter trarre vantaggio dall’utilizzo di Parallel Linq lo si deve sfruttare in elementi corposi (nel test ho utilizzato una collection con 1.000.000 di elementi, ma i vantaggi si cominciano a percepire dai 50.000 elementi in poi), altrimenti si rischia di ottenere l’effetto opposto. Ovviamente incide molto anche il numero di processori che si hanno a disposizione.
I dati riportati sono relativi ad un portatile dual core in modalità balanced, ma la differenza si nota.

Ciauz.AsParallel()

This entry was posted on Monday, 26 October, 2009 and is filed under .NET . You can follow any responses to this entry through here . You can leave a response.

Non è passata neanche una settimana dall’uscita della Beta 2 di Visual Studio 2010 e sul sito Microsoft è già disponibile il Training Kit che include parecchio materiale, presentazioni, hands-in labs e demo.

Il materiale è bello corposo, sono 95 Mb che includono i seguenti argomenti:

• C# 4.0
• Visual Basic 10
• F#
• Parallel Extensions
• Windows Communication Foundation
• Windows Workflow
• Windows Presentation Foundation
• ASP.NET 4
• Windows 7
• Entity Framework
• ADO.NET Data Services
• Managed Extensibility Framework
• Visual Studio Team System

Il download è disponibile qui ed è basato sulla Beta 2 e, come potete vedere dall’elenco, non è presente del materiale su ASP.NET MVC 2, motivo per cui non potete mancare qui.

more to come...stay connected!

This entry was posted on Friday, 23 October, 2009 and is filed under .NET . You can follow any responses to this entry through here . You can leave a response.

Semplicemente wow!

Già dalla splash screen si capisce subito che Visual Studio ha fatto una bella virata rispetto ai predecessori (IMHO Vs2008 era il miglior tool di sviluppo in circolazione, dico “era” perchè vs2k10 vince già con la beta).
Comunque non solo la spash screen ha avuto un cambiamento, ma anche la home e l’icona hanno subito un restyling, come si suol dire, anche l’occhio vuole la sua parte.

Detto ciò un’altra novità che sale subito all’occhio sono le performances : decisamente più veloce rispetto alla Beta 1 che, aimé, era un po’ deludente da questo punto di vista, ma il team di VS ha saputo lavorare alla grande e portare la beta 2 ai livelli di Visual Studio 2008 RTM (vorrei sbilanciarmi ma non ho avuto modo di effettuare test approfonditi).

Purtroppo nella fase di setup ho avuto un errore durante l’installazione dei Silverlight 3 tools (probabilmente perchè li avevo già installati sulla macchina prima della Beta 2), ma la procedura si è conclusa ugualmente e sembra essere tutto perfettamente funzionante.
Confermo la presenza di ASP.NET MVC 2 Preview 2 e numerosi nuovi templates, tra cui SharePoint e Cloud Service, che dovrebbero essere una release indietro.

Purtroppo non ho avuto modo di effettuare dei veri e propri test sulle novità introdotte dalla Beta 2 del .NET Framework, a parte l’autoencode e l’ajax CDN (maggiori info rispettivamente qui e qui), ma sicuramente a breve ci saranno news, e magari qualcosa in più verso metà novembre :).

Sotto alcuni screenshots.

This entry was posted on Tuesday, 20 October, 2009 and is filed under .NET . You can follow any responses to this entry through here . You can leave a response.