mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-21 10:55:01 +01:00
fix(python): the image of the worker goes in place once its fence is signalled, the viewer binds it each frame
From the review of 8811ee5a:
- glWaitSync ordered only the context of the main window. The extra viewports and the windows of
python.displaywindows draw in contexts of their own and could bind the new texture before the upload
was done. commit_thread_upload() now asks the fence without waiting (glClientWaitSync, timeout 0) and
puts the image in place only once it is signalled, so every context binding it afterwards has it whole.
Until then the task stays in the upload queue and is asked again the next frame.
- The drawing thread chose between upload and commit by python.threadedupload, the worker by whether it
got a context. With python.threadedupload on and no context made for the worker, the screens were no
longer updated. The task now records that a worker uploaded it.
- The viewer of python.displaywindows told a new image by its texture name, but a deleted name comes back
for a later texture. It binds the name of the last image each frame, read under the lock of the render
target, and the name it starts with is read on the drawing thread when it is made.
This commit is contained in:
@@ -27,8 +27,13 @@ struct ITexture
|
|||||||
{
|
{
|
||||||
update_from_memory(width, height, data);
|
update_from_memory(width, height, data);
|
||||||
}
|
}
|
||||||
// puts in place the image of the last upload_from_thread(), once the gpu has it. called on the drawing thread
|
// puts in place the image of the last upload_from_thread() once the gpu has it, without waiting for it. called on the
|
||||||
virtual void commit_thread_upload() { /* the image went in place right away */ }
|
// drawing thread; false while the upload isn't done yet, to be asked again later
|
||||||
|
virtual bool commit_thread_upload()
|
||||||
|
{
|
||||||
|
// the image went in place right away
|
||||||
|
return true;
|
||||||
|
}
|
||||||
static ITexture *null_texture()
|
static ITexture *null_texture()
|
||||||
{
|
{
|
||||||
struct NullTexture : public ITexture
|
struct NullTexture : public ITexture
|
||||||
|
|||||||
@@ -788,27 +788,31 @@ void opengl_texture::upload_from_thread(size_t width, size_t height, const uint8
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void opengl_texture::commit_thread_upload()
|
bool opengl_texture::commit_thread_upload()
|
||||||
{
|
{
|
||||||
std::optional<texture_thread_upload> upload;
|
texture_thread_upload upload;
|
||||||
{
|
{
|
||||||
std::scoped_lock lock{m_threaduploadmutex};
|
std::scoped_lock lock{m_threaduploadmutex};
|
||||||
upload = std::exchange(m_threadupload, std::nullopt);
|
if (false == m_threadupload.has_value())
|
||||||
|
return true;
|
||||||
|
// asked without waiting. the image goes in place only once the upload is done, so every context binding it after
|
||||||
|
// has it whole: the extra viewports and the windows of python.displaywindows draw in contexts of their own
|
||||||
|
if (m_threadupload->fence != nullptr)
|
||||||
|
{
|
||||||
|
// a failed query (GL_WAIT_FAILED) isn't asked again: the image would never go in place
|
||||||
|
if (glClientWaitSync(m_threadupload->fence, 0, 0) == GL_TIMEOUT_EXPIRED)
|
||||||
|
return false;
|
||||||
|
glDeleteSync(m_threadupload->fence);
|
||||||
|
}
|
||||||
|
upload = *m_threadupload;
|
||||||
|
m_threadupload.reset();
|
||||||
}
|
}
|
||||||
if (false == upload.has_value())
|
|
||||||
return;
|
|
||||||
|
|
||||||
if (upload->fence != nullptr)
|
|
||||||
{
|
|
||||||
// the commands that follow wait on the gpu for the upload to be done, the cpu goes on
|
|
||||||
glWaitSync(upload->fence, 0, GL_TIMEOUT_IGNORED);
|
|
||||||
glDeleteSync(upload->fence);
|
|
||||||
}
|
|
||||||
if (id != invalid_id)
|
if (id != invalid_id)
|
||||||
glDeleteTextures(1, &id);
|
glDeleteTextures(1, &id);
|
||||||
id = upload->id;
|
id = upload.id;
|
||||||
data_width = static_cast<unsigned int>(upload->width);
|
data_width = static_cast<unsigned int>(upload.width);
|
||||||
data_height = static_cast<unsigned int>(upload->height);
|
data_height = static_cast<unsigned int>(upload.height);
|
||||||
data_format = GL_SRGB8_ALPHA8;
|
data_format = GL_SRGB8_ALPHA8;
|
||||||
data_components = GL_RGBA;
|
data_components = GL_RGBA;
|
||||||
if (type == "internalsrc:")
|
if (type == "internalsrc:")
|
||||||
@@ -819,6 +823,7 @@ void opengl_texture::commit_thread_upload()
|
|||||||
// the name deleted may come back for another texture, and a deleted texture isn't bound any more
|
// the name deleted may come back for another texture, and a deleted texture isn't bound any more
|
||||||
for (auto &unit : units)
|
for (auto &unit : units)
|
||||||
unit = -1;
|
unit = -1;
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
|||||||
@@ -98,7 +98,7 @@ struct opengl_texture : public ITexture {
|
|||||||
// the image goes into a texture of its own, and the drawing thread swaps it in after the gpu has it (commit_thread_upload).
|
// the image goes into a texture of its own, and the drawing thread swaps it in after the gpu has it (commit_thread_upload).
|
||||||
// the texture drawn from is never written by the uploading thread
|
// the texture drawn from is never written by the uploading thread
|
||||||
void upload_from_thread(size_t width, size_t height, const uint8_t *data) override;
|
void upload_from_thread(size_t width, size_t height, const uint8_t *data) override;
|
||||||
void commit_thread_upload() override;
|
bool commit_thread_upload() override;
|
||||||
|
|
||||||
// members
|
// members
|
||||||
static constexpr GLuint invalid_id { std::numeric_limits<GLuint>::max() }; // id value of texture without GL resource
|
static constexpr GLuint invalid_id { std::numeric_limits<GLuint>::max() }; // id value of texture without GL resource
|
||||||
|
|||||||
@@ -232,22 +232,31 @@ void render_task::upload() const
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void render_task::upload_from_thread() const
|
void render_task::upload_from_thread()
|
||||||
{
|
{
|
||||||
|
m_uploadedbyworker = true;
|
||||||
if (Global.python_uploadmain && m_target && m_target->shared_tex)
|
if (Global.python_uploadmain && m_target && m_target->shared_tex)
|
||||||
{
|
{
|
||||||
m_target->shared_tex->upload_from_thread(m_target->width, m_target->height, reinterpret_cast<const uint8_t *>(m_target->image.data()));
|
m_target->shared_tex->upload_from_thread(m_target->width, m_target->height, reinterpret_cast<const uint8_t *>(m_target->image.data()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void render_task::commit_upload() const
|
bool render_task::finish_upload() const
|
||||||
{
|
{
|
||||||
if (Global.python_uploadmain && m_target && m_target->shared_tex)
|
if (false == Global.python_uploadmain || nullptr == m_target || nullptr == m_target->shared_tex)
|
||||||
|
return true;
|
||||||
|
if (m_uploadedbyworker)
|
||||||
{
|
{
|
||||||
m_target->shared_tex->commit_thread_upload();
|
if (false == m_target->shared_tex->commit_thread_upload())
|
||||||
std::scoped_lock lock(m_target->mutex);
|
return false;
|
||||||
m_target->texture_id = m_target->shared_tex->get_id();
|
|
||||||
}
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
upload();
|
||||||
|
}
|
||||||
|
std::scoped_lock lock(m_target->mutex);
|
||||||
|
m_target->texture_id = m_target->shared_tex->get_id();
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
void render_task::cancel() const { /* nothing to do */ }
|
void render_task::cancel() const { /* nothing to do */ }
|
||||||
@@ -629,15 +638,8 @@ void python_taskqueue::update()
|
|||||||
{
|
{
|
||||||
std::scoped_lock lock(m_uploadtasks.mutex);
|
std::scoped_lock lock(m_uploadtasks.mutex);
|
||||||
|
|
||||||
for (auto const &task : m_uploadtasks.data)
|
// a task whose image a worker uploaded stays until the gpu has the image
|
||||||
{
|
std::erase_if(m_uploadtasks.data, [](std::shared_ptr<render_task> const &Task) { return Task->finish_upload(); });
|
||||||
if (Global.python_threadedupload)
|
|
||||||
task->commit_upload();
|
|
||||||
else
|
|
||||||
task->upload();
|
|
||||||
}
|
|
||||||
|
|
||||||
m_uploadtasks.data.clear();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void python_taskqueue::error()
|
void python_taskqueue::error()
|
||||||
|
|||||||
@@ -85,10 +85,11 @@ class render_task
|
|||||||
void run();
|
void run();
|
||||||
// uploads the image on the drawing thread
|
// uploads the image on the drawing thread
|
||||||
void upload() const;
|
void upload() const;
|
||||||
// uploads the image on a worker with a gl context of its own (python.threadedupload); commit_upload() puts it in place
|
// uploads the image on a worker with a gl context of its own (python.threadedupload); finish_upload() puts it in place
|
||||||
void upload_from_thread() const;
|
void upload_from_thread();
|
||||||
// puts the image of upload_from_thread() in place, on the drawing thread
|
// on the drawing thread: uploads the image, or puts in place the one a worker uploaded. false while the gpu hasn't got
|
||||||
void commit_upload() const;
|
// the latter yet, to be called again
|
||||||
|
bool finish_upload() const;
|
||||||
void cancel() const;
|
void cancel() const;
|
||||||
auto target() const -> std::shared_ptr<python_rt>
|
auto target() const -> std::shared_ptr<python_rt>
|
||||||
{
|
{
|
||||||
@@ -100,6 +101,8 @@ class render_task
|
|||||||
PyObject *m_renderer{nullptr};
|
PyObject *m_renderer{nullptr};
|
||||||
std::shared_ptr<dictionary_source> m_input{nullptr};
|
std::shared_ptr<dictionary_source> m_input{nullptr};
|
||||||
std::shared_ptr<python_rt> m_target{nullptr};
|
std::shared_ptr<python_rt> m_target{nullptr};
|
||||||
|
// set by upload_from_thread(); read by the drawing thread after the task was handed over under the lock of the queue
|
||||||
|
bool m_uploadedbyworker{false};
|
||||||
};
|
};
|
||||||
|
|
||||||
class python_taskqueue
|
class python_taskqueue
|
||||||
|
|||||||
@@ -30,7 +30,7 @@ void texture_window_cursor_pos(GLFWwindow *win, double x, double y)
|
|||||||
}
|
}
|
||||||
|
|
||||||
python_screen_viewer::python_screen_viewer(std::shared_ptr<python_rt> rt, std::shared_ptr<std::vector<glm::vec2>> touchlist, std::string const &surfacename)
|
python_screen_viewer::python_screen_viewer(std::shared_ptr<python_rt> rt, std::shared_ptr<std::vector<glm::vec2>> touchlist, std::string const &surfacename)
|
||||||
: m_rt(rt), m_touchlist(touchlist)
|
: m_rt(rt), m_touchlist(touchlist), m_initialtexture(rt->shared_tex->get_id())
|
||||||
{
|
{
|
||||||
|
|
||||||
for (const auto &viewport : Global.python_viewports) {
|
for (const auto &viewport : Global.python_viewports) {
|
||||||
@@ -90,8 +90,7 @@ void python_screen_viewer::threadfunc()
|
|||||||
glActiveTexture(GL_TEXTURE0);
|
glActiveTexture(GL_TEXTURE0);
|
||||||
|
|
||||||
if (Global.python_sharectx) {
|
if (Global.python_sharectx) {
|
||||||
window->shared_texture = m_rt->shared_tex->get_id();
|
bind_shared_texture();
|
||||||
glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(window->shared_texture));
|
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
GLuint tex;
|
GLuint tex;
|
||||||
@@ -148,7 +147,7 @@ void python_screen_viewer::threadfunc()
|
|||||||
|
|
||||||
glfwMakeContextCurrent(window->window);
|
glfwMakeContextCurrent(window->window);
|
||||||
if (Global.python_sharectx)
|
if (Global.python_sharectx)
|
||||||
bind_shared_texture(*window);
|
bind_shared_texture();
|
||||||
gl::program::unbind();
|
gl::program::unbind();
|
||||||
gl::buffer::unbind();
|
gl::buffer::unbind();
|
||||||
|
|
||||||
@@ -191,18 +190,16 @@ void python_screen_viewer::threadfunc()
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void python_screen_viewer::bind_shared_texture(window_state &Window) const
|
void python_screen_viewer::bind_shared_texture() const
|
||||||
{
|
{
|
||||||
size_t texture;
|
size_t texture;
|
||||||
{
|
{
|
||||||
std::scoped_lock guard(m_rt->mutex);
|
std::scoped_lock guard(m_rt->mutex);
|
||||||
texture = m_rt->texture_id;
|
texture = m_rt->texture_id;
|
||||||
}
|
}
|
||||||
// each image uploaded by a worker comes in a texture of its own
|
// bound each frame: each image uploaded by a worker comes in a texture of its own, and a name deleted comes back for
|
||||||
if (texture == 0 || texture == Window.shared_texture)
|
// a later one, so a name seen before may be another texture already
|
||||||
return;
|
glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(texture != 0 ? texture : m_initialtexture));
|
||||||
Window.shared_texture = texture;
|
|
||||||
glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(texture));
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void python_screen_viewer::notify_window_fb_size(GLFWwindow const *window, int w, int h) const
|
void python_screen_viewer::notify_window_fb_size(GLFWwindow const *window, int w, int h) const
|
||||||
|
|||||||
@@ -18,7 +18,6 @@ class python_screen_viewer
|
|||||||
std::unique_ptr<gl::program> shader;
|
std::unique_ptr<gl::program> shader;
|
||||||
|
|
||||||
std::chrono::high_resolution_clock::time_point timestamp;
|
std::chrono::high_resolution_clock::time_point timestamp;
|
||||||
size_t shared_texture{0}; // with python.sharectx, the texture of the screen bound in this window's context
|
|
||||||
|
|
||||||
window_state() = default;
|
window_state() = default;
|
||||||
~window_state();
|
~window_state();
|
||||||
@@ -32,10 +31,12 @@ class python_screen_viewer
|
|||||||
gl::scene_ubs m_ubs;
|
gl::scene_ubs m_ubs;
|
||||||
|
|
||||||
std::atomic_bool m_exit = false;
|
std::atomic_bool m_exit = false;
|
||||||
|
// the texture of the screen when the viewer was made, read on the drawing thread: shown until an image is put in place
|
||||||
|
size_t m_initialtexture{0};
|
||||||
|
|
||||||
void threadfunc();
|
void threadfunc();
|
||||||
// with python.sharectx, binds the texture with the last image of the screen, in the context of the window made current
|
// with python.sharectx, binds the texture with the last image of the screen, in the context of the window made current
|
||||||
void bind_shared_texture(window_state &Window) const;
|
void bind_shared_texture() const;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
python_screen_viewer(std::shared_ptr<python_rt> rt, std::shared_ptr<std::vector<glm::vec2>> touchlist, std::string const &name);
|
python_screen_viewer(std::shared_ptr<python_rt> rt, std::shared_ptr<std::vector<glm::vec2>> touchlist, std::string const &name);
|
||||||
|
|||||||
Reference in New Issue
Block a user