I have experienced a lot of heated debates about the performance of the old opengl rendering functions VS the new rendering functions on this portal, but also elsewhere nowadays.

So i have created a little program to measure the draw call performance in opengl to see what is the situation.

From now on, i am not going to debate anything regarding to this question because i am not going to repeat myself again and again (immediate mode vs lists vs vertex array vs vertex buffer object), if anyone brings up the question, i will simply link this topic to them.

I have measured multiple video cards from multiple vendors.

If someone finds this useful, then my BCH (bitcoin cash) address is:

bitcoincash:qqg9ccd6wjrdexu7xqpm6akphp7zdc25zvtdvn8wd0

And then i might try to benchmark more video cards from more vendors and a few generations older/newer, or if someone wants to try this tool, send me the price of my food for this weekend, and i upload the binaries and source code to shithub.

I am not going to comment the results, everyone can read it up for himself. Except if there is something strange happening with one of the parameters.

Platform: Linux
Vendor: Nouveau
Card: nVidia Quadro 4000

Vendor: nouveau
GPU: NVC0
Version: 4.3 (Compatibility Profile) Mesa 20.3.5

Raw glVertex3f performance - tiny polygon count (OpenGL 1.0):
   100k polygons at 60 fps max
        (6035298 poly/sec)
        (6035298 pairs/sec when each glBein/glEnd pair contains one triangles)

Raw glVertex3f performance  - small polygon count (OpenGL 1.0):
   255k polygons at 60 fps max
        (15339821 poly/sec)
        (1278318 pairs/sec when each glBein/glEnd pair contains 12 triangles)

Raw glVertex3f performance  - medium polygon count (OpenGL 1.0):
   306k polygons at 60 fps max
        (18395167 poly/sec)
        (61317 pairs/sec when each glBein/glEnd pair contains 300 triangles)

glCallList performance - small polygon count (OpenGL 1.0):
   602k polygons at 60 fps max
        (36152843 poly/sec)
        (301273 call/sec when each call emits 120 poly)

glCallList performance - medium polygon count (OpenGL 1.0):
   701k polygons at 60 fps max
        (42100346 poly/sec)
        (14033 call/sec when each call emits 3000 poly)

glCallList performance - high polygon count (OpenGL 1.0):
   748k polygons at 60 fps max
        (44929016 poly/sec)
        (1096 call/sec when each call emits 40960 poly)

glCallList performance - large polygon count (OpenGL 1.0):
   701k polygons at 60 fps max
        (42063304 poly/sec)
        (160 call/sec when each call emits 262144 poly)

Combined glVertex3f+glTexCoord+glColor performance  - tiny polygon count (OpenGL 1.0):
   61k polygons at 60 fps max
        (3678894 poly/sec)
        (3678894 ninelets/sec)

Combined glVertex3f+glTexCoord+glColor performance - small polygon count (OpenGL 1.0):
   98k polygons at 60 fps max
        (5926345 poly/sec)
        (493862 pairs/sec, where each glBein/glEnd pair contains 12 triangles)

Combined glVertex3f+glTexCoord+glColor performance - medium polygon count (OpenGL 1.0):
   104k polygons at 60 fps max
        (6269908 poly/sec)
        (20899 pairs/sec, where each glBein/glEnd pair contains 300 triangles)

Raw glDrawArrays performance - tiny polygon count (OpenGL 1.1):
   133k polygon at 60 fps max
        (8007507 polygon/sec)
        (667292 call/sec when each call emits 12 poly)

Raw glDrawArrays performance - small polygon count (OpenGL 1.1):
   321k polygon at 60 fps max
        (19314896 polygon/sec)
        (21460 call/sec when each call emits 900 poly)

