C++ Dynamisk minneshantering

hej!

jag ska undersöka hur mycket minne jag kan allokera innan OS säger ifrån genom att först
- allokera minne i 1GB-bitar

jag ska även undersöka vad som händer i OS då program läcker minne genom att
- allokera minne i 1GB-bitar

någon vänlig själ som kan förklara lite enklare språk hur det fungerar och ska gå till vid allokering med 1GB i taget samt 1KB i taget

även om jag loopar igenom för att addressera upp en integer så är ju det ändå inte 1GB i taget, utan det är en integer som är värd 4byte (inte alltid) som loopas igenom, det är väl ändå inte samma sak som att allokera upp 1GB i taget? kan ett program läcka minne även om jag använder delete?

lite hjälp på vägen tack

va duktiga ni är!

jag tror att jag börjar att förstå detta nu.

eftersom jag ska kolla hur många GB jag kan allokera innan det blir stopp (catch bad_alloc) så tänkte jag skapa en loop, men jag får inte till det, utan det kastas bad_alloc exception direkt på 2a varvet

jag skulle kunna göra det manuellt och skapa 16st manuellt och se vad det tar stopp, men loopen kommer väl till användning senare när jag ska utföra samma sak fast där jag allokerar 1KB i taget istället

tips?

här är vad jag har hittils:

try 
{

        int *gigabyte;      
        int sizeGb = 1024*1024*1024/sizeof(gigabyte);
      

        for(int i = 0; i < 15; i++)
        {
              gigabyte = new int[sizeGb];
              cout << "1GB + ";
              _getch();
        }

        delete[] gigabyte;	
					
}
	
catch (bad_alloc e ) 
{
	cerr << "Error: memory could not be allocated";        
}

En fundering var ifall jag på istället något sätt ändra värdet på sizeGb så att det plussas på 1GB för vare loop varv? därmed skulle jag bara behöva lägga detta i loopen och så att minnesallokeringen även dubblas på något sätt vilket jag ej lyckats med hittils

Jag tänkte mig nånting åt detta hållet:

int integer;
		int sizeGb = 1024*1024*1024/sizeof(integer);

		for(int i = 0; i < 16; i++)
		{
			int *gigabyte;	
			gigabyte = new int[sizeGb];
			cout << "1GB : ";
			_getch();
			delete[] gigabyte;	
			cout << "Deleted\n";
			_getch();
			sizeGb+=  (   1024*1024*1024/sizeof(integer)    );
		}

men som sagt det fungerar inte, bad_alloc händer efter 1a varvet

Provade det och det fungerade inte, jag måste väl få allokera mer än 1GB minne? jag har 16GB minne i datorn, borde få allokera upptill 11-12 GB minne. Jag har mätt upp windows7 till att den körs med 3,68 GB minne, säg 4GB.

varför blir detta fel tror du?

Elgot, du hade rätt!

jag provade att göra det enkelt för mig:

		int integer;
		int sizeGb = 1024*1024*1024/sizeof(integer);

		int *gigabyte1;	
		gigabyte1 = new int[sizeGb];
		cout << "1GB + ";
		_getch();

		int *gigabyte2;	
		gigabyte2 = new int[sizeGb];     //ERROR KASTAS HÄR
		cout << "1GB + ";
		_getch();

Vid den 2a allokeringen får jag bad_alloc. Men varför är det så? jag borde väl få allokera minne bäst jag vill förutsatt att det finns tillgängligt? upptill 11GB iallafall

Samt: jag ska även prova att allokera 1KB i taget istället för 1GB. Förslag på hur jag gör detta till en loop då min egen loop inte fungerade?

Hur ser jag ifall jag kompilerar som 64-bits program? jag använder Visual studio 2012 och och jag har windows7 64bit.
Visual studio är installerat till c:\programmering\VS

ifall du tänkte på programmappens namn c:\program (x86)

Tack! detta verkade göra susen!

        for(int i = 1; i < 13; i++)
        {
            int *gigabyte;    
            gigabyte = new int[sizeGb];
            cout << i << " GB : ";
            _getch();
            delete[] gigabyte;    
            cout << "Deleted\n";
            _getch();
            sizeGb+=  (   1024*1024*1024/sizeof(integer)    );
        }

Jag kom upp i 7GB minne, men en konstig sak som jag inte förstår mig på, varför kan jag inte se i aktivitetshanteraren i windows att mer minne används? den står stadigt kvar på 25% minne oavsett vad som händer. Innan jag ändrade till x64 så kunde den hoppa upp från 25% till 31% nånstans efter 1GB

Sedan så tycker jag att jag borde kunna allokera åtminstone ett par GB till, ca 10-11 GB borde fungera?

här allokerar jag 20GB utan error med 16GB minne, vad gör jag fel?

int integer;
int sizeKb = 1024/sizeof(integer);

