Mất bao lâu để OpenGL thực sự cập nhật màn hình?

Tôi có một ứng dụng thử nghiệm OpenGL đơn giản trong C, rút ​​ra những điều khác nhau để đáp ứng với đầu vào chính. (Mesa 8.0.4, đã thử với Mesa-EGL và với GLFW, Ubuntu 12.04LTS trên PC với NVIDIA GTX650). Việc vẽ khá đơn giản / nhanh chóng (loại hình tam giác xoay). Mã kiểm tra của tôi không giới hạn tốc độ khung hình một cách có chủ ý theo bất kỳ cách nào, nó chỉ trông như thế này:

while (true)
{
    draw();
    swap_buffers();
}

Tôi đã tính thời gian này rất cẩn thận và tôi thấy rằng thời gian từ một cuộc gọi eglSwapBuffers()(hoặc glfwSwapBuffers, điều tương tự) đến cuộc gọi tiếp theo là ~ 16,6 mili giây. Thời gian từ sau cuộc gọi đến eglSwapBuffers()ngay trước cuộc gọi tiếp theo chỉ ít hơn thế một chút, mặc dù những gì được rút ra rất đơn giản. Thời gian mà bộ đệm trao đổi cuộc gọi mất dưới 1ms.

Tuy nhiên, thời gian từ ứng dụng thay đổi những gì nó vẽ để phản hồi với phím bấm đến thay đổi thực sự hiển thị trên màn hình là> 150ms (giá trị khoảng 8-9 khung hình). Điều này được đo bằng camera ghi lại màn hình và bàn phím ở tốc độ 60fps.

Do đó, các câu hỏi:

1. Trường hợp rút thăm được đệm giữa một lệnh gọi để trao đổi bộ đệm và thực sự hiển thị trên màn hình? Tại sao lại có sự chậm trễ? Có vẻ như ứng dụng đang vẽ nhiều khung hình phía trước màn hình mọi lúc.

2. Ứng dụng OpenGL có thể làm gì để thu hút màn hình ngay lập tức? (tức là: không có bộ đệm, chỉ chặn cho đến khi vẽ xong; tôi không cần thông lượng cao, tôi cần độ trễ thấp)

3. Ứng dụng có thể làm gì để rút thăm ngay lập tức ở trên nhanh nhất có thể?

4. Làm thế nào một ứng dụng có thể biết những gì thực sự trên màn hình ngay bây giờ? (Hoặc, độ trễ của bộ đệm hiện tại là bao lâu / bao nhiêu khung hình?)

Bất kỳ chức năng API vẽ nào được gọi từ CPU sẽ được gửi tới bộ đệm vòng lệnh GPU để được GPU thực hiện sau đó. Điều này có nghĩa là các chức năng OpenGL chủ yếu là các chức năng không chặn. Vì vậy, CPU và GPU sẽ hoạt động song song.

Điều quan trọng nhất cần lưu ý là ứng dụng của bạn có thể bị ràng buộc CPU hoặc GPU. Một khi bạn gọi glFinish, CPU sẽ đợi GPU hoàn thành các lệnh vẽ của nó, nếu GPU mất nhiều thời gian hơn và có thể / khiến CPU bị đình trệ thì các ứng dụng của bạn bị ràng buộc GPU. Nếu GPU hoàn thành việc vẽ các lệnh và CPU mất quá nhiều thời gian để glFinish thì ứng dụng của bạn bị ràng buộc CPU.

Và lưu ý rằng có một sự khác biệt giữa glFlushvà glFinish.

glFlush: chỉ ra rằng tất cả các lệnh đã được gửi tới GL trước đó phải hoàn thành trong thời gian hữu hạn.

glFinish: buộc tất cả các lệnh GL trước đó phải hoàn thành. Kết thúc không trả về cho đến khi tất cả các hiệu ứng từ các lệnh được ban hành trước đó trên trạng thái máy khách và máy chủ GL và bộ đệm khung được thực hiện đầy đủ. "

glXSwapBuffers thực hiện một glFlush ngầm trước khi nó trở lại. Các lệnh OpenGL sau đó có thể được ban hành ngay sau khi gọi glXSwapBuffers, nhưng không được thực thi cho đến khi hoàn thành việc trao đổi bộ đệm.

Thời gian khung hình thực tế rất có thể sẽ được xác định theo đó trong số hai CPU / GPU đang mất nhiều thời gian hơn để hoàn thành công việc của nó.

OpenGL không bao giờ cập nhật màn hình, về mặt kỹ thuật.

Có một API hệ thống cửa sổ tách biệt với GL (ví dụ GLX, WGL, CGL, EGL) thực hiện điều này. Bộ đệm hoán đổi bằng cách sử dụng các API này thường ngầm gọi glFlush (...)nhưng trong một số triển khai (ví dụ: trình tạo trình GDI trên Windows), nó thực hiện đầy đủ glFinish (...):

    ^{* Ở phía bên trái, là đường dẫn ICD (phần cứng) đi qua SwapBuffers (...). Ở bên phải, đường dẫn GDI (phần mềm).}

Nếu bạn có Vsync kích hoạt và đôi đệm, sau đó bất kỳ lệnh đó sẽ sửa đổi bộ đệm trở lại trước khi một swap cấp phát xảy ra phải gian hàng cho đến khi trao đổi. Có một độ sâu giới hạn trong hàng đợi lệnh, vì vậy lệnh bị đình trệ này cuối cùng sẽ gây ra kẹt xe trong đường ống. Điều này có thể có nghĩa là thay vì chặn trên SwapBuffers (...)ứng dụng của bạn thực sự chặn một số lệnh GL không liên quan cho đến khi VBLANK xuất hiện. Những gì nó thực sự sôi nổi là có bao nhiêu bộ đệm trở lại trong chuỗi trao đổi của bạn.

Miễn là tất cả các bộ đệm phía sau có đầy đủ các khung đã hoàn thành chưa được di chuyển ra phía trước, bộ đệm trao đổi sẽ ngầm gây ra chặn. Đáng buồn thay, không có cách nào để kiểm soát rõ ràng số lượng bộ đệm trở lại được sử dụng bởi hầu hết các API hệ thống cửa sổ GL (ngoài 0 bộ đệm đơn hoặc 1 bộ đệm đôi). Trình điều khiển có thể tự do sử dụng 2 bộ đệm trở lại nếu muốn (bộ đệm ba), nhưng bạn không thể yêu cầu điều này ở cấp ứng dụng bằng cách sử dụng cái gì đó như GLX hoặc WGL.

Tôi cho rằng bạn quen thuộc với thí nghiệm này ?

Về cơ bản, John Carmack đang làm một cái gì đó tương tự, ghi lại màn hình và các pixel thời gian được gửi đến màn hình. Ông thấy rằng rất nhiều độ trễ xuất phát từ màn hình. Các yếu tố khác là độ trễ đầu vào từ bàn phím, trình điều khiển video và hoặc tất nhiên là việc thực hiện chương trình.