[SOLUCIONADO] Respuesta inesperada en asignación de memoria

[cristiansc93]

El programa es solamente para asignar la mayor cantidad de memoria posible utilizando arrays. Pero mi duda es que asigna valores cercanos a 30 mil, mas o menos el tamaño de un entero, y las variables son long double, esperaria una cantidad muchisimo mayor de asignación. Podria alguien decirme como corre en su computadora y/o compartirme algun conocimiento mas detallado sobre su ejecucion?

Les paso el copy-paste:

Código C++:

#include <iostream>
#include <new>
using namespace std;
 
int main ()
{
    long long int n = 0;
    long long int * p;
 
    while(p != 0) 
 
// Utilizo zero por que no me gusta modificar el compilador para que                    //agarren los null y nullptr
 
    {
 
//nothrow evita que new se rompa al toparse con la memoria maxia y no poder asignar //mas, en lugar de eso, regresa un puntero nulo o... a mi humilde entendimiento 0.
 
        p= new (nothrow) long long int[n];
        n++;
    }
 
    cout << endl << "-----------------------" << endl;
    cout << "size: " << n << endl;
 
    delete[] p;
 
    return 0;
}
 

[Profesor_Falken]

Buenas,

Te propongo una pequeña modificación en tu código que te ayudará a entender que es lo que estás haciendo/entendiendo mal:

Código C++:

#include <iostream>
#include <new>
using namespace std;
 
int main ()
{
    long long int n = 0;
    long long int * p;
 
    while(p != 0)
 
// Utilizo zero por que no me gusta modificar el compilador para que                    //agarren los null y nullptr
 
    {
 
//nothrow evita que new se rompa al toparse con la memoria maxia y no poder asignar //mas, en lugar de eso, regresa un puntero nulo o... a mi humilde entendimiento 0.
 
        p= new (nothrow) long long int[n];
        n++;
    }
 
    cout << endl << "-----------------------" << endl;
 
//Hemos reservado memoria para n arrays long long int, cada uno con n+1 elementos
    long totalSize = 0;
    for (int i = 1; i<n; i++) {
        totalSize += n;
    }
 
    cout << "Real number of allocated long long int: " << totalSize << endl;
 
 
    delete[] p;
 
    return 0;
}
 

En mi modestísimo equipo me devuelve 533794816, que son unos dos gigas. Nada mal.


Un saludo

[eferion]

Iniciado por cristiansc93

Código C++:

// Utilizo zero por que no me gusta modificar el compilador para que
//agarren los null y nullptr
 

modificar el compilador?? nullptr es una palabra reservada de c++... lo que pasa es que solo está disponible a partir del estándar del 2011 (el anterior data de 1999).

null, en cambio, suele ser una convención. No es más que un alias de 0.

Personalmente creo más beneficioso usar nullptr, null y 0 (en ese estricto orden) para inicializar punteros. ¿Mis motivos? explicados en el siguiente ejemplo: Imagina que te encuentras las 3 asignaciones siguientes entre medias del código... que conclusión puedes sacar de cada una, sin conocer el resto del codigo?

Código C++:

var = 0; // Puede ser un puntero... o un número!!!
var = NULL; // Entiendo que debería ser un puntero, pero también se puede usar en variables numéricas
var = nullptr; // Esta asignación únicamente funciona con punteros
 

Queda claro, por tanto, que si ves un nullptr es que esa variable se trata de un puntero.

Otra ventaja de nullptr la encuentras en el caso de funciones sobrecargadas:

Código C++:

void func( int )
{
  std::cout << "func(int)" << std::endl;
}
 
void func( char* )
{
  std::cout << "func(char*)" << std::endl;
}
 
int main( )
{
  func( 0 ); // func(int)
  func( NULL ); // func( int )
  func( nullptr ); // func(char*)
}
 

Si con esto no te he convencido, no se me ocurre que más puedo hacer :)

Código C++:

long long int n = 0;
// ...
p= new (nothrow) long long int[n];
 

Ojo con esto!!! La primera reserva que intentas hacer no es válida. No puedes crear un array de 0 elementos. El mínimo es 1.

Y, para rematar. Dices que el programa finaliza con 30.000. Veamos:

* Utilizas long long int, es decir, supongamos 64 bits
* 30.000 * 64 = 1.920.000 bits = 1.875 kb = 1.83 Mb

