if your code is something like:

for i++ {
glBegin(GL_QUADS)
glTexCoord2f(0.0, 0.0); glVertex3f(i.vertex1[0], i.vertex1[1], i.vertex1[2])
glTexCoord2f(0.0, 1.0); glVertex3f(i.vertex2[0], i.vertex2[1], i.vertex2[2])
glTexCoord2f(1.0, 1.0); glVertex3f(i.vertex3[0], i.vertex3[1], i.vertex3[2])
glTexCoord2f(1.0, 0.0); glVertex3f(i.vertex4[0], i.vertex4[1], i.vertex4[2])
glEnd();
}


try something more like:

glBegin(GL_QUADS)
for i++ {
glTexCoord2f(0.0, 0.0); glVertex3f(i.vertex1[0], i.vertex1[1], i.vertex1[2])
glTexCoord2f(0.0, 1.0); glVertex3f(i.vertex2[0], i.vertex2[1], i.vertex2[2])
glTexCoord2f(1.0, 1.0); glVertex3f(i.vertex3[0], i.vertex3[1], i.vertex3[2])
glTexCoord2f(1.0, 0.0); glVertex3f(i.vertex4[0], i.vertex4[1], i.vertex4[2])
}
glEnd();

Cutting out the extra OpenGL calls should greatly improve rendering.
And since your just rendering a grid, you should use Triangle Strips, that'll cut out a load more glVertex calls.

If you really only see a few squares at a time, you could try Frustrum culling to determain what's visible or not, but if you do see most of the grid all the time, using a Display list will greatly improve performance.

Those are just some quick and easy techniques that should always be used, if these don't work, then it's goto be something else wrong, like a driver problem or something.

A triangle strip is used to cut out the number of Vertexes that you have to send to the renderer. It does use Triangles instead of Quads, but it removes the redundancy of points that are shared with multiple polygons.

Link to Triangle Strips:
http://www.opengl.org/resources/code/samples/sig99/advanced99/notes/node18.html

Wait, I'm not sure what your definition of Display lists are but, Link:
http://www.lighthouse3d.com/opengl/displaylists/

Give something like this a shot:


[INIT CODE]
GLuint myList;
myList= glGenLists(1);
glNewList(myList,GL_COMPILE);

glBegin(GL_QUADS)
for i++ {
glTexCoord2f(0.0, 0.0); glVertex3f(i.vertex1[0], i.vertex1[1], i.vertex1[2])
glTexCoord2f(0.0, 1.0); glVertex3f(i.vertex2[0], i.vertex2[1], i.vertex2[2])
glTexCoord2f(1.0, 1.0); glVertex3f(i.vertex3[0], i.vertex3[1], i.vertex3[2])
glTexCoord2f(1.0, 0.0); glVertex3f(i.vertex4[0], i.vertex4[1], i.vertex4[2])
}
glEnd();

glEndList();



[RENDER CODE]
glCallList(myList);


-----------
You have to think of OpenGL (or any Rendering API) as one big bottleneck, and the best way to speed it up, is to cut out as many calls to it as possible.

Just a quick Question, Is this grid dynamic or static?
I kinda just assumed it was static. If it does in fact get modified often, like every frame, then Display lists may not be the way to go.

Cool that makes a few things clearer.


You could used a Quad tree. Instead of having the entire grid in 1 single Display List, you can break it upto, say 20x20 grid squares per QuadTree node.

When ever a square changes, you just update the node that it's in. Updating a 20x node should be really fast; real-time.

http://www.gamedev.net/community/forums/topic.asp?topic_id=456434

[EDIT]
Umm, just make sure you clear the old list, and your not continually making a new one :)