Stack vs Heap

Question

Pour ceux que ca int&#233;resse je viens de faire un test.. Il parait qu'avec .NET l'allocation dynamique sur le tas est quasiment aussi rapide que l'allocation sur la pile.. Pas si s&#251;r..

namespace Test
{
    class App
    {
        [ System.Runtime.InteropServices.DllImport( "kernel32.dll" ) ]
        [ System.Security.SuppressUnmanagedCodeSecurity ]
        private static extern int QueryPerformanceCounter( ref long count );


        private static long ticks = 0;


        private static long Ticks
        {
            get
            {
                QueryPerformanceCounter( ref ticks );
                return ticks;
            }
        }


        private unsafe static void Stack( )
        {
            byte* p = stackalloc byte[ 256 ]; // Attention &#224; StackOverflowException.
        }


        private static void Heap( )
        {
            byte[ ] tab = new byte[ 256 ];
        }


        private static void Main( )
        {
            long ticks = 0;
            long stack = 0;
            long heap = 0;


            Stack( ); // JIT
            Heap( ); // JIT


            ticks = Ticks;
            for ( int i = 0; i < 1000; i++ )
                Stack( );
            stack = Ticks - ticks;


            ticks = Ticks;
            for ( int i = 0; i < 1000; i++ )
                Heap( );
            heap = Ticks - ticks;


            System.Windows.Forms.MessageBox.Show( "Stack	: " + stack + "
Heap	: " + heap );
        }
    }
}

ZogStriP · Answer

Je viens de tester ton programme et il est vrai que l'allocation sur le
tas n'est pas aussi rapide que sur la pile (un facteur d'environ :
60)...



Mais moi j'aimerais savoir o&#249; est ce que tu as lu que l'allocation sur
le Heap &#233;tait pratiquement aussi rapide que l'allocation sur la Pile en
.Net ??



Je ne m'y connais pas trop, mais je pense qu'en C/C++ c'est la m&#234;me chose.... non ?

ZogStriP
Mon Blog : IA pour Incomplet de l'Anc&#233;phale Mon Site : Site web sur le projet [%3C/body ]

MorpionMx · Answer

Meme reaction que ZogStrip, j'ai jamais lu que l'allocation sur le tas &#233;tait aussi rapide que celui sur la pile.

Mx

Lutinore · Answer

Salut, bien je ne sais plus ou j'ai lu ca &#224; vrai dire.. On entend aussi parfois dire qu'avec les nouveaux microprocesseurs d'auourd'hui les diff&#233;rences ne sont plus aussi significatives.. En fait le but premier de ce test c'est que je voulais tester la performance du mot cl&#233; "stackalloc", non seulement c'est &#233;fficace mais en plus le GC n'a aucun travail &#224; faire &#224; la sortie de la fonction et si je parcours le tableau avec le pointeur retourn&#233; je ne subit pas les ralentissement d&#251; au tests "IndexOutOfRange" du "runtime". J'imagine que pour certaines applications ca peut &#234;re utile..

ZogStriP · Answer

C'est certainement utile, mais &#231;a voudrais dire que l'on retombe dans
des applications C/C++ alors que l'on code en C# et en Manag&#233; (et tout
le monde sait que Manage => Perte de performances....)

ZogStriP
Mon Blog : IA pour Incomplet de l'Anc&#233;phale Mon Site : Site web sur le projet [%3C/body ]

Lutinore · Answer

Oui mais parfois travailler en unsafe c'est in&#233;vitable.. En g&#233;n&#233;ral j'utilise plut&#244;t Marshal.AllocCoTaskMem.. On peut aussi fixer en m&#233;moire un tableau, mais je crois que c'est pas super performant.. Vi ok on retombe en C\C++ mais c'est une bonne r&#233;ponse &#224; ceux qui disent que le C# est pas rapide, qu'on peut pas faire de jeu ou ce genre d'application.. Il ne s'agit pas de tout coder en unsafe bien s&#251;r, juste les parties critiques..

ZogStriP · Answer

Ouai je sais, et je pense que c'est pour cette raison que MS a laiss&#233; un moyen d'utiliser du code unsafe :)



Je ne m'y connais pas du tout en unsafe, est ce que tu pourrais expliquer ce que c'est : Marshal.AllocCoTaskMem ???



Merci

ZogStriP
Mon Blog : IA pour Incomplet de l'Anc&#233;phale Mon Site : Site web sur le projet [%3C/body ]

Lutinore · Answer

C'est comme malloc en C, tu alloues de la m&#233;moire NON manag&#233;e et donc tu peux y acc&#233;der avec un pointeur sans devoir la fixer, c'est pratique qu'en tu travailles avec PInvoke et que tu as besoin d'un buffer qui ne bouge pas en m&#233;moire..

ZogStriP · Answer

Si je comprend bien c'est la version non manag&#233; de :



fixed(....) ???

ZogStriP
Mon Blog : IA pour Incomplet de l'Anc&#233;phale Mon Site : Site web sur le projet [%3C/body ]

Lutinore · Answer

Pas vraiment, mais ca peut avoir la m&#233;me utilit&#233;, mais je n'imagine pas une application "fixer" un buffer durant tout le temps de son ex&#233;cution.. de plus Microsoft pr&#233;conise de fixer les objet le moins longtemps possible, surement pour ne pas bloquer le GC.

ZogStriP · Answer

Ben ouai, quand ont fixe un objet c'est qu'on a a pas besoin pour
longtemps, parce que &#231;a empeche le Garbage Collector de le d&#233;plac&#233; lors
de ces phases.. donc une perte de performance..

ZogStriP
Mon Blog : IA pour Incomplet de l'Anc&#233;phale Mon Site : Site web sur le projet [%3C/body ]

