улучшение скорости выполнения этой части кода

Question

У меня есть два метода, используемых для рендеринга сетки. Первый из них:

void Grid::openglRender(){ 
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
    glBegin(GL_TRIANGLES); 
    glColor3f(1.0f, 1.0f, 0.0f); 
    Node* A, * B, * C, * D; 
    for(size_t X=0 ; X<sizeX-1 ; X++)for(size_t Z=0 ; Z<sizeZ-1; Z++){ 
    A = &nodes[X*sizeZ+Z]; 
    B = &nodes[(X+1)*sizeZ+Z]; 
    C = &nodes[X*sizeZ+(Z+1)]; 
    D = &nodes[(X+1)*sizeZ+(Z+1)]; 
    glVertex3f(A->x, A->y, A->z); 
    glVertex3f(B->x, B->y, B->z); 
    glVertex3f(C->x, C->y, C->z); 

    glVertex3f(B->x, B->y, B->z); 
    glVertex3f(D->x, D->y, D->z); 
    glVertex3f(C->x, C->y, C->z); 
    } 
    glEnd(); 
}; 

Второй один:

void Grid::openglRender(){ 
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
    glBegin(GL_TRIANGLES); 
    glColor3f(1.0f, 1.0f, 0.0f); 
    for(size_t X=0 ; X<sizeX-1 ; X++)for(size_t Z=0 ; Z<sizeZ-1; Z++){ 
    glVertex3f(nodes[X*sizeZ+Z].x, nodes[X*sizeZ+Z].y, nodes[X*sizeZ+Z].z); 
    glVertex3f(nodes[(X+1)*sizeZ+Z].x, nodes[(X+1)*sizeZ+Z].y, nodes[(X+1)*sizeZ+Z].z); 
    glVertex3f(nodes[X*sizeZ+(Z+1)].x, nodes[X*sizeZ+(Z+1)].y, nodes[X*sizeZ+(Z+1)].z); 

    glVertex3f(nodes[(X+1)*sizeZ+Z].x, nodes[(X+1)*sizeZ+Z].y, nodes[(X+1)*sizeZ+Z].z); 
    glVertex3f(nodes[(X+1)*sizeZ+(Z+1)].x, nodes[(X+1)*sizeZ+(Z+1)].y, nodes[(X+1)*sizeZ+(Z+1)].z); 
    glVertex3f(nodes[X*sizeZ+(Z+1)].x, nodes[X*sizeZ+(Z+1)].y, nodes[X*sizeZ+(Z+1)].z); 
    } 
    glEnd(); 
}; 

для меня первый один выглядит лучше в плане числа операций, в glVertex3f я просто использовать указатель, чтобы получить значение. Во втором методе каждый раз приходится умножать и добавлять что-то.

Но в рабочее время я не очень ощущаю разницу. Значит, я прав, когда говорю, что первый лучше? или, может быть, что я выбрал компилятор лучше меня знаете, что делать, чтобы получить лучшее ...

может быть, это было бы немного лучше, если я объявляю X и Z перед тем, for петлями, чтобы избежать особенно декларации и разрушения sizeX времен Z

Также я думаю, лучше всего было бы создать список (один раз, хранящийся ро быть повторно каждый кадр) со всеми узлами в порядке, которые должны быть перемещено, чтобы создать сетку вместо использования два for

Answer 1

A = &nodes[X*sizeZ+Z]; 
B = &nodes[(X+1)*sizeZ+Z]; 
C = &nodes[X*sizeZ+(Z+1)]; 
D = &nodes[(X+1)*sizeZ+(Z+1)]; 

может быть

A = &nodes[X * sizeZ + Z]; 
B = A + sizeZ; 
C = A + 1; 
D = B + 1; 

, который должен не только сократить число операций, совсем немного, но и сделать отношения узлов немного более очевидным. Я не знаю, насколько умен ваш компилятор, и сможет ли он сам выполнить такую ​​оптимизацию. Но зачем делать это, когда альтернатива яснее?

(обязательное предупреждение о преждевременной оптимизации здесь. Если вы даже не замечая разницы между этими двумя, то это слишком рано, чтобы беспокоиться о микро-оптимизации.)

Answer 2

Просто потому, что вы оптимизировать кусок кода Безразлично 'всегда означает, что вы увидите лучшую производительность во время выполнения. Как вы оцениваете производительность во время выполнения? В зависимости от количества итераций в двух циклах, вы, возможно, никогда не увидите разницу, если количество итераций достаточно велико. Какова фактическая величина sizeX и sizeZ?

Answer 3

Эти призывы устарели, это одна из причин, почему ваша программа работает медленно. Вместо этого вы должны посмотреть в VBO и шейдеры!