Es poca memoria... si, pero fíjate que dentro del bucle no liberas memoria... lo haces al salir del bucle. Pero claro, sales del bucle cuando ha fallado la reserva de memoria, luego p vale 0, luego ese delete no hace absolutamente nada.

Por otro lado, dado que no liberas memoria, el programa va creciendo y creciendo.

Un cálculo rápido nos dice que ( 30.000 * 64 ) * 15.000 = 28.800.000.000 bits consumidos = 28.125.000 kb = 27.465 Mb = 26.82 Gb.

Este cálculo es aproximado y te dice (si no me he confundido con las cuentas) la memoria consumida en 30.000 ciclos.

Como puedes ver, no es moco de pavo.

Un saludo.

[aguml]

Pues yo vi un inconveniente muy gordo, usa fuerza bruta y empieza desde 1 y el tamaño maximo de un long long int es inmenso y podria ser eterno dependiendo de la memoria disponible. Para hacer unas pruebas y aligerar lo maximo el proceso hice esto:

Código PHP:

  #include <iostream> 
#include <new> 
#include <math> 
using namespace std; 
      
int main () 
{ 
   unsigned long long int n = std::numeric_limits<long long int>::max(); 
   long long int *p; 
   unsigned long long int tamEnBytes; 
   double tamEnKb, tamEnMb, tamEnGb; 
   int nCeros=0; 
 
   // Voy incrementando exponencialmente 10^nDigitos para avanzar mas rapido 
   // hasta un valor que de null al reservar 
   do{ 
      p= new (std::nothrow) long long int[n]; 
      if(p == NULL){ 
         nCeros++; 
         n = std::numeric_limits<long long int>::max() / (10*nCeros); 
      } 
   }while(n > 0 && p == NULL); 
 
   //Una vez salga libero la memoria 
   if(p != NULL) 
   { 
      delete[] p; 
 
      // Una vez salga del bucle anterior tendré un valor mayor al que puedo usar 
      // asi que lo voy decrementando hasta encontrar el valor valido maximo 
      do{ 
         n++; 
         p= new (std::nothrow) long long int[n]; 
         if(p != NULL) 
            delete [] p; 
      }while(p != NULL && n < std::numeric_limits<long long int>::max()); 
 
      n--; 
      tamEnBytes = sizeof(long long int) * n; 
      tamEnKb = tamEnBytes / (double)1024 * n; 
      tamEnMb = tamEnKb / 1024; 
      tamEnGb = tamEnMb / 1024; 
      cout << endl << "-----------------------" << endl; 
      cout << "Numero maximo de elementos para los que se pudo obtener memoria es: " << n << endl; 
      cout << "Memoria total consumida por el array: " << endl << 
      tamEnBytes << " bytes o " << endl << 
      tamEnKb << " kb o " << endl << 
      tamEnMb << " Mb o " << endl << 
      tamEnGb << " Gb" << endl << endl; 
   } 
   cout << "Presiona una tecla para salir" << endl; 
   cin.get(); 
   return 0; 
}  
   

y me da este resultado:

-----------------------
Numero maximo de elementos para los que se pudo obtener memoria es: 922337203716897579
Memoria total consumida por el array:
7378697629735180632 bytes o
6.64614e+33 kb o
6.49037e+30 Mb o
6.33825e+27 Gb

Presiona una tecla para salir

Muchos Gigas ¿no? ¿que hago mal para que me de esas burradas? solo tengo 1 giga de ram ¿de donde se saca tanto? Eso no lo tengo ni con el disco duro jajaja.
A ver si veis el fallo aunque pienso que pude ser algo relacionado con desbordamientos de variables o cosas asi pero no lo se seguro ni como solucionarlo.

[lareto]

En teoría, en una plataforma de 32 bits los punteros pueden direccionar hasta 2^32 bits (4 GB), y en una de 64 bits 2^64 (algo más de 18 millones de terabytes).

En la vida real esos límites están más acotados aún debido a la cantidad de memoria real y virtual disponible, y de la porción de memoria de ese mismo address space que se reserva el sistema y sobre todo por el compilador.

Puede ser útil curiosear en:
"Memory Limits for Applications on Windows"
https://software.intel.com/en-us/art...ations-windows

[aguml]

Vale, vi algun fallo en los calculos pero aun asi lo veo una burrada. Asi quedó ahora:

Código PHP:

  #include <iostream>
#include <new>
#include <math>
using namespace std;

int main ()
{
   unsigned long long int n = std::numeric_limits<long long int>::max();
   long long int *p;
   double tamEnBytes, tamEnKb, tamEnMb, tamEnGb;
   int nCeros=0;

   // Voy incrementando exponencialmente 10^nDigitos para avanzar mas rapido
   // hasta un valor que de null al reservar
   do{
      p= new (std::nothrow) long long int[n];
      if(p == NULL){
         nCeros++;
         n = std::numeric_limits<long long int>::max() / (10 * nCeros);
      }
   }while(n > 0 && p == NULL);

   //Una vez salga libero la memoria
   if(p != NULL)
   {
      delete [] p;

      // Una vez salga del bucle anterior tendré un valor mayor al que puedo usar
      // asi que lo voy decrementando hasta encontrar el valor valido maximo
      do{
         n++;
         p= new (std::nothrow) long long int[n];
         if(p != NULL)
            delete [] p;
      }while(p != NULL && n < std::numeric_limits<long long int>::max());

      n--;
      tamEnBytes = sizeof(long long int) * n;
      tamEnKb = tamEnBytes * ((double)8 / 1024);
      tamEnMb = tamEnKb / 1024;
      tamEnGb = tamEnMb / 1024;
      cout << endl << "-----------------------" << endl;
      cout << "Numero maximo de elementos para los que se pudo obtener memoria es: " << n << endl;
      cout << "Memoria total consumida por el array: " << endl <<
      tamEnBytes << " bytes (" << (unsigned long long int)tamEnBytes << " bytes) o " << endl <<
      tamEnKb << " Kb (" << (unsigned long long int)tamEnKb << " Kb) o " << endl <<
      tamEnMb << " Mb (" << (unsigned long long int)tamEnMb << " Mb) o " << endl <<
      tamEnGb << " Gb (" << (unsigned long long int)tamEnGb << " Gb) o " << endl << endl;
   }
   cout << "Presiona una tecla para salir" << endl;
   cin.get();
   return 0;
}  
   

-----------------------
Numero maximo de elementos para los que se pudo obtener memoria es: 922337203716897579
Memoria total consumida por el array:
7.3787e+18 bytes o
5.76461e+16 kb o
5.6295e+13 Mb o
5.49756e+10 Gb

Presiona una tecla para salir

Me sigue pareciendo una burrada. A ver si alguien lo aclara...

[lareto]

Pongo mi explicación en el código:

Código C++:

#include <iostream>
#include <new>
#include <limits>
#include <cstdint>
 
int main()
{
    long long n = std::numeric_limits<long long>::max();
    long long *p;
    int nCeros=0;
 
    do{
        p= new (std::nothrow) long long[n];
        if (p == nullptr){
            nCeros++;
            n = std::numeric_limits<long long>::max() / (10 * nCeros);
        }
    } while (p == nullptr);
 
    long long bytes = n * sizeof(long long);
    std::cout << "\nDa la impresion de que se hubiera podido obtener memoria para "
        << bytes << " Bytes;\n";
    std::cout << "(Que serian " << bytes/1024.0/1024/1024 << " GB)\n\n";
 
    std::cout << "Incluso se puede tener la ilusion de que es posible\n"
        "operar sobre ese espacio de memoria ...\n\n";
 
    std::cout << "Por ejemplo:\n";
    p[0] = 5;
    p[n-1] = 6;
 
    std::cout << "p[0] = " << p[0] << '\n';
    std::cout << "p[" << n-1 << "] = " << p[n-1] << '\n';
 
    std::cout << "\nPero, realmente? Existe algo que se llame p[" << n-1 << "]?\n\n";
 
    std::cout << "size_t desilucion;\n";
    size_t desilusion;
 
    std::cout << "El operator new usa el tipo size_t para el tamaño de los objetos.\n\n";
 
    std::cout << "En este caso, haciendo desilusion = n-1:\n";
    desilusion = n-1;  // el compilador debería advertir que se trunca
    std::cout << "la asignacion parece decir: desilusion = " << n-1 << ";\n\n"
        "pero en realidad, al truncarse, lo que realmente queda es:\n";
    std::cout << "desilusion == " << desilusion << "\n\n";
 
    std::cout << "De modo que:\n";
    std::cout << "p[0] == " << p[0] << '\n';
    std::cout << "p[" << desilusion << "] == " << p[desilusion] << "\n\n";
 
 
    std::cout << "Como puede verse, el tamaño efectivamente asignado fue de:\n";
    std::cout << desilusion * sizeof(long long) << " Bytes;\n";
    std::cout << "que son " << desilusion * sizeof(long long)/ 1024.0/1024/1024 
        << " GB,\nque ya no es tan burrada, o es una burrada dentro de los limites esperados.\n\n";
  
 
    std::cout << "P.D.: Aunque los arrays no son punteros... (es broma :),\n"
        "siempre que se trate de direcciones de memoria, la medida\n"
        "deberia expresarse en size_t\n";
 
}
 

