Averiguar la memoria de vídeo disponible en OpenGL

[marcode]

¿Conocéis alguna función o extensión de OpenGL que me sirva para conocer la cantidad de memoria disponible para texturas? similar a la de DirectX GetAvailableTextureMem.

O alguna otra de windows con la que pueda saber la memoria de vídeo libre, tanto local como AGP.

[DraKKaR]

Creo recordzar que OpenGL (como buen abstractor del hardware que es) no te permite conocer eso directamente. Lo que sí que se peude hacer es un truco alternativo. Puedes hacer que OpenGL, al subir una textura a memoria de video, te diga si ha cabido. Entonces el truco sería ir subiendo texturas enormes de 32Mb, 64M, 128MB. Hasta que no quepa nada. Entonces ya tienes la limitación de memoria que buscabas.

[marcode]

Aunque en principio me puede servir, el problema es que me gustaría saberlo casi constantemente durante la ejecución para llevar un poco el control (más que nada para depurar). Entonces lo de subir texturas grandes debe llevar bastante tiempo (y tampoco me acaba de convencer mucho).

GetAvailableTextureMem cuando lo probé lo he usado continuadamente y no provoca ninguna pérdida de velocidad, es raro que no se pueda conseguir lo mismo de otra forma que no sea usar esa función.

[zupervaca]

Umm, la funcion GetAvailableTextureMem tenia entendido que daba un valor aproximado, ya que la forma en que una tarjeta grafica almacena las texturas no tiene que ser igual que en otra, es decir, una tarjeta grafica puede soportar compresion de texturas y otra no directamente en memoria, con lo que es imposible saber la memoria libre que queda para texturas.
En principio en ogl olvidate de saber cuanta memoria libre tienes ya que esto queda oculto al programador, en teoria, ogl administra todo esto automaticamente, es decir, si hay memoria de video pues la aprovecha y si no, pues a la memoria ram, ademas la textura que es mas usada la deja en la memoria de video o en el agp si esta se esta modificando, la verdad es que habria tanto que explicar que se podria hacer un documento sobre ello.

[Prompt]

Marcode, ¿necesitas conocerla por algún motivo en particular?

[TheAzazel]

Creo que a alguno el verano le ha sentado mal...

y ahora sobre el tema, yo lo que hago para averiguar la cantidad de memoria solo funciona en windows y es...usar GetAvailableTextureMem() :)

ya se que no es portable, pero no se si necesitas que lo sea.

Por lo demas, ya te lo han dicho casi todo...

[marcode]

Umm, la funcion GetAvailableTextureMem tenia entendido que daba un valor aproximado, ya que la forma en que una tarjeta grafica almacena las texturas no tiene que ser igual que en otra, es decir, una tarjeta grafica puede soportar compresion de texturas y otra no directamente en memoria, con lo que es imposible saber la memoria libre que queda para texturas.

Por las pruebas que hice me daba bastante aproximado la memoria de vídeo más la de sistema AGP libre, noté el incremento correspondiente tras subir en el setup de la bios el tamaño de apertura AGP. Supongo que si se puede comprimir o no, será indiferente.

y contando los MB que le hayas tangado a la tarjeta grafica, eso si la has desplumado del todo, que puede que se haya guardao algo, pos ya sabes cuanta ram tienes.

Tendría que saber también cuanta memoria AGP hay, que también me interesa. Además lo de llevar la cuenta me parece un poco coñazo, porque hay que tener en cuenta los mipmaps generados automaticamente, la que se esté usando por otras aplicaciones, la ocupada por buffers de vértices, surfaces, etc.

Marcode, ¿necesitas conocerla por algún motivo en particular?

Para evitar cargar texturas en memoria que no sea de vídeo (muy lenta) y para ver en un mensaje de texto en pantalla continuamente cuando y qué cantidad gasto, tal y como hacía en DX.

y ahora sobre el tema, yo lo que hago para averiguar la cantidad de memoria solo funciona en windows y es...usar GetAvailableTextureMem

Sí, esa usaba yo con DX, el problema es que es un método de IDirect3DDevice9. He echado un vistazo al código de OpenGL Extension Viewer, donde hay un función que según dice usa DX, y que no sé si me servirá, es la única que está declarada en el mismo "cpp" pero no sé a que librería pertenece ni de qué va, tendré que investigar más.

Código [Seleccionar] Expand


unsigned int gvInfoGetAvailableVidMem(void);  // Get total video memory (using DirectX)


Lo que creo es que cuando se refiere a la memoria de textura GetAvailableTextureMem, es a la de vídeo más la agp (que es la que me interesa saber).

[Zaelsius]

Mirate la sección "Get installed video ram":

http://www.gamedev.net/reference/articles/article2281.asp

O en PDF: http://www.lemonteam.com/html/tutorials/pcmac-snippets.pdf

A nosotros nos ha funcionado bien siempre. La versión Mac nunca falla, y la Windows hay veces en las que devuelve algunos megas menos. Haciendo las cuentas(hace ya mucho tiempo de esto..) creo que la cantidad descontada equivalia más o menos al framebuffer en uso(resolucion por profundidad). De todas maneras pruéba el código tú mismo a ver qué tal te anda..

