none
Alguien con WinXP y doble núcleo ó HT .... RRS feed

  • Pregunta

  • 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 Smile

    Un saludo.
    jueves, 26 de julio de 2007 10:13

Respuestas

  • 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!

     

    jueves, 26 de julio de 2007 10:45

Todas las respuestas

  • 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!

     

    jueves, 26 de julio de 2007 10:45
  • 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 Wink

    Un saludo.
    jueves, 26 de julio de 2007 11:30
  • Un placer.

    jueves, 26 de julio de 2007 11:32
  • 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 Stick out tongue

    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!!
    martes, 31 de julio de 2007 10:03