[aguml]

Gracias amigo por tu tiempo pero tengo dudas y muchas aun jajaja.
A ver:

Código PHP:

  std::cout << "la asignacion parece decir: desilusion = " << n-1 << ";\n\n"
    "pero en realidad, al truncarse, lo que realmente queda es:\n";
std::cout << "desilusion == " << desilusion << "\n\n";  
   

Ciertamente en mi caso el truncado es brutal ya que n-1 es 922337203685477579 y desilusion vale 3435973835. ¿donde están los 922337203685477579 miembros?
Con eso no se que decir ya que si p[desilusion] y p[n-1] apuntan al mismo sitio ¿que pasa si realmente quiero ver el valor de p[n-1] donde n sea 3435973836? pues que desilusion no se truncaria no? no se, tengo un cacao...
El caso es que al ser desilusion de 4 bytes y n de 8 bytes ¿cuantas veces se ha truncado desilusion? ¿como sabe a cual de esas veces me refiero para mostrar el valor correcto?

PD: al hacer p[n-1]... el compilador me da warnings de Suspicious pointer aritmetich.

[lareto]

Ciertamente en mi caso el truncado es brutal ya que n-1 es 922337203685477579 y desilusion vale 3435973835. ¿donde están los 922337203685477579 miembros?

No están en ningún lado, nunca existieron. El programa está intentando asignar una cantidad de memoria imposible e ir bajando las pretensiones hasta que lo consiga, y para eso usa la expresión:

Código C++:

p= new (std::nothrow) long long[n];
 

Pero, como en tu plataforma un long long es de 64 bits, mientras que un size_t es de 32, lo que realmente está sucediendo es:

Código C++:

p= new (std::nothrow) long long[(size_t)n];
 

Y esa asignación tiene éxito cuando es posible asignar n * sizeof(long long) truncados al hacer el cast a size_t.
Recuerda que la cantidad de memoria que puede asignar tu programa depende varios factores (¿leíste el artículo que mencionaba en mi primer mensaje, verdad?), y que para un Windows de 32 bits es razonable esperar algo así como 1,7 GB (que van a salir de la ram; y si no alcanza, del archivo de intercambio).

... ¿que pasa si realmente quiero ver el valor de p[n-1] donde n sea 3435973836?

