[C++] Taille maximale autorisée en RAM

[Aenonis]

Bonjour à toutes et à tous, ou bonsoir, c'est selon.

Je suis occupé à tester un programme (de ma composition) qui utilise des nombres de "taille infinie" mais vu que infini n'est pas informatique, je suis en train de faire une boucle infinie qui alloue de la mémoire sans la libérer (ooouuuhh que c'est mal, je sais) en affichant l'indice de l'octet alloué (avec i de 0 à ...).
Et je relèverai quand le programme aura planté le dernier i affiché pour savoir quand on aura atteint la taille maximale.

Ceci étant dit, je me demande s'il existe un moyen "plus efficace" que d'attendre des plombes que le programme plante...

Je me demande si le programme a droit à une valeur fixe de RAM (par exemple 500 Mo) ou bien, ça dépend de la RAM existante sur le PC (j'ai 4 dont 3.85 Go utilisables de RAM sur mon PC) ou encore, ça dépend des divers processus lancés sur la machine et de la mémoire qu'ils utilisent eux aussi.

(Pour info, mon programme tourne toujours et dans l'explorateur des tâches Windows, le programme en est déjà à 412.000 Ko et il n'a toujours pas planté).

J'ai dû étudié ça lors de mes études en cours de système d'exploitation comme était gérée la mémoire mais je dois vous dire que je n'ai plus de souvenir, surtout que j'ai étudié ça sous Linux, donc Windows, c'est forcément différent.

Je suppose aussi que le dernier i affiché (juste avant que le programme ne plante) sera différent à chaque exécution, ce qui m'aidera fort malheureusement pas à m'informer des limites de mon programme.

Si quelqu'un pouvait m'éclaircir sur ce point, j'en serait fort ravi.

Au plaisir,

Aenonis
-----

[Aenonis]

Re,

Je me souviens vaguement d'une notion importante dans mon cas de figure.

J'ai vu "mémoire physique" sur l'explorateur de tâches Windows, j'ai tout de suite fait le lien avec "mémoire logique". Et quand j'ai dit "logique", j'ai pensé à la pagination (enfin, 10 minutes après, le temps que mes cellules grises se mettent en route).

Je présume que mon programme demande à l'OS d'allouer une zone mémoire dans la mémoire logique et c'est l'OS qui fait le lien entre entre la mémoire logique et la mémoire physique... L'OS lui retourne une page et si il ne sait plus, il y a une segmentation fault (comme accéder au contenu d'un pointeur pointant sur NULL), donc, je n'aurai sûrement pas la valeur recherchée à l'octet près mais "à la page près", si mes souvenirs sont exacts.

De plus, il y a de la RAM réservée pour l'OS, un bout de RAM avec le code de toutes les interruptions système, etc...
Donc, sur mes 4 Go de RAM, il y a un bout que je ne pourrais pas utiliser.

Au fur et à mesure que j'écris, je me rends compte que la valeur recherchée est très aléatoire et je n'aurai pas de valeur réellement déterminante pour savoir jusqu'où "l'infini" du programme peut aller.

Je réitère donc ma demande, si quelqu'un pouvait éclaircir ce point encore fort obscur, j'en serais extrêmement ravi.

Au plaisir,

Aenonis

[Chanur]

Bonjour,
J'ai un vieux bout de code qui fait ça. Le truc c'est de faire varier l'incrément de taille mémoire. Et il n'y a pas besoin de faire planter le programme, il suffit de regarder la valeur de retour de malloc.

#include <stdio.h>
#include <stdlib.h>
main()
    {
    unsigned long int taille=5000000; // valeur parfaitement arbitraire ...
    unsigned long int increment;
    void * p = 0;


    do
        {
        if (p)
            {
            printf ("taille allouee = %lu octets\r", taille);
            free (p);
            taille *= 2;
            }
        p = malloc (taille);
        }
    while (p);


    increment = taille/2;
    while (increment > 2)
        {
        p = malloc (taille);
        if (p)
            {
            free (p);
            p=0;
            taille += increment;
            }
        else
            {
            increment /=2;
            taille -= increment;
            }
        printf ("taille allouee = %lu octets\r", taille);
        }
    printf ("\ntaille allouee maxi : %lu octets = %.0lf k octets = %.1lf M octets = %.1lf G octets\n", taille, taille /1024., taille / 1024. / 1024., taille / 1024. / 1024. / 1024.);
    return 0;
    }

[Aenonis]

Bonjour cher Charnur,

Je te remercie pour le code.

Je l'ai modifié à ma convenance sans rien toucher à l'algorithme en tant que tel.

Voici le code nouvellement modifié:

#include <stdlib.h>

#include <iostream>
using namespace std;

void getTaille(unsigned long long int taille);

int main(int argc, char *argv[])
{
    getTaille(200*(1024*1024)); //200 Mo
    getTaille(750*(1024*1024)); //750 Mo
    return 0;
}

void getTaille(unsigned long long int taille)
{
    void *p=NULL;
    do
    {
        if (p)
        {
            cout << "Taille allouee: " << taille/(1024.*1024.) << " Mo" << endl;
            free(p);
            taille*=2;
        }
        p=malloc(taille);
    }
    while (p);
    cout << "Millieu procedure" << endl;
    unsigned long long int increment=taille/2;
    while (increment>2)
    {
        p=malloc(taille);
        if (p)
        {
            free(p);
            p=NULL;
            taille+=increment;
        }
        else
        {
            increment/=2;
            taille-=increment;
        }
        cout << "Taille allouee: " << taille/(1024.*1024.) << " Mo" << endl;
    }
    cout << "Taille allouee maximum:" << endl;
    cout << "octets: " << taille << endl;
    cout << "Ko    : " << taille/(1024.) << endl;
    cout << "Mo    : " << taille/(1024.*1024.) << endl;
    cout << "Go    : " << taille/(1024.*1024.*1024.) << endl;
}

Lorsque j'exécute ce code, l'affichage me fait penser au temps de vol de la conjecture de Syracuse (ça monte, ça descend et ça se stabilise ensuite).

La valeur en Mo finale des deux appels (200 et 750 Mo) est exactement la même (959.812 Mo) mais ce que je ne comprends pas, c'est que lors de l'algorithme, surtout juste après l'affichage du milieu de procédure, la valeur maximale prend 1200 Mo pour la fonction 200 Mo et 1125 Mo pour celle à 750 Mo, vu que le malloc a réussi avec ces deux valeurs maximales, pourquoi l'algo nous répond 959.812 Mo comme valeur maximale, l'algo est sans doute juste vu que je peux lui fournir n'importe quelle valeur, il me répondra toujours 959.812 Mo, mais il y a un truc qui ne me revient pas.

Sinon, j'ai arrêté mon programme qui tournait en boucle, il était déjà à 1.5 Go de pris, après trois heures, évidemment, en allouant octet par octet, ça va pas vite...

La valeur retournée par l'algo ne correspond pas avec le 1.5 Go, si ton algo m'aurait renvoyé 2 Go, là d'accord, sujet classé, mais là, il me renvoie une valeur nettement plus petite (-33%) que lors de la fermeture du programme initial.

En te remerciant,

Aenonis

[A voir en vidéo sur Futura]

[lou_ibmix_xi]

Salut,

Tu fais fausse route, il faudrait déjà que l'on sache quel système d'exploitation tu utilises, puis éventuellement à l'implémentation de la bibliothèque standard que tu utilises pour vérifier comment sont implémenter le "malloc" (ou le new pour le C++).
En effet, suivant les implémentations, "malloc" peut ne pas renvoyer NULL alors qu'il ny a plus d'espace disponible, l'espace allouable est souvent séparrer en morceaux de tailles variables mais fixées, et un "malloc (n)" renverra un pointeur sur une zone libre dont la taille est supérieure ou égale à n, donc tester octets par octets n'est pas pertinent...
Une dernière remarque, dépendant de la finalité réelle de ton programme: si il est ammené à évoluer, si la quantité de mémoire dépends fortement du type d'entrée, ou si il doit être diffusé "largement", il peut être opportun de trouver une stratégie pour pallier au besoin de mémoire qui ne sera pas forcément disponible: utiliser des fichiers pour stocker des résultats intermédiaire, prévoir un implémentation parallèle etc...

[Aenonis]

En fait, c'est toujours le même programme sur lequel je bosse, à savoir les nombres.

Les nombres sont de taille "infinie", on peut avoir autant de chiffres qu'on veut, le programme est fait pour.

Mais lors du renseignement en exponentielle, par exemple "1e100", je crée une liste commençant par '1' et 100 zéros derrière.

J'ai essayé de valeurs plus grandes (jusqu'à 10 millions de zéros derrière), mais à 100 millions, le programme m'a dit merde.

Je dois avoir ces zéros quelque part, parce que si je veux faire une opération sur ce nombre à 10 millions de chiffres (parmi les 5 usuelles, '+', '-', '*', '/', '%'), le nombre doit être contenu quelque part.

Genre

Nombre("1e10000000")-1;

Ne devra contenir que des '9', 10 millions de '9'.

J'ai calculé le temps en secondes que prenait la construction, l'opération et la destruction de l'objet:
- 6 secondes pour la construction
- une minute pour la soustraction
- 4 secondes pour la destruction

Évidemment, j'ai pris un extrême, le million ne prend que 10 secondes pour le tout, et un temps tout à fait acceptable pour les valeurs moindres.

Je pourrais également modifier la façon dont je gère les nombres mais je devrai réécrire tous mes algorithmes (les 5 opérations de base).

Voilà,

Au plaisir,

Aenonis

PS: Si un modo pouvait regrouper les sujets "[C++] Taille maximale autorisée en RAM" et "[Regex] Une regex bien compliquée à construire..." en un seul fil de discussion, ça m'arrangerait, vu que je parle du même programme.

[bzh_nicolas]

Sous Windows :
- programme compilé en 32 bits : 2 Go
- programme compilé en 64 bits : 8 To

Sous Linux, c'est plus variable et ça dépend des kernels. Certains systèmes 64 bits montent jusqu'à 128 To (certaines debian par exemple). Il y a peut-être des limites plus élevées.
Tu devrais pouvoir trouver ces infos dans les docs techniques des différents kernels si tu utilises Linux.