Attachment 145474 Details for Bug 111784 – Source code exhibiting the issue

Source code exhibiting the issue

radeon_mesa_shared_context_freeze.cpp (text/x-c++src), 5.56 KB, created by Emmanuel Durand on 2019-09-23 14:23:24 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Emmanuel Durand

Created: 2019-09-23 14:23:24 UTC

Size: 5.56 KB

patch

obsolete

>/*
> * To compile this code, GLFW3 is needed, as well as a GL 3.3 version of Glad generated from this site:
> * https://glad.dav1d.de/
> * Then compile it with the following command:
> * $ g++ -Og -I /path/to/glad/include /path/to/glad.c radeon_mesa_shared_context_freeze.cpp $(pkg-config --libs glfw3) -lGL -lpthread -o radeon_test
> */
>
>#include <chrono>
>#include <cmath>
>#include <future>
>#include <iostream>
>#include <memory>
>#include <thread>
>#include <vector>
>
>#include "./glad/glad.h"
>
>#include <GLFW/glfw3.h>
>
>using namespace std;
>
>/*************/
>class GlWindow
>{
>  public:
>    /**
>     * \brief Constructor
>     * \param w Pointer to an existing GLFWwindow
>     * \param mainWindow Pointer to an existing GLFWwindow which is shared with w
>     */
>    GlWindow() = delete;
>    GlWindow(GLFWwindow* w, GLFWwindow* mainWindow)
>    {
>        _window = w;
>        _mainWindow = mainWindow;
>    }
>
>    /**
>     * \brief Destructor
>     */
>    ~GlWindow()
>    {
>        if (_window != nullptr)
>            glfwDestroyWindow(_window);
>    }
>
>    /**
>     * \brief Get the pointer to the GLFW window
>     * \return Return the pointer to the GLFW window
>     */
>    GLFWwindow* get() const { return _window; }
>
>    /**
>     * \brief Get the pointer to the main GLFW window
>     * \return Return the main GLFW window
>     */
>    GLFWwindow* getMainWindow() const { return _mainWindow; }
>
>    /**
>     * \brief Set the context of this window as current
>     * \return Return true if everything went well
>     */
>    bool setAsCurrentContext() const
>    {
>        _previousWindow = glfwGetCurrentContext();
>        if (_previousWindow == _window)
>            return true;
>        _mutex.lock();
>        glfwMakeContextCurrent(_window);
>        return true;
>    }
>
>    /**
>     * \brief Release the context
>     */
>    void releaseContext() const
>    {
>        if (_window == _previousWindow)
>            _previousWindow = nullptr;
>        else if (glfwGetCurrentContext() == _window)
>        {
>            if (_previousWindow == nullptr)
>                glfwMakeContextCurrent(NULL);
>            else
>            {
>                glfwMakeContextCurrent(_previousWindow);
>                _previousWindow = nullptr;
>            }
>            _mutex.unlock();
>        }
>    }
>
>  private:
>    mutable std::mutex _mutex;
>    mutable GLFWwindow* _previousWindow{nullptr};
>    GLFWwindow* _window{nullptr};
>    GLFWwindow* _mainWindow{nullptr};
>};
>
>// Some global variables
>std::shared_ptr<GlWindow> _mainWindow;
>// Texture upload context
>std::future<void> _textureUploadFuture;
>std::shared_ptr<GlWindow> _textureUploadWindow;
>std::atomic_bool _textureUploadDone{false};
>std::mutex _textureMutex; //!< Sync between texture and render loops
>GLsync _textureUploadFence{nullptr}, _cameraDrawnFence{nullptr};
>
>/*************/
>shared_ptr<GlWindow> getNewSharedWindow(const string& name)
>{
>    string windowName;
>    name.size() == 0 ? windowName = "Splash::Window" : windowName = "Splash::" + name;
>
>    if (!_mainWindow)
>        return {nullptr};
>
>    // The GL version is the same as in the initialization, so we don't have to reset it here
>    glfwWindowHint(GLFW_VISIBLE, false);
>    GLFWwindow* window = glfwCreateWindow(512, 512, windowName.c_str(), NULL, _mainWindow->get());
>    if (!window)
>        return {nullptr};
>    auto glWindow = make_shared<GlWindow>(window, _mainWindow->get());
>
>    glWindow->setAsCurrentContext();
>    glWindow->releaseContext();
>
>    return glWindow;
>}
>
>/*************/
>void init(const string& name)
>{
>    // GLFW stuff
>    if (!glfwInit())
>    {
>        return;
>    }
>
>    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
>    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
>    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
>    glfwWindowHint(GLFW_VISIBLE, false);
>
>    GLFWwindow* window = glfwCreateWindow(512, 512, name.c_str(), NULL, NULL);
>
>    if (!window)
>    {
>        return;
>    }
>
>    _mainWindow = make_shared<GlWindow>(window, window);
>
>    _mainWindow->setAsCurrentContext();
>    gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
>    _mainWindow->releaseContext();
>
>    _textureUploadWindow = getNewSharedWindow("texture_upload");
>}
>
>/*************/
>void textureUploadRun()
>{
>    _textureUploadWindow->setAsCurrentContext();
>
>    while (true)
>    {
>        unique_lock<std::mutex> lockTexture(_textureMutex);
>
>        if (glIsSync(_cameraDrawnFence) == GL_TRUE)
>        {
>            glWaitSync(_cameraDrawnFence, 0, GL_TIMEOUT_IGNORED);
>            glDeleteSync(_cameraDrawnFence);
>        }
>
>        if (glIsSync(_textureUploadFence) == GL_TRUE)
>            glDeleteSync(_textureUploadFence);
>        _textureUploadFence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
>        lockTexture.unlock();
>    }
>
>    _textureUploadWindow->releaseContext();
>}
>
>/*************/
>void run()
>{
>    _textureUploadFuture = async(std::launch::async, [&]() { textureUploadRun(); });
>    _mainWindow->setAsCurrentContext();
>    while (true)
>    {
>        std::cout << "-------> " << std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now().time_since_epoch()).count() << "\n";
>        auto textureLock = unique_lock<std::mutex>(_textureMutex);
>        if (glIsSync(_textureUploadFence) == GL_TRUE)
>        {
>            glWaitSync(_textureUploadFence, 0, GL_TIMEOUT_IGNORED);
>            glDeleteSync(_textureUploadFence);
>        }
>
>        if (glIsSync(_cameraDrawnFence) == GL_TRUE)
>            glDeleteSync(_cameraDrawnFence);
>        _cameraDrawnFence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
>    }
>    _mainWindow->releaseContext();
>}
>
>/*************/
>int main(int argc, char** argv)
>{
>    init("test");
>    run();
>}

Actions: View

Attachments on bug 111784: 145472 | 145473 | 145474 | 145487

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.