Lutinore · Answer

Exactement.. avec Marshall.AllocCoTaskMem tu n'as pas se probl&#232;me.

ZogStriP · Answer

J'ai ajout&#233; &#224; ton code la fonction :



private unsafe static void Test( )

{

           
System.Runtime.InteropServices.Marshal.AllocCoTaskMem(256 *
sizeof(byte));

}



Et je l'ai test&#233;, mais pour mes tests c'est plus long que l'allocation sur le Heap en .Net....



Peut &#234;tre que je me plante, c'est peut &#234;tre pas : 256 * sizeof(byte)...





Test&#233; grace au code suivant :



class Class1

    {

        [ System.Runtime.InteropServices.DllImport( "kernel32.dll" ) ]

        [ System.Security.SuppressUnmanagedCodeSecurity ]

        private static extern int QueryPerformanceCounter( ref long count );



        private static long ticks = 0;



        private static long Ticks

        {

            get

            {

                QueryPerformanceCounter( ref ticks );

                return ticks;

            }

        }



        private unsafe static void Stack( )

        {

            byte* p =
stackalloc byte[ 256 ]; // Attention &#224; StackOverflowException.

        }



        private static void Heap( )

        {

            byte[ ] tab = new byte[ 256 ];

        }



        private unsafe static void Test( )

        {

           
System.Runtime.InteropServices.Marshal.AllocCoTaskMem(256 *
sizeof(byte));

        }



        private static void Main( )

        {

            long ticks = 0;

            long stack = 0;

            long heap = 0;

            long test = 0;



            Stack( ); // JIT

            Heap( ); // JIT

            Test( ); // JIT



            ticks = Ticks;

            for ( int i = 0; i < 1000; i++ )

                Stack( );

            stack = Ticks - ticks;



            ticks = Ticks;

            for ( int i = 0; i < 1000; i++ )

                Heap( );

            heap = Ticks - ticks;



            ticks = Ticks;

            for( int i = 0; i < 1000; i++ )

                Test( );

            test = Ticks - ticks;



           
System.Console.WriteLine("Stack	: " + stack + "
Heap	: " + heap +
"
Test	: " + test );

        }

    }

ZogStriP
Mon Blog : IA pour Incomplet de l'Anc&#233;phale Mon Site : Site web sur le projet [%3C/body ]

Lutinore · Answer

Excuses moi j'avais pas vu ton message.. En fait pour faire une bonne utilisation de cette m&#233;thode, il faut s'en servir un seule fois dans ton code et garder le pointeur en champs de la classe.. Et n'oublie pas d'appeler Marshal.FreeCoTaskMem sinon bonjour le memory leak !

class App
{
   private unsafe static byte* pBuffer = null;


   private unsafe static void Main( )
   {
      pBuffer = ( byte* )Marshal.AllocCotaskMem( sizeof( byte ) * 256 );

      // ...

      Marshall.FreeCoTaskMem( ( IntPtr )pBuffer );
   }
}

Lutinore · Answer

Voil&#224; un test plus significatif, avantage &#224; Marshal.AllocCoTaskMem mais de peu.. Cela dit cette fonction reste utile pour PInvoke.

namespace Test
{
    class App
    {
        [ System.Runtime.InteropServices.DllImport( "kernel32.dll" ) ]
        [ System.Security.SuppressUnmanagedCodeSecurity ]
        private static extern int QueryPerformanceCounter( out long count );


        private static long ticks = 0;
        private unsafe static byte* pBuffer = null;
        private static byte[ ] buffer = null;


        private static long Ticks
        {
            get
            {
                QueryPerformanceCounter( out ticks );
                return ticks;
            }
        }


        private unsafe static void Heap( )
        {
            fixed ( byte* p = buffer )
            {
                for ( int i = 0; i < 256; i++ )
                    p[ i ] = p[ i ]; // Read and Write
            }
        }


        private unsafe static void Global( )
        {
            for ( int i = 0; i < 256; i++ )
                pBuffer[ i ] = pBuffer[ i ]; // Read and write
        }


        private unsafe static void Main( )
        {
            pBuffer = ( byte* )Marshal.AllocCoTaskMem( sizeof( byte ) * 256 );
            buffer = new byte[ 256 ];


            long ticks = 0;
            long heap = 0;
            long global = 0;


            Heap( ); // JIT
            Global( ); // JIT


            ticks = Ticks;
            for ( int i = 0; i < 1000; i++ )
                Heap( );
            heap = Ticks - ticks;


            ticks = Ticks;
            for ( int i = 0; i < 1000; i++ )
                Global( );
            global = Ticks - ticks;


            Marshal.FreeCoTaskMem( ( IntPtr )pBuffer );


            System.Windows.Forms.MessageBox.Show( "Heap	: " + heap + "
Global	: " + global );
        }
    }
}

ZogStriP · Answer

J'ai maintenant :



private unsafe static byte* pBuffer = null;

        private unsafe static void Test( )

        {

            pBuffer =
(byte*)System.Runtime.InteropServices.Marshal.AllocCoTaskMem( sizeof(
byte ) * 256 );

            System.Runtime.InteropServices.Marshal.FreeCoTaskMem((IntPtr) pBuffer);

        }



Et c'est &#224; peine plus rapide que le Heap...

Mais c'est plus rapide que ce que je faisais avant...



:p

ZogStriP
Mon Blog : IA pour Incomplet de l'Anc&#233;phale Mon Site : Site web sur le projet [%3C/body ]

Lutinore · Answer

Remarque c'est aussi le heap, le heap global.. Oui mais tu peux passer cette m&#233;moire &#224; du code NON manag&#233; c'est pratique.

Stack vs Heap

16 réponses

Votre réponse

Discussions similaires