Raw glDrawArrays performance - medium polygon count (OpenGL 1.1):
   303k polygon at 60 fps max
        (18210124 polygon/sec)
        (1481 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - tiny polygon count (OpenGL 1.5/2.0+):
   137k polygon at 60 fps max
        (8264667 polygon/sec)
        (688722 call/sec when each call emits 12 poly)

Vertex Buffer Object pipeline - small polygon count (OpenGL 1.5/2.0+):
   604k polygon at 60 fps max
        (36277474 polygon/sec)
        (40308 call/sec when each call emits 900 poly)

Vertex Buffer Object pipeline - medium polygon count (OpenGL 1.5/2.0+):
   748k polygon at 60 fps max
        (44920147 polygon/sec)
        (3655 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - large polygon count (OpenGL 1.5/2.0+):
   842k polygon at 60 fps max
        (50545599 polygon/sec)
        (257 call/sec when each call emits 196608 poly)

Platform: Linux
vendor: XORG
Card: AMD HD5670

Vendor: X.Org
GPU: AMD REDWOOD (DRM 2.50.0 / 5.18.18, LLVM 11.0.1)
Version: 3.1 Mesa 20.3.5

Raw glVertex3f performance - tiny polygon count (OpenGL 1.0):
   103k polygons at 60 fps max
        (6198369 poly/sec)
        (6198369 pairs/sec when each glBein/glEnd pair contains one triangles)

Raw glVertex3f performance  - small polygon count (OpenGL 1.0):
   278k polygons at 60 fps max
        (16730839 poly/sec)
        (1394236 pairs/sec when each glBein/glEnd pair contains 12 triangles)

Raw glVertex3f performance  - medium polygon count (OpenGL 1.0):
   330k polygons at 60 fps max
        (19832724 poly/sec)
        (66109 pairs/sec when each glBein/glEnd pair contains 300 triangles)

glCallList performance - small polygon count (OpenGL 1.0):
   2428k polygons at 60 fps max
        (145709299 poly/sec)
        (1214244 call/sec when each call emits 120 poly)

glCallList performance - medium polygon count (OpenGL 1.0):
   3989k polygons at 60 fps max
        (239394247 poly/sec)
        (79798 call/sec when each call emits 3000 poly)

glCallList performance - high polygon count (OpenGL 1.0):
   4084k polygons at 60 fps max
        (245053738 poly/sec)
        (5982 call/sec when each call emits 40960 poly)

glCallList performance - large polygon count (OpenGL 1.0):
   4017k polygons at 60 fps max
        (241046098 poly/sec)
        (919 call/sec when each call emits 262144 poly)

Combined glVertex3f+glTexCoord+glColor performance  - tiny polygon count (OpenGL 1.0):
   64k polygons at 60 fps max
        (3856553 poly/sec)
        (3856553 ninelets/sec)

Combined glVertex3f+glTexCoord+glColor performance - small polygon count (OpenGL 1.0):
   110k polygons at 60 fps max
        (6641820 poly/sec)
        (553485 pairs/sec, where each glBein/glEnd pair contains 12 triangles)

Combined glVertex3f+glTexCoord+glColor performance - medium polygon count (OpenGL 1.0):
   118k polygons at 60 fps max
        (7137720 poly/sec)
        (23792 pairs/sec, where each glBein/glEnd pair contains 300 triangles)

Raw glDrawArrays performance - tiny polygon count (OpenGL 1.1):
   112k polygon at 60 fps max
        (6768995 polygon/sec)
        (564082 call/sec when each call emits 12 poly)

Raw glDrawArrays performance - small polygon count (OpenGL 1.1):
   1355k polygon at 60 fps max
        (81302334 polygon/sec)
        (90335 call/sec when each call emits 900 poly)

Raw glDrawArrays performance - medium polygon count (OpenGL 1.1):
   1379k polygon at 60 fps max
        (82741742 polygon/sec)
        (6733 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - tiny polygon count (OpenGL 1.5/2.0+):
   129k polygon at 60 fps max
        (7742877 polygon/sec)
        (645239 call/sec when each call emits 12 poly)

Vertex Buffer Object pipeline - small polygon count (OpenGL 1.5/2.0+):
   3784k polygon at 60 fps max
        (227049801 polygon/sec)
        (252277 call/sec when each call emits 900 poly)

Vertex Buffer Object pipeline - medium polygon count (OpenGL 1.5/2.0+):
   4067k polygon at 60 fps max
        (244063926 polygon/sec)
        (19861 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - large polygon count (OpenGL 1.5/2.0+):
   4203k polygon at 60 fps max
        (252214587 polygon/sec)
        (1282 call/sec when each call emits 196608 poly)

Platform: Linux
Vendor: mesa
Card: Software rendering (Phenom2/6 cores)

Vendor: Mesa/X.org
GPU: llvmpipe (LLVM 11.0.1, 128 bits)
Version: 3.1 Mesa 20.3.5

Raw glVertex3f performance - tiny polygon count (OpenGL 1.0):
   60k polygons at 60 fps max
        (3630192 poly/sec)
        (3630192 pairs/sec when each glBein/glEnd pair contains one triangles)

Raw glVertex3f performance  - small polygon count (OpenGL 1.0):
   123k polygons at 60 fps max
        (7418670 poly/sec)
        (618222 pairs/sec when each glBein/glEnd pair contains 12 triangles)

Raw glVertex3f performance  - medium polygon count (OpenGL 1.0):
   133k polygons at 60 fps max
        (7990041 poly/sec)
        (26633 pairs/sec when each glBein/glEnd pair contains 300 triangles)

glCallList performance - small polygon count (OpenGL 1.0):
   225k polygons at 60 fps max
        (13515370 poly/sec)
        (112628 call/sec when each call emits 120 poly)

glCallList performance - medium polygon count (OpenGL 1.0):
   240k polygons at 60 fps max
        (14403012 poly/sec)
        (4801 call/sec when each call emits 3000 poly)

glCallList performance - high polygon count (OpenGL 1.0):
   238k polygons at 60 fps max
        (14308087 poly/sec)
        (349 call/sec when each call emits 40960 poly)

glCallList performance - large polygon count (OpenGL 1.0):
   231k polygons at 60 fps max
        (13870133 poly/sec)
        (52 call/sec when each call emits 262144 poly)

Combined glVertex3f+glTexCoord+glColor performance  - tiny polygon count (OpenGL 1.0):
   39k polygons at 60 fps max
        (2385952 poly/sec)
        (2385952 ninelets/sec)

Combined glVertex3f+glTexCoord+glColor performance - small polygon count (OpenGL 1.0):
   61k polygons at 60 fps max
        (3660502 poly/sec)
        (305041 pairs/sec, where each glBein/glEnd pair contains 12 triangles)

Combined glVertex3f+glTexCoord+glColor performance - medium polygon count (OpenGL 1.0):
   63k polygons at 60 fps max
        (3794626 poly/sec)
        (12648 pairs/sec, where each glBein/glEnd pair contains 300 triangles)

Raw glDrawArrays performance - tiny polygon count (OpenGL 1.1):
   73k polygon at 60 fps max
        (4422846 polygon/sec)
        (368570 call/sec when each call emits 12 poly)

Raw glDrawArrays performance - small polygon count (OpenGL 1.1):
   230k polygon at 60 fps max
        (13831875 polygon/sec)
        (15368 call/sec when each call emits 900 poly)

Raw glDrawArrays performance - medium polygon count (OpenGL 1.1):
   239k polygon at 60 fps max
        (14349493 polygon/sec)
        (1167 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - tiny polygon count (OpenGL 1.5/2.0+):
   65k polygon at 60 fps max
        (3902824 polygon/sec)
        (325235 call/sec when each call emits 12 poly)

Vertex Buffer Object pipeline - small polygon count (OpenGL 1.5/2.0+):
   229k polygon at 60 fps max
        (13780465 polygon/sec)
        (15311 call/sec when each call emits 900 poly)

Vertex Buffer Object pipeline - medium polygon count (OpenGL 1.5/2.0+):
   238k polygon at 60 fps max
        (14297107 polygon/sec)
        (1163 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - large polygon count (OpenGL 1.5/2.0+):
   234k polygon at 60 fps max
        (14041602 polygon/sec)
        (71 call/sec when each call emits 196608 poly)

platform: Windows
vendor: nVidia
card: quadro 4000

Vendor: NVIDIA Corporation
GPU: Quadro 4000/PCIe/SSE2
Version: 4.5.0 NVIDIA 377.83

Raw glVertex3f performance - tiny polygon count (OpenGL 1.0):
   188k polygons at 60 fps max
        (11291929 poly/sec)
        (11291929 pairs/sec when each glBein/glEnd pair contains one triangles)

Raw glVertex3f performance  - small polygon count (OpenGL 1.0):
   192k polygons at 60 fps max
        (11572996 poly/sec)
        (964416 pairs/sec when each glBein/glEnd pair contains 12 triangles)

Raw glVertex3f performance  - medium polygon count (OpenGL 1.0):
   314k polygons at 60 fps max
        (18886679 poly/sec)
        (62955 pairs/sec when each glBein/glEnd pair contains 300 triangles)

glCallList performance - small polygon count (OpenGL 1.0):
   2847k polygons at 60 fps max
        (170860927 poly/sec)
        (1423841 call/sec when each call emits 120 poly)

glCallList performance - medium polygon count (OpenGL 1.0):
   100k polygons at 60 fps max
        (6059381 poly/sec)
        (2019 call/sec when each call emits 3000 poly)

glCallList performance - high polygon count (OpenGL 1.0):
   12621k polygons at 60 fps max
        (757266424 poly/sec)
        (18487 call/sec when each call emits 40960 poly)

glCallList performance - large polygon count (OpenGL 1.0):
   69k polygons at 60 fps max
        (4177593 poly/sec)
        (15 call/sec when each call emits 262144 poly)

Combined glVertex3f+glTexCoord+glColor performance  - tiny polygon count (OpenGL
 1.0):
   127k polygons at 60 fps max
        (7646276 poly/sec)
        (7646276 ninelets/sec)

Combined glVertex3f+glTexCoord+glColor performance - small polygon count (OpenGL
 1.0):
   168k polygons at 60 fps max
        (10136452 poly/sec)
        (844704 pairs/sec, where each glBein/glEnd pair contains 12 triangles)

Combined glVertex3f+glTexCoord+glColor performance - medium polygon count (OpenG
L 1.0):
   109k polygons at 60 fps max
        (6540018 poly/sec)
        (21800 pairs/sec, where each glBein/glEnd pair contains 300 triangles)

Raw glDrawArrays performance - tiny polygon count (OpenGL 1.1):
   230k polygon at 60 fps max
        (13801916 polygon/sec)
        (1150159 call/sec when each call emits 12 poly)

Raw glDrawArrays performance - small polygon count (OpenGL 1.1):
   485k polygon at 60 fps max
        (29116790 polygon/sec)
        (32351 call/sec when each call emits 900 poly)

Raw glDrawArrays performance - medium polygon count (OpenGL 1.1):
   80k polygon at 60 fps max
        (4842879 polygon/sec)
        (394 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - tiny polygon count (OpenGL 1.5/2.0+):
   310k polygon at 60 fps max
        (18658892 polygon/sec)
        (1554907 call/sec when each call emits 12 poly)

Vertex Buffer Object pipeline - small polygon count (OpenGL 1.5/2.0+):
   2782k polygon at 60 fps max
        (166942696 polygon/sec)
        (185491 call/sec when each call emits 900 poly)

Vertex Buffer Object pipeline - medium polygon count (OpenGL 1.5/2.0+):
   99k polygon at 60 fps max
        (5956374 polygon/sec)
        (484 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - large polygon count (OpenGL 1.5/2.0+):
   95k polygon at 60 fps max
        (5756065 polygon/sec)
        (29 call/sec when each call emits 196608 poly)

strange things:

The anemic speed of call lists and vbos with some sizes is correct, i have measured it multiple times, and even changed the algorithm multiple times a little bit as well to see if something changes, but not. It seems the drivers wildly swapping in and out the vertex data from the gpu. Most of the problems occur when a lot of polygons are being forced in with a single draw operation (even with a normal vertex array one) and smaller chunks are okay.

Geri said:
So i have created a little program to measure the draw call performance in opengl to see what is the situation.

We need more detail regarding draw call vs. upload to GPU memory.

I assume you generate the display lists and VBOs just once, so the driver loads them up just once, and then the upload does not affect the actual rendering and perf. measurements? (I can't remember about Arrays and what's their option there.)

This is quite important to know, otherwise your numbers are useless. From my experience the upload has by far the highest cost. But if you do it just once as intended, i wonder why glVertex isn't much slower at all, which has to upload every frame.

This could be eventually because the GPUs are very old, and rendering itself becomes the bottleneck. But usually, when we whine about draw call costs, we worry about CPU costs of the driver, not the rendering on GPU.

So i think you should elaborate a bit more on your test regarding those details. Also it would be good to know if the bottleneck is on CPU or GPU if you can tell.

Geri said:
and i upload the binaries and source code to shithub.

This would actually answer all those questions. I doubt anyone will pay you a coffee for a simple benchmark anyway.

platform: Windows
driver: AMD
card: Radeon HD5670

Vendor: ATI Technologies Inc.
GPU: AMD Radeon HD 5670
Version: 4.5.13399 Compatibility Profile Context 15.200.1062.1004

Raw glVertex3f performance - tiny polygon count (OpenGL 1.0):
   133k polygons at 60 fps max
        (8007687 poly/sec)
        (8007687 pairs/sec when each glBein/glEnd pair contains one triangles)

Raw glVertex3f performance  - small polygon count (OpenGL 1.0):
   476k polygons at 60 fps max
        (28580879 poly/sec)
        (2381739 pairs/sec when each glBein/glEnd pair contains 12 triangles)

Raw glVertex3f performance  - medium polygon count (OpenGL 1.0):
   416k polygons at 60 fps max
        (24983344 poly/sec)
        (83277 pairs/sec when each glBein/glEnd pair contains 300 triangles)

glCallList performance - small polygon count (OpenGL 1.0):
   3521k polygons at 60 fps max
        (211295681 poly/sec)
        (1760797 call/sec when each call emits 120 poly)

Combined glVertex3f+glTexCoord+glColor performance  - tiny polygon count (OpenGL
 1.0):
   90k polygons at 60 fps max
        (5419190 poly/sec)
        (5419190 ninelets/sec)

Combined glVertex3f+glTexCoord+glColor performance - small polygon count (OpenGL
 1.0):
   194k polygons at 60 fps max
        (11680726 poly/sec)
        (973393 pairs/sec, where each glBein/glEnd pair contains 12 triangles)

Combined glVertex3f+glTexCoord+glColor performance - medium polygon count (OpenG
L 1.0):
   140k polygons at 60 fps max
        (8455997 poly/sec)
        (28186 pairs/sec, where each glBein/glEnd pair contains 300 triangles)

Raw glDrawArrays performance - tiny polygon count (OpenGL 1.1):
   489k polygon at 60 fps max
        (29384513 polygon/sec)
        (2448709 call/sec when each call emits 12 poly)

Raw glDrawArrays performance - small polygon count (OpenGL 1.1):
   920k polygon at 60 fps max
        (55214723 polygon/sec)
        (61349 call/sec when each call emits 900 poly)

Raw glDrawArrays performance - medium polygon count (OpenGL 1.1):
   1008k polygon at 60 fps max
        (60492287 polygon/sec)
        (4922 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - tiny polygon count (OpenGL 1.5/2.0+):
   303k polygon at 60 fps max
        (18205804 polygon/sec)
        (1517150 call/sec when each call emits 12 poly)

Vertex Buffer Object pipeline - small polygon count (OpenGL 1.5/2.0+):
   3889k polygon at 60 fps max
        (233377659 polygon/sec)
        (259308 call/sec when each call emits 900 poly)

Vertex Buffer Object pipeline - medium polygon count (OpenGL 1.5/2.0+):
   4259k polygon at 60 fps max
        (255577418 polygon/sec)
        (20798 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - large polygon count (OpenGL 1.5/2.0+):
   4344k polygon at 60 fps max
        (260654545 polygon/sec)
        (1325 call/sec when each call emits 196608 poly)

Display Lists with bigger vertex count probably got optimized by the AMD driver, because i am getting unlimited polygons per sec. Those results are deleted from this.

JoeJ said:
I assume you generate the display lists and VBOs just once, so the driver loads them up just once, and then the upload does not affect the actual rendering and perf. measurements? (I can't remember about Arrays and what's their option there.)

Yes. Well thats the point of VBOs and display lists anyway. You create them once, and render them again and again.
Fill rate cant be the bottleneck here, because no vertex gets rendered. Every vertex is behind the camera.
The system i used to generate these results is a pci-e 1.0 system with a phenom2 based 6 core cpu at 2 ghz.
The bandwidth to gpu is crippled, tho all cards ran at pci-e16x mode.

Platform: Windows
Vendor: Matrox
Card: Matrox M9120

Vendor: Matrox Graphics Inc.
GPU: Matrox ICD for M-Series
Version: 2.0

Raw glVertex3f performance - tiny polygon count (OpenGL 1.0):
   79k polygons at 60 fps max
        (4770992 poly/sec)
        (4770992 pairs/sec when each glBein/glEnd pair contains one triangles)

Raw glVertex3f performance  - small polygon count (OpenGL 1.0):
   131k polygons at 60 fps max
        (7892140 poly/sec)
        (657678 pairs/sec when each glBein/glEnd pair contains 12 triangles)

Raw glVertex3f performance  - medium polygon count (OpenGL 1.0):
   140k polygons at 60 fps max
        (8437500 poly/sec)
        (28125 pairs/sec when each glBein/glEnd pair contains 300 triangles)

glCallList performance - small polygon count (OpenGL 1.0):
   102k polygons at 60 fps max
        (6166495 poly/sec)
        (51387 call/sec when each call emits 120 poly)

glCallList performance - medium polygon count (OpenGL 1.0):
   316k polygons at 60 fps max
        (19017432 poly/sec)
        (6339 call/sec when each call emits 3000 poly)

glCallList performance - high polygon count (OpenGL 1.0):
   292k polygons at 60 fps max
        (17560557 poly/sec)
        (428 call/sec when each call emits 40960 poly)

glCallList performance - large polygon count (OpenGL 1.0):
   260k polygons at 60 fps max
        (15636385 poly/sec)
        (59 call/sec when each call emits 262144 poly)

Combined glVertex3f+glTexCoord+glColor performance  - tiny polygon count (OpenGL
 1.0):
   63k polygons at 60 fps max
        (3780718 poly/sec)
        (3780718 ninelets/sec)

Combined glVertex3f+glTexCoord+glColor performance - small polygon count (OpenGL
 1.0):
   92k polygons at 60 fps max
        (5529953 poly/sec)
        (460829 pairs/sec, where each glBein/glEnd pair contains 12 triangles)

Combined glVertex3f+glTexCoord+glColor performance - medium polygon count (OpenG
L 1.0):
   95k polygons at 60 fps max
        (5705229 poly/sec)
        (19017 pairs/sec, where each glBein/glEnd pair contains 300 triangles)

Raw glDrawArrays performance - tiny polygon count (OpenGL 1.1):
   205k polygon at 60 fps max
        (12347266 polygon/sec)
        (1028938 call/sec when each call emits 12 poly)

Raw glDrawArrays performance - small polygon count (OpenGL 1.1):
   210k polygon at 60 fps max
        (12654668 polygon/sec)
        (14060 call/sec when each call emits 900 poly)

Raw glDrawArrays performance - medium polygon count (OpenGL 1.1):
   210k polygon at 60 fps max
        (12605231 polygon/sec)
        (1025 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - tiny polygon count (OpenGL 1.5/2.0+):
   1k polygon at 60 fps max
        (109880 polygon/sec)
        (9156 call/sec when each call emits 12 poly)

Vertex Buffer Object pipeline - small polygon count (OpenGL 1.5/2.0+):
   65k polygon at 60 fps max
        (3917301 polygon/sec)
        (4352 call/sec when each call emits 900 poly)

Vertex Buffer Object pipeline - medium polygon count (OpenGL 1.5/2.0+):
   166k polygon at 60 fps max
        (10017391 polygon/sec)
        (815 call/sec when each call emits 12288 poly)

Vertex Buffer Object pipeline - large polygon count (OpenGL 1.5/2.0+):
   213k polygon at 60 fps max
        (12827838 polygon/sec)
        (65 call/sec when each call emits 196608 poly)

verdict: Do not render small chunks with VBO-s on Matrox M9120

Platform: Windows
Vendor: nVidia
Chip: TNT 1

Vendor: NVIDIA Corporation
GPU: RIVA TNT/AGP
Version: 1.1.3

Raw glVertex3f performance - tiny polygon count (OpenGL 1.0):
   3k polygons at 60 fps max
        (185873 poly/sec)
        (185873 pairs/sec when each glBein/glEnd pair contains one triangles)

Raw glVertex3f performance  - small polygon count (OpenGL 1.0):
   4k polygons at 60 fps max
        (287081 poly/sec)
        (23923 pairs/sec when each glBein/glEnd pair contains 12 triangles)

Raw glVertex3f performance  - medium polygon count (OpenGL 1.0):
   4k polygons at 60 fps max
        (287631 poly/sec)
        (958 pairs/sec when each glBein/glEnd pair contains 300 triangles)

Combined glVertex3f+glTexCoord+glColor performance  - tiny polygon count (OpenGL
 1.0):
   2k polygons at 60 fps max
        (131061 poly/sec)
        (131061 ninelets/sec)

Combined glVertex3f+glTexCoord+glColor performance - small polygon count (OpenGL
 1.0):
   2k polygons at 60 fps max
        (158311 poly/sec)
        (13192 pairs/sec, where each glBein/glEnd pair contains 12 triangles)

Combined glVertex3f+glTexCoord+glColor performance - medium polygon count (OpenG
L 1.0):
   2k polygons at 60 fps max
        (150526 poly/sec)
        (501 pairs/sec, where each glBein/glEnd pair contains 300 triangles)

Raw glDrawArrays performance - tiny polygon count (OpenGL 1.1):
   5k polygon at 60 fps max
        (338504 polygon/sec)
        (28208 call/sec when each call emits 12 poly)

Raw glDrawArrays performance - small polygon count (OpenGL 1.1):
   6k polygon at 60 fps max
        (381033 polygon/sec)
        (423 call/sec when each call emits 300 poly)

Raw glDrawArrays performance - medium polygon count (OpenGL 1.1):
   6k polygon at 60 fps max
        (373268 polygon/sec)
        (30 call/sec when each call emits 1288 poly)

GLLists produced unlimit polygons/sec on the RivaTNT so i removed those.

cpu used for this was 6x86mx at 250mhz