Edit: no habia leido todo..

el problema es que me gustaría saberlo casi constantemente durante la ejecución para llevar un poco el control (más que nada para depurar)

Hmm entonces lo veo bien difícil  :?

[marcode]

Pues sí que está difícil. Además por lo que veo todo pasa por usar DirectX.

Al parecer hay una forma parecida a la que planteo Drakkar al principio, Pero con texturas más pequeñas, me he decidido a probarlo para ver cuanto tiempo llevaba.

He probado a cargar una textura y despues comprobar si está residente en la memoria de texturas con glAreTexturesResident, con el fin de hacer posteriormente un bucle para comprobar la cantidad de memoria en texturas que consigo crear que deberá ser igual a la memoria disponible.

Pero el problema es que siempre me da false (incluso una textura), según parece las texturas pueden no ser subidas a la memoria de video hasta que no se dibuja algo con ella, por lo que lo hago dibujando un punto, pero sigue sin funcionar, me sigue dando FALSE.

Este es el código:

Código [Seleccionar] Expand


  glEnable(GL_TEXTURE_2D);

  GLuint texture;
  glGenTextures(1, &texture);

  glBindTexture(GL_TEXTURE_2D, texture);

  glTexImage2D(GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB,          GL_UNSIGNED_BYTE, NULL); // textura vacia (null)

  glBegin(GL_POINTS);  
      glVertex3f(0,0,0); // dibujo un punto con la textura activa
  glEnd();

  // tres formas diferentes de comprobar si es residente
  GLboolean R1, R2
  GLint R3;

  R1 = glAreTexturesResident(1, &texture, &R2);

  glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_RESIDENT, &R3);

  // las 3 comprobaciones R1,R2,R3, me dan siempre FALSE !!!!!!!!!


¿Alguien ha usado glAreTexturesResident alguna vez?, ¿por qué me da false siempre?, ¿se me ha pasado algo?

Así es que no puedo hacer nada. :(

pd: Mientras buscaba di con un sencillo programilla que sirve para ver el consumo de la memoria de vídeo en tiempo real, me tendré que apañar con él ( Video Memory Watcher )

[swapd0]

Hola, hace tiempo que no toco el OpenGL, pero me acuerdo de una tecnica que usaba cuando programaba en al Atari ST, y queria saber la memoria, sin usar el SO.

Teniendo en cuenta que la memoria maxima era de 4Mb :shock: y la minima de 512Kb :shock: , lo que hacia era:
1 Escribir en la ultima direccion (4Mb-1)
2 Leer el valor, si era el mismo significaba que tenia esa memoria, y salir
3 Decrementar el puntero en 512Kb y volver a 1

Si puedes acceder a la memoria de la targeta como si fuera memoria normal, esto no llevaria mas que un par de lineas de codigo, y seria muy rapido, supongo que podrias decrementar el puntero en potencias de 2, ya que las tarjetas suelen llevar 512Mb, 256Mb, 128Mb...

[marcode]

Sí, se puede acceder a la memoria de vídeo/agp en OpenGL, por lo que se podrá hacer el truco de ir probando cantidades menores potencia de 2, de hecho en un foro guiri uno da esa solución.

De momento probaré a hacerlo con texturas, ya qué al poderse crear vacías no es necesario mover memoria y tal vez sea más rápido. Ya solucioné el problema que tenía, si no selecciono un filtro el punto no se dibuja con textura por lo que nunca sube esta al vídeo, y por eso me daba como no residente.

Voy a hacer el bucle y ya contaré...

[Pablo Zurita]

No hay garantías que glAreTexturesResident te de información útil. Depende de la implementación y el hardware. Por ejemplo en caso de varias placas de 3dlabs, ellos tiene virtualizada la memoria para las texturas entonces solos los texels necesarios residen en memoria, en ese caso tampoco te va a ayudar. Usar vertex buffer objects y tratar de ocupar la memoria restante tampoco sirve porque de nuevo, las implementaciones pueden determinar segmentos de memoria diferentes para cada recurso. Ninguna de las dos alternativas te va a dar información útil. Podes hacer un query básico de memoria podes usar Direct3D o usar SDL usando la función SDL_GetVideoInfo.

[Pablo Zurita]

BTW, Microsoft también te dice que GetAvailableTextureMem es una estimación que no debe ser usada para nada muy específico.

The returned value is rounded to the nearest MB. This is done to reflect the fact that video memory estimates are never precise due to alignment and other issues that affect consumption by certain resources. Applications can use this value to make gross estimates of memory availability to make large-scale resource decisions such as how many levels of a mipmap to attempt to allocate, but applications cannot use this value to make small-scale decisions such as if there is enough memory left to allocate another resource.

[marcode]

Tampoco necesito saber con precisíon, me sirve con un valor aproximado, mega arriba, mega abajo, y GetAvailableTextureMem me funcionaba bastante bien con DX. En principio si lo uso solo para depurar, no me importa que no funcione en otras tarjetas gráficas o en otras implementaciones.

Aquí un tal "Vino" asegura que es posible averiguar hasta el último byte disponible reservando/liberando memoria de vídeo (la última respuesta).