Allocation dynamique au lancement d'un programme

Version imprimable

02/07/2013, 11h11
kipgon

Allocation dynamique au lancement d'un programme

Salut salut,

je viens (encore :oops:) vous poser quelques questions sur l'allocation de la mémoire !

Voici mon problème :

j'ai un programme qui fais un calcul nécessitant de grands tableaux. Pour le moment je déclarais mes tableaux en statique, seulement je suis limité et je ne peux pas déclarer de tableaux au dessus d'une certaine taille.

Je me suis donc mis à déclarer mes tableaux en dynamique. Le problème cette fois était que ma fonction de calcul était beaucoup plus longue du fait justement de l'allocation dynamique.

Je me suis donc mis à vouloir déclarer mes tableaux de manière dynamique mais cette fois ci dans ma fenêtre principale (les tableaux étant des std::vector privé de ma classe "Fenêtre Principale").

Je me disais qu'ainsi ma fonction de calcul serait plus rapide étant donné que l'allocation mémoire serait faites au lancement du programme. Mais en fait pas du tout :cry: !!!

Je ne comprends pas tout à fait ce qu'il se passe et comme je suis encore débutant je me permet de vous demander vôtre avis sur ce que je fais !

Merci d'avance
02/07/2013, 11h57
koala01

Salut,

Que tu utilises simplement l'allocation dynamique ou un std::vector va, de toutes manières, présenter le même problème: l'augmentation de la taille va prendre énormément de temps car il s'agit d'allouer de la mémoire pour la nouvelle taille, de copier les différents éléments contenus dans ton tableau, pour enfin, libérer la mémoire de l'ancien tableau.

L'idéal est donc d'essayer de réserver directement la taille pour l'ensemble des éléments que tu devras placer, s'il t'est possible de définir le nombre d'éléments que tu vas manipuler au total, du moins.

Ceci dit, sans voir ton code, il nous sera très difficile de pouvoir t'aider en aucune manière, car les boulles de crystal on tendance à avoir des ratés en période de vacances ;)
02/07/2013, 12h01
imperio

Citation:

Envoyé par kipgon

Je me disais qu'ainsi ma fonction de calcul serait plus rapide étant donné que l'allocation mémoire serait faites au lancement du programme. Mais en fait pas du tout :cry: !!!

Ba non, l'allocation dynamique se fait au moment ou le programme rentre dans la fonction qui la fait. De plus j'aurais tendance a penser que tu ne liberes pas la memoire d'apres ce que tu dis (pas bien !).

Pour les variables statiques, elles sont "allouees" la premiere fois que le programme rentre dans la fonction puis liberer lorsque le programme se termine. Dans ton cas j'aurais tendance a penser que des variables statiques seraient plus interessantes mais t'as besoin de tableaux de tailles diverses c'est bien ca ? T'as pas une taille maximale ?
02/07/2013, 13h42
Bousk

Bonjour,

peut-être qu'en prenant le problème dans un autre sens tu pourrais simplement te passer de tableaux et travailler avec moins de valeurs "en même temps".
la nécessité de "grands tableaux" vient le plus souvent d'une incompréhension que d'une nécessité, à fortiori en débutant.
02/07/2013, 13h59
jabbounet

Citation:

Envoyé par kipgon

Salut salut,
Je me suis donc mis à vouloir déclarer mes tableaux de manière dynamique mais cette fois ci dans ma fenêtre principale (les tableaux étant des std::vector privé de ma classe "Fenêtre Principale").

Si tu utilise des std::vector et que tu es capable de déterminer la taille de ces dernier avant le calcul, tu peux utiliser la fonction reserve() pour préparer la place mémoire nécéssaire.

Cela peut avoir un impact ou pas, tout dépend de la façon dont tu utilise ton vecteur.
02/07/2013, 17h17
kipgon

J'ai bien une taille maximale, mais si je déclare en statique mes tableaux de cette taille, mon programme plante quand je clique sur le bouton connecté à ma fonction de calcul !

J'imagine que c'est une question d'espace mémoire mais je ne m'y connais pas vraiment :?.

En tout cas on m'a dit que pour de grosse quantité de donnée il valait mieux prendre la mémoire sur le tas plutôt que sur la pile donc je suis passé en dynamique.

De plus si j'ai entrepris de déclarer au lancement de mon programme mes tableaux plutôt que dans la fonction de calcul c'est parce qu'il me semble que les programmes tel que Matlab font de même, au lancement ils prennent un gros espace de la mémoire puis ils utilisent cette mémoire en fonction des besoins.

Cela dit, j'ai du mal m'exprimer imperio, la déclaration dynamique ne se fait PAS dans ma fonction de calcul, elle se fait dans ma classe représentant ma fenêtre principale donc à l'ouverture du programme. C'est pour cela que je pose cette question de cout temporelle car je pensais qu'en déclarant mes tableaux avant ma fonction cela ferait que, l'allocation étant déjà effectué, le calcul soit aussi rapide qu'avec des tableaux statique.