for(int i = 1; i < (1024*20); i++)
{
      int *kilobyte;    
      kilobyte = new int[sizeKb];
      cout << i << " KB\n";
      delete[] kilobyte;
      sizeKb+=  (   1024/sizeof(integer)    );
}

swapfilen är avstängd

om jag kan allokera 40.000 KB minne genom att göra det i 1-KB åt gången så borde jag kunnat ha gjort det med att allokera på samma sätt fast i 1-GB i taget

det verkar inte finnas något stopp på hur många KB minne jag kan allokera

sedan att minnesmätaren i aktivitetshanteraren inte rör sig alls förstår jag inte överhuvudtaget, som sagt den hoppade från 25% till 31% förut när jag allokerade 1GB minne innan jag ändrade platformen till x64

Det låter faktiskt vettigt! hur stänger jag av denna sorts optimering i VS 2012 ?

jag har av-aktiverat optimization
och skrivit till minnet jag allokererar enligt nedan
tanken är att kolla om 1 KB går att allokera , okej, prova då allokera 2KB, 3KB, 4KB, etc tillls det tar stopp och jag får error så jag kan se vart det tar stopp
Har du någon bättre idé på att göra detta? det är inte det "snyggaste" att demontera varje varv

Mycket lustigt om jag använder long int borde det vara safe

long int integer;
long int sizeKb = 1024/sizeof(integer);

        for(int i = 1; i < (1024*40); i++)
        {
            long int *kilobyte;    
            kilobyte = new long int[sizeKb];
            *kilobyte = 1;                                //skriver till minnet
            cout << i << " KB\n";
            delete[] kilobyte;
            sizeKb+=  (   1024/sizeof(integer)    );
        }

Men jag kan fortfarande allokera otroliga mängder minne utan stopp.
samt vad tror ni att det beror på att minnesmätaren i aktivitetshanteraren aldrig nånsin rubbas nu efter jag bytte till x64 ?

Oj vilket slarvfel av mig med loopen och några futtiga megabyte, fixat nu

try 
{
     cout << "Uppgift: allokera i 1-KB åt gången\n\n";
     int integer;
     size_t sizeKb = 1024/sizeof(integer);

     cout << "utskrift för varje Gigabyte allokerat\n--------------------------------\n";

     for(int i = 1; i < (1024*1024*15); i++)
     {
          int *kilobyte;    
          kilobyte = new int[sizeKb];
          *kilobyte = 1;                        //skriver till minnet
            
	     if(  (i == 1024*1024) || (i == 1024*1024*2) || (i == 1024*1024*3) || (i == 1024*1024*4) || (i == 1024*1024*5) || (i == 1024*1024*6) ||  
                  (i == 1024*1024*7) || (i == 1024*1024*8) || (i == 1024*1024*9) || (i == 1024*1024*10) || (i == 1024*1024*11) || (i == 1024*1024*12) 
                  || (i == 1024*1024*13) || (i == 1024*1024*14) || (i == 1024*1024*15) )
                 {
		       cout << i << " KB\n";
                 }

            delete[] kilobyte;
            sizeKb+=  (   1024/sizeof(integer)    );

        }//end for
}//end try

	catch (bad_alloc e ) 
	{
		_getch();
		cerr << "Error: memory could not be allocated";
	}

Vid detta så allokerar jag upptill 11 gigabyte (med 1-kB i taget) och så får jag en vacker varning i windows att minnet är lågt och jag rekomenderas att stänga av programmet...vilket jag inte gör, efter det så stängs tyvärr mitt C++ console rutan av utan förvarning, jag får inte ens bad_alloc. Varför får jag inte det?

Jag är fortfarande konfunderad på varför jag inte kan allokera 11GB minne i föregående, genom allokera 1GB i taget där det tar stopp efter 7GB

if((i % (1024*1024)) == 0)
    cout << i << " KB\n";

Nice touch med modulus Elgot
jo jag hade glömt att ändra till size_t vid den första delen (allokering av 1-GB i taget)

Del 1: allokering med 1-GB åt gången, landar på 11GB och sedan bad_alloc
Del 2: allokering med 1-KB åt gången, landar på 11GB och sedan lågt minnes-varning i windows, sedan stängs console av utan förvarning

att console stängs av helt utan förvarning kan väl vara rimligt antar jag, men jag hade förväntat mig bad_alloc istället för att console bara stängs av

Tack så mycket för hjälpen alla

En sista sak som jag är fundersam på,

vid allokerandet av 1-KB i taget,

säg att jag vill att programmet ska läcka minne, då struntar jag bara i att använda delete?

Hur kan jag göra om föregående så att den och loopen resulterar i minnes-läckage? jag kommer inte på något bra sätt att göra loopen. Samt vad betyder minnesläckage/varför är det dåligt?

ja och samtidigt så vet jag inte hur jag gör detta, om jag visste skulle jag inte fråga? självklart har jag provat

lågt blodsocker?