Alguien con WinXP y doble núcleo ó HT ....

Question

Alguien con WinXP y doble núcleo ó HT podría decirme que resultados le da este código:

Code Snippet

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace ConsoleApplication5
{
    class Contador
    {
        public static int Count;
    }

    class Program
    {
        delegate void modificavar_();

        static void Main(string[] args)
        {
            TimeSpan I;
            TimeSpan F;

            modificavar_ modificavar = new modificavar_(delegate() { Contador.Count++;});
            Contador.Count = 0;
            IAsyncResult ia=null;
            I = new TimeSpan(DateTime.Now.Ticks);
            for (int i = 0; i < 10000; i++)
                ia=modificavar.BeginInvoke(null, null);
            ia.AsyncWaitHandle.WaitOne();
            F = new TimeSpan(DateTime.Now.Ticks);
            Console.WriteLine("Resultado async: {0} en {1} milisegundos.", Contador.Count,F.Subtract(I).TotalMilliseconds);

            Contador.Count = 0;
            ThreadStart t = new ThreadStart(delegate() { Contador.Count++; });
            Thread T=null;
            I = new TimeSpan(DateTime.Now.Ticks);
            for (int i = 0; i < 10000; i++)
            {
                T = new Thread(t);
                T.Start();
            }
            T.Join();
            F = new TimeSpan(DateTime.Now.Ticks);
            Console.WriteLine("Resultado no-async: {0} en {1} milisegundos.", Contador.Count, F.Subtract(I).TotalMilliseconds);

            Console.ReadKey();
        }
    }
}

Resulta que estoy probando en un HT con Windows 2k, y sospecho que si la máquina tuviese windows XP (con mejor soporte SMP) no daría siempre 10000 si no que se perderían iteraciones. Al loro con el consumo de CPU  y tiempo requerido usando el modelo asíncrono y creando objetos Thread .... ThreadPool powa ! xD

Resultado async: 10000 en 1301,846 milisegundos.
Resultado no-async: 10000 en 54116,7368 milisegundos.


Gracias

Un saludo.

Answer 1

Con la combinación XP - HT los resultados son los siguientes:

 

Resultado async: 10000 en 966,2948 milisegundos.
Resultado no-async: 9989 en 99762,4662 milisegundos.

 

Salud!

 

Answer 2

Humm.. curioso que en modo asíncrono no pase, y es que creo que podría ó debería pasar pero gracias a ThreadPool es rapidísimo y no da tiempo xD Probaré luego a meter retardos a ver que sucede.

Gracias Toni

Un saludo.

Answer 3

Un placer.

Answer 4

Sin querer ser un aprovechado a ver si alguien ...

Code Snippet

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace ConsoleApplication5
{
    class Contador
    {
        public static int Count;
        public static readonly object o = new object();
    }

    class Program
    {
        static void Main(string[] args)
        {
            Test1();
            Test2();

            Console.WriteLine("\n\n FIN");
            Console.ReadKey();
        }

        static void Test1()
        {
            Console.WriteLine("\nSame thread");
            TimeSpan I;
            TimeSpan F;

            Contador.Count = 0;
            I = new TimeSpan(DateTime.Now.Ticks);
            for (int i = 0; i < 1000000; i++)
            {
                Interlocked.Increment(ref Contador.Count);
            }
            F = new TimeSpan(DateTime.Now.Ticks);

            Console.WriteLine("     Interlocked: {0} en {1} milisegundos.", Contador.Count, F.Subtract(I).TotalMilliseconds);

            Contador.Count = 0;
            I = new TimeSpan(DateTime.Now.Ticks);
            for (int i = 0; i < 1000000; i++)
            {
                lock (Contador.o)
                {
                    Contador.Count++;
                }
            }
            F = new TimeSpan(DateTime.Now.Ticks);

            Console.WriteLine("     Locked: {0} en {1} milisegundos.", Contador.Count, F.Subtract(I).TotalMilliseconds);
        }

        delegate void modificavar_();

        static void Test2()
        {
            Console.WriteLine("\nMultithreaded");
            TimeSpan I;
            TimeSpan F;

            modificavar_ modificavar = new modificavar_(delegate() { Interlocked.Increment(ref Contador.Count); });
            Contador.Count = 0;
            IAsyncResult ia = null;
            I = new TimeSpan(DateTime.Now.Ticks);
            for (int i = 0; i < 10000; i++)
                ia = modificavar.BeginInvoke(null, null);
            ia.AsyncWaitHandle.WaitOne();
            F = new TimeSpan(DateTime.Now.Ticks);
            Console.WriteLine("     Interlocked: {0} en {1} milisegundos.", Contador.Count, F.Subtract(I).TotalMilliseconds);

            modificavar = new modificavar_(delegate() { lock (Contador.o) { Contador.Count++; } });
            Contador.Count = 0;
            ia = null;
            I = new TimeSpan(DateTime.Now.Ticks);
            for (int i = 0; i < 10000; i++)
                ia = modificavar.BeginInvoke(null, null);
            ia.AsyncWaitHandle.WaitOne();
            F = new TimeSpan(DateTime.Now.Ticks);
            Console.WriteLine("     Locked: {0} en {1} milisegundos.", Contador.Count, F.Subtract(I).TotalMilliseconds);
        }
    }
}

Pretendo saber si son más rapidas las tecnicas de low-lock y cuanto

En este triste PC:


Same thread
     Interlocked: 1000000 en 0 milisegundos.
     Locked: 1000000 en 40,0576 milisegundos.

Multithreaded
     Interlocked: 10000 en 1271,8288 milisegundos.
     Locked: 10000 en 1301,872 milisegundos.


 FIN

Un saludo y gracias!!