Discussion :

[fafacpp]

bonjours a tous,
Voila, je suis en train de réaliser une appli basée sur OpenGL et je viens de m'apercevoir d'une chose bizarre en lancant mon appli avec le "Gestionnaire des taches de Windows" ouvert à l'onglet "Processus" : lorsque je déplace le curseur de la sourie sur la vue OpenGL, sans cliquer, la mémoire utilisée par mon appli augmente à chaque déplacement!!! L'augmentation n'est certes pas énorme, environs 4Ko par déplacement, mais au bout de X déplacements de curseur sur la vue, il arrivera tot ou tard une saturation de la memoire alors que mon appli n'a encore rien créé ni rendu!
Pour en avoir le coeur net, j'ai codé une simple appli win32 qui initialise une vue OpenGL. J'ouvre le "Gestionnaire ..." et là idem : également augmentation de la memoire utilisée par l'appli à chaque déplacement du curseur sur la vue OpenGL!
Je ne sais pas si ca viens de moi, de Windows (Windows XP Pro SP2), du compilo (Code::Block), des libs OpenGL...
Si vous connaissez une solution à cet étrange problème, je vous en serai tres reconnaissant.



Voici la source du code win32 utilisé pour tester:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>
 
/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
void InitOGL(void);
void CloseOGL(void);
 
HWND hWindows;
HINSTANCE hInst;
HDC hDC;
HGLRC hRC;
HWND Label;
 
 
/*  Make the class name into a global variable  */
char szClassName[ ] = "CodeBlocksWindowsApp";
 
int WINAPI WinMain (HINSTANCE hThisInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR lpszArgument,
                     int nCmdShow)
{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */
 
    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);
 
    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
 
    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;
 
    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Code::Blocks Template Windows App",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           544,                 /* The programs width */
           375,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );
 
    /* Make the window visible on the screen */
    ShowWindow (hwnd, nCmdShow);
 
    hWindows = hwnd;
    hInst = hThisInstance;
    InitOGL(); // note : InitOGL() est lancé aprés ShowWindow() et non pas dans un "case WM_CREATE"
               // car "WM_CREATE" est declenché PENDANT la creation de la fenetre et non APRES avoir créé la fenetre.
 
    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }
 
    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}
 
 
/*  This function is called by the Windows function DispatchMessage()  */
 
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)                  /* handle the messages */
    {
 
        case WM_DESTROY:
            CloseOGL();
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }
 
    return 0;
}
 
void InitOGL(void)
{
    PIXELFORMATDESCRIPTOR pfd;
    int format;
    HDC hDC;
    HGLRC hRC;
 
    // creation controle STATIC
    Label = CreateWindow("STATIC", "", WS_VISIBLE|WS_CHILD|SS_SIMPLE,
                          10, 10, 100, 100, hWindows, (HMENU)-1, hInst, NULL );
 
    // get the device context (DC)
    hDC = GetDC( Label );
 
    // set the pixel format for the DC
    ZeroMemory( &pfd, sizeof( pfd ) );
    pfd.nSize = sizeof( pfd );
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
    format = ChoosePixelFormat( hDC, &pfd );
    SetPixelFormat( hDC, format, &pfd );
 
    // create and enable the render context (RC)
    hRC = wglCreateContext( hDC );
    wglMakeCurrent( hDC, hRC );
 
    SwapBuffers(hDC);
 
    // note : en mettent les 3 ligne si dessus en commentaire plus de pb, mais plus de vue OpenGL non plus!
}
 
void CloseOGL(void)
{
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(hRC);
    ReleaseDC(Label, hDC);
}

D'avance merci de lire ce post et cette étrange histoire.
Fafacpp

[Khastarax]

J'ai les mêmes symptomes en C# .net1.1 en utilisant Tao pour l'OpenGL.
Cependant il arrive un moment ou l'utilisation mémoire n'augmente plus. Il s'agit peut être d'un historique d'évenement ou quelquechose du genre.
j'ai aussi remarqué qu'au lancement mon appli occupait 21Mo en mémoire, et une fois réduite et restaurée, elle n'en occupe plus que 6.
Mystère...

[fafacpp]

oui, chez moi aussi l'utilisation de memoire se stabilise lorsque je charge un objet et que je fais un rendu. Si ca reste comme ca c'est pas tres grave mais c'est pas tres clean non plus, il doit surement y avoir une explication..