C# structs/classes stack/heap control?

Question

así que en C++ es muy fácil. usted quiere que se asigne cualquier clase/estructura en el montón, use nuevo. si lo quieres en la pila, no uses nuevo.

en C# siempre usamos la nueva palabra clave, y dependiendo de si se trata de una estructura o una clase, se asigna en la pila o en el montón (las estructuras van a la pila, las clases al montón) y en algunas aplicaciones puede haber una ENORME diferencia de rendimiento cuando se cambia el diseño de modo que solo esos objetos van al montón que realmente pertenecen allí.

Lo que me pregunto es: ¿hay una manera directa de controlar dónde se asigna un objeto independientemente de si se declara como estructura o clase? Sé que los tipos de valores (estructuras) se pueden guardar en cajas para ir al montón (pero el boxeo/unboxing tiene un costo de rendimiento). ¿Hay alguna manera de asignar clases en la pila?

Además, ¿hay algún mecanismo para asignar memoria sin procesar y usar algo así como la ubicación nueva en C++? Sé que esto rompe con la idea de ser administrado, pero puede hacer una gran diferencia en el rendimiento si puede usar su administración de memoria personalizada.

Me encanta C# por su conveniencia, porque es un recolector de basura y otras cosas, pero a veces, al trabajar en el cuello de botella de una aplicación, puede ser conveniente tener más control sobre lo que realmente está sucediendo.

Algún consejo/toques agradables :)

edición: Ejemplo de ejecución:

struct Foo1 
{ 
    public int i; 
    public float f; 
    public double d; 
} 

struct Foo2 
{ 
    public Foo1[] bar; 

    public void Init(){ 
     bar = new Foo1[100]; 
     for (int i = 0; i < 100; i++) 
      bar[i] = new Foo1(); 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     DateTime time = DateTime.Now; 
     Foo2[] arr = new Foo2[1000000]; 
     for (int i = 0; i < 1000000; i++) 
     { 
      arr[i] = new Foo2(); 
      arr[i].Init(); 
     } 

     Console.WriteLine((DateTime.Now - time).TotalMilliseconds); 
    } 
} 

Esto toma 1.8 segundos en mi máquina para ejecutar (tenga en cuenta que en realidad sólo hay asignación pasando - sin paso de parámetros)

si Foo1 se cambia de estructura a clase, la ejecución lleva 8.9 segundos. eso es cinco veces más lento

Answer 1

Mientras que en el caso general es cierto que los objetos siempre se asignan en el montón, C# le permite bajar al nivel del puntero para una interoperabilidad pesada o para un código crítico de muy alto rendimiento.

En unsafe bloques, puede usar stackalloc para asignar objetos en la pila y usarlos como punteros.

Para citar su ejemplo:

// cs_keyword_stackalloc.cs 
// compile with: /unsafe 
using System; 

class Test 
{ 
    public static unsafe void Main() 
    { 
     int* fib = stackalloc int[100]; 
     int* p = fib; 
     *p++ = *p++ = 1; 
     for (int i=2; i<100; ++i, ++p) 
     *p = p[-1] + p[-2]; 
     for (int i=0; i<10; ++i) 
     Console.WriteLine (fib[i]); 
    } 
} 

Nota sin embargo que no es necesario declarar un método completo insegura, que sólo puede utilizar un bloque unsafe {...} por ello.

Answer 2

Su explicación de dónde van los tipos de valores frente a los tipos de referencia (stack v. heap) no es completamente correcta.

Las estructuras también se pueden asignar en el montón si son miembros de un tipo de referencia, por ejemplo. O si los ha empaquetado al pasarlos a través de una referencia de objeto.

Debe leer http://www.yoda.arachsys.com/csharp/memory.html para obtener una mejor comprensión de dónde se asignan realmente los diferentes tipos.

En una nota aparte, en .Net, realmente no debería importar dónde se asigna un tipo, como escribe Eric Lippert: the stack is an implementation detail. Es mejor que comprendas la semántica de cómo se pasan los tipos (por valor, referencia, etc.).

Además, parece estar implicando que la asignación de un objeto en el montón es más costosa que en la pila. En realidad, yo diría que el costo de rendimiento de copiar los tipos de valor supera el beneficio de cualquier ahorro en una asignación ligeramente más rápida en la pila. La mayor diferencia entre la pila y el montón es que en la mayoría de las arquitecturas de CPU es más probable que la pila se conserve en la memoria caché de la CPU y, por lo tanto, evite fallas en la memoria caché.

Este no es el problema más importante para preocuparse por. Debe decidir si el tipo debe tener una semántica de valor por paso o no. Si no es así, entonces tal vez debería ser un tipo de referencia.

Answer 3

No se preocupe, su cabeza todavía está en el mundo de c/C++ donde puede importar mucho donde va todo. Hay un grupo de personas realmente inteligentes en el equipo de CLR que pasan todo el día preocupándose por hacer esto mágicamente rápido.

Hay algunos aspectos críticos en C# y el uso de memoria por lo general assocaited con la creación de una gran cantidad de pequeños objetos por accidentes (que hace la cadena = cadena + otra cadena en un bucle es un clásico)

Hay una memprofiler que le mostrará qué está sucediendo si realmente cree que tiene un problema de Potencia causada por la administración de memoria

he escrito un montón de rendimiento del código intensa (de procesamiento de gráficos clientes, servidores de red) en C# y nunca tuvo que preocuparse por nada de este

Answer 4

Esta es la forma incorrecta de ver las estructuras y las clases en C#. En C#, la diferencia entre una estructura y una clase no está donde se asigna, sino la semántica de la copia. Una estructura tiene semántica de valores y una clase tiene semántica de referencia. Los programadores de C++ tienden a leer más sobre esto, ya que están acostumbrados a que los objetos en la pila tengan semántica de valores y los objetos en el montón tengan semántica de referencia.

El modo en que se asigna esta memoria es un detalle de implementación del tiempo de ejecución. El tiempo de ejecución puede usar pilas, montones o cualquier otro esquema de asignación híbrido que quiera. Si bien es cierto que generalmente las estructuras se asignarán en algo así como una pila, y las clases se asignarán en una especie de montón, no es necesario. Por ejemplo, una clase asignada en una función y no pasada fuera del alcance de la función podría ser fácilmente asignada en la pila.

Answer 5

No se deje engañar por la palabra clave new, es opcional para las estructuras.

En C# hay un mundo administrado en el que se disfruta del recolector de basura y Type-Safety y no tiene que preocuparse por los detalles de la memoria. La diferencia Stack/Heap es irrelevante, se trata de la semántica de copia.

Para los raros casos en los que desea control, existe la parte insegura (no administrada) de C# con punteros reales y todo.

Pero el costo de las cosas es diferente en C# que en C++, así que no cazar fantasmas, los objetos no administrados y de corta vida son muy baratos. Y el compilador puede asignar pequeñas matrices en la pila como una optimización, no podrá saber y tampoco debería importarle.