Si has asignado una cantidad de bytes a p, ese es el límite de tu variable, más allá hay cualquier cosa, otros datos o código del programa, lo que sea que haya en la memoria después de p. Pero si el programa ya agotó todo su espacio permitido por el sistema operativo, 3435973836 queda fuera de su universo, que en CPUs en modo protegido (https://en.wikipedia.org/wiki/Protected_mode) significa la muerte del programa.

El caso es que al ser desilusion de 4 bytes y n de 8 bytes ¿cuantas veces se ha truncado desilusion?

Puedes hacer la cuenta; tienes a
std::numeric_limits<size_t>::max() y a
std::numeric_limits<long long>::max() y que
std::numeric_limits<size_t>::max() +1 == 0

PD: al hacer p[n-1]... el compilador me da warnings de Suspicious pointer conversion.

Parece razonable. En términos de aritmética de punteros, p[n-1] es p + n-1, donde n se definió como long long, pero se usa truncado a size_t.

[aguml]

Ya lo voy pillando, entonces me surge otra pregunta ¿que pasa si intento llenar todos sus miembros con el valor maximo - 1 de un long long? o lo que es lo mismo, obligo al programa a guardar un valor muy grande de tipo long long en todos sus miembros. ¿Crashearia y se cerraria el programa? ya que la memoria realmente no existe porque ha asignado para size_t y no para long long ¿no?
El codigo anterior lo he puesto para que tarde el menor tiempo posible en dar con el valor maximo de forma precisa aunque supongo que este seria un caso para hacerlo de forma recursiva pero yo y la recursividad nos odiamos
Aqui el codigo:

Código PHP:

  #include <iostream> 
#include <new> 
#include <math> 
using namespace std; 
 
int main () 
{ 
   unsigned long long int n = std::numeric_limits<long long int>::max(); 
   long long int *p, tamEnBytes, tamEnKb; 
   double tamEnMb, tamEnGb; 
   int nCeros=0; 
   size_t maxSize; 
    
   // Voy dividiendo el valor maximo del tipo long long int entre 10*nDigitos para avanzar mas rapido 
   // incrementando nDigitos en cada pasada hasta dar con un valor que no de null al reservar 
   do{ 
      p= new (std::nothrow) long long int[n]; 
      if(p == NULL){ 
         nCeros++; 
         n = std::numeric_limits<long long int>::max() / (10 * nCeros); 
      } 
   }while(n > 0 && p == NULL); 
 
   //Una vez salga libero la memoria 
   if(p != NULL) 
   { 
      delete [] p; 
 
      if(n != std::numeric_limits<long long int>::max()) 
      { 
         // Una vez salga del bucle anterior tendré un valor mayor al que puedo usar 
         // asi que lo voy decrementando hasta encontrar el valor valido maximo 
         do{ 
            n+=10000; 
            p= new (std::nothrow) long long int[n]; 
            if(p != NULL) 
               delete [] p; 
         }while(p != NULL && n < std::numeric_limits<long long int>::max()); 
 
         do{ 
            n -= 1000; 
            p= new (std::nothrow) long long int[n]; 
         }while(n > 0 && p == NULL); 
 
         delete [] p; 
 
         // Una vez salga del bucle anterior tendré un valor mayor al que puedo usar 
         // asi que lo voy decrementando hasta encontrar el valor valido maximo 
         do{ 
            n+=100; 
            p= new (std::nothrow) long long int[n]; 
            if(p != NULL) 
               delete [] p; 
         }while(p != NULL && n < std::numeric_limits<long long int>::max()); 
 
         do{ 
            n -= 10; 
            p= new (std::nothrow) long long int[n]; 
         }while(n > 0 && p == NULL); 
 
         delete [] p; 
 
         // Una vez salga del bucle anterior tendré un valor mayor al que puedo usar 
         // asi que lo voy decrementando hasta encontrar el valor valido maximo 
         do{ 
            n++; 
            p= new (std::nothrow) long long int[n]; 
            if(p != NULL) 
               delete [] p; 
         }while(p != NULL && n < std::numeric_limits<long long int>::max()); 
 
         n--; 
      } 
       
      maxSize = n-1; 
      tamEnBytes = sizeof(long long int) * maxSize; 
      tamEnKb = tamEnBytes / 1024; 
      tamEnMb = tamEnKb / 1024.0; 
      tamEnGb = tamEnMb / 1024; 
      cout << endl << "-----------------------" << endl; 
      cout << "Numero maximo de elementos para los que se pudo obtener memoria es: " << n << endl; 
      cout << "Memoria total consumida por el array: " << endl << 
      tamEnBytes << " bytes o " << endl << 
      tamEnKb << " Kb o " << endl << 
      tamEnMb << " Mb o " << endl << 
      tamEnGb << " Gb" << endl << endl; 
   } 
   cout << "Presiona una tecla para salir" << endl; 
   cin.get(); 
   return 0; 
}  
   

[lareto]

Iniciado por aguml

... ¿que pasa si intento llenar todos sus miembros con el valor maximo - 1

No pasa nada. El tamaño de un tipo no cambia con el valor que vaya a tener un objeto de ese tipo.

[aguml]

Iniciado por lareto

No pasa nada. El tamaño de un tipo no cambia con el valor que vaya a tener un objeto de ese tipo.

Pero si decimos que es imposible que reserve tanta memoria y que es truncada ¿donde piensa escribir cuando intente escribir en todos y cada uno de los miembros?

[lareto]

Me tomó cierto esfuerzo hacer el programa con intención de aclararlo, pero se ve que no funcionó. Paso.

[cristiansc93]

Agradezco sus respuestas, estudiaré el código mas de cerca. Muy buenas explicaciones a todos