Mais bon j'ai fait un petit test pour des tableaux de 200 par 200 en ne réalisant qu'un calcul sur les 30 par 30 premières variables, il prend le même temps qu'avec une déclaration de tableau en 30 par 30 avec un calcul en 30 par 30. Aussi je me pose une question : est ce que le simple fait de modifier une "case" de tableau dynamique est plus long que de modifier une "case" de tableau statique ?
02/07/2013, 18h12
koala01

Pourrais tu, comme tu ne sembles pas avoir compris l'allusion, au moins nous montrer ton code, parce que, comme cela, nous aurons vraiment énormément de mal à t'aider !

Tu veux de l'aide :question:, alors, aide nous à t'aider en nous montrant ce que tu as fait ;)

Citation:

Envoyé par kipgon

Mais bon j'ai fait un petit test pour des tableaux de 200 par 200 en ne réalisant qu'un calcul sur les 30 par 30 premières variables, il prend le même temps qu'avec une déclaration de tableau en 30 par 30 avec un calcul en 30 par 30. Aussi je me pose une question : est ce que le simple fait de modifier une "case" de tableau dynamique est plus long que de modifier une "case" de tableau statique ?

L'accès est très certainement un peu plus long en moyenne du fait de la probabilité d'avoir un page fault.

En dehors de ça c'est sensiblement identique.

Il faut juste bien se rendre compte qu'un code type
Code:

1 2 3 4 std::vector<int> vec; for(int i=0; i<1000000; ++i) { vec.push_back(i); }
Sera BEAUCOUP plus long que
Code:

1 2 3 4 5 std::vector<int> vec; vec.reserve(1000001); // Je sais pas trop si le redimensionnement se fait quand size == capacity ou quand size dépasse capacity for(int i=0; i<1000000; ++i) { vec.push_back(i); }
Tout simplement parce qu'a chaque push_back, il peut y avoir un redimensionnement du tableau (avec copie du contenu etc..) et ça, c'est long.

Sinon, l'utilisation d'un tableau à 1 dimension au lieu de 2 amène, de manière générale, un temps d'exécution plus court.

03/07/2013, 10h12
Astraya
Citation:

Code:

vec.reserve(1000001); // Je sais pas trop si le redimensionnement se fait quand size == capacity ou quand size dépasse capacity

reserve fonctionne comme une allocation "normale";
Code:

1 2 vec.reserve(1000000); ~= int vec[1000000];
pas besoin d'allouer 1 de plus que nécessaire ici.

Bonjour et excusez moi pour le retard,

J'ai effectivement la possibilité de réduire le nombre de tableau, ce que je vais faire, mais j'aimerais comprendre pour l'allocation dynamique.

Voici un pseudo code de ce que je fais :

Tout d'abord j'ai créé un objet matrix dans le seul but de me simplifier la vie avec les vectors (linéariser le parcours du tableau etc ...)

ici p est déclaré dans le .h comme ceci :

Code:

vector<double> p;

pour le .cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
matrix::matrix(int dim_i, int dim_j) : m_dim_i(dim_i), m_dim_j(dim_j)
{
    p.resize(m_dim_i*m_dim_j);
 
    for (int i=0; i<m_dim_i; i++)
    {
        for (int j=0; j<m_dim_j; j++)
        {
            p[m_dim_j*i+j] = 0;
        }
    }
}
 
matrix::matrix(int dim_i) : m_dim_i(dim_i), m_dim_j(1)
{
    p.resize(m_dim_i);
 
    for (int i=0; i<m_dim_i; i++)
    {
        p[i] = 0;
    }
}
 
matrix::matrix()
{
 
}
 
matrix::~matrix()
{
 
}
 
matrix &matrix::setSize(int dim_i, int dim_j)
{
    this->~matrix();
 
    m_dim_i= dim_i;
    m_dim_j= dim_j;
 
    p.resize(m_dim_i*m_dim_j);
 
    for (int i=0; i<m_dim_i; i++)
    {
        for (int j=0; j<m_dim_j; j++)
        {
            p[m_dim_j*i+j] = 0;
        }
    }
 
    return *this;
}

Et voici comment je l'utilise :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "matrix.h"
 
FenPrincipale::FenPrincipale()
{
 
    int alloc = 200;
 
    m.setSize(alloc,alloc);
 
QPushButton *boutonCalcul = new QPushButton("Calcul", this);
 
connect(boutonCalcul, SIGNAL(clicked()),this, SLOT(Calcul()));
}
 
void FenPrincipale::Calcul()
{
//Utilisation de m
}

J'espère que je suis clair ;)