|
665785f6
|
2025-10-11T14:11:26
|
|
Vulkan: Load the image when damage region is set
Ensure image loads when buffer age > 0 and damage region is set,
regardless of first eglQuerySurface call
Bug: angleproject:450967247
Change-Id: I5cae32fc3c3e8c0b26e9d8a6eb6c1365d0d12bf9
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/7031241
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Auto-Submit: Xin Yuan <xin.yuan@arm.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
5fd368aa
|
2025-07-30T14:45:55
|
|
Replace Surface::getWidth/Height() with getSize()
Most places in the code use both `getWidth/Height()` methods at the same
time. On some back-ends it is more optimal to have single method.
For example, `WindowSurfaceWGL` first uses `GetClientRect()` Win32 API
inside each method to then calculate width and hight in each method,
causing repeated `GetClientRect()` call.
The only place where only one of the methods may be used is from
`SurfaceImpl::getUserSize()` when one of the parameters is `nullptr`,
which is only possible from `QuerySurfaceAttrib()` function. This
method is rewritten to use new `getSize()` method and then use whatever
dimensions is requested by the caller. This may cause
`QuerySurfaceAttrib()` inefficiency on some back-ends that get width and
height of the surface differently (`SurfaceEGL` for example). In such
cases `getUserSize()` is overridden to avoid returning a dimension
which is not required.
After this change all places in the code that previously used both
`getWidth/Height()` methods (like `Surface::getAttachmentSize()`) will
be more efficient. The `QuerySurfaceAttrib()`, on the other hand, will
have slightly more overhead on back-ends where base
`SurfaceImpl::getUserSize()` method is used, which only happens on
back-ends with trivial `getSize()` implementation.
Bug: angleproject:397848903
Change-Id: I4a22701a1e62ee4e7d07e77cac5b388050d98e4d
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6802440
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
4189fbb8
|
2025-07-29T17:50:24
|
|
Implement EGL_ANDROID_presentation_time for Vulkan backend
The implementation leverages the VK_GOOGLE_display_timing Vulkan
extension.
Bug: chromium:434977616
Bug: angleproject:42261214
Change-Id: I7e6c64eca6c01e7eb79d41dc5ef63311a7792e2b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6799254
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Cody Northrop <cnorthrop@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
3e52318c
|
2025-06-26T10:46:00
|
|
Vulkan: Ensure always using resolved Window Surface size
`WindowSurfaceVk::getWidth/Height()` methods return cached, previously
resolved Surface size. Using these methods while current Window Surface
size is unresolved may return stale values, causing undesired behavior.
Appropriate ASSERTs were added to these methods to prevent such usage.
Added ASSERTs revealed few places with incorrect usage:
- In `Context::makeCurrent()` to set initial viewport or for capture.
- In `IsPartialBlit()` and `ValidateReadPixelsBase()` validations.
- In `SerializeFramebufferAttachment()` during capture.
Rest of the code was thoroughly checked if it is possible to call
`WindowSurfaceVk::getWidth/Height()` when size is unresolved. All other
places always call these methods after framebuffer state
synchronization, which acquires swapchain images and resolves the
surface size.
Added `ensureSizeResolved()` method that is called during validation and
in the `SerializeFramebufferAttachment()` method. It is possible to use
existing `Framebuffer::syncState()` method as alternative, but this
solution was discarded since it may potentially interfere with
`State::syncDirtyObjects()` method.
The `Surface::getUserSize()` replaces old methods as optimization, to
prevent calling relatively expensive method twice from
`Context::makeCurrent()` to get width and height of the `drawSurface`.
Test: angle_trace_tests --gtest_filter=EGLSurfaceTest.ResizeBeforeMakeCurrent/*
Test: angle_trace_tests --gtest_filter=EGLSurfaceTest.ResizeBeforeMakeCurrentPostSizeQuery/*
Test: angle_trace_tests --gtest_filter=EGLSurfaceTest.ResizeAndReadPixelsRobustANGLE/*
Test: angle_trace_tests --gtest_filter=EGLSurfaceTest.ResizeAndBlitFramebufferANGLE/*
Bug: angleproject:397848903
Change-Id: I082e13d0b8db5fd7d08ff25b102df1f283e1256d
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6792928
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Cody Northrop <cnorthrop@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
6a03109f
|
2025-07-09T18:24:31
|
|
Refine getCompressionRate
As Vulkan spec states, vkGetImageSubresourceLayout should not be called
for the android swapchainimage when the image is not bound to memory.
Refine the path of getCompressionRate to make sure at least
swapchainimage[0] has been initialized when it is been called.
Bug: angleproject:433057375
Change-Id: I80b68874686940c0ef77df97b928b0e153c5bbf8
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6774721
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Cody Northrop <cnorthrop@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
317f81db
|
2025-05-01T14:17:47
|
|
Fix EGL_RENDER_BUFFER query if EGL_SINGLE_BUFFER unsupported
eglCreateWindowSurface() can have the EGL attribute EGL_RENDER_BUFFER
specified:
EGL_RENDER_BUFFER specifies which buffer should be used by default for
client API rendering to the window, as described in section 2.2.2. If
its value is EGL_SINGLE_BUFFER, then client APIs should render
directly into the visible window. If its value is EGL_BACK_BUFFER,
then all client APIs should render into the back buffer. The default
value of EGL_RENDER_BUFFER is EGL_BACK_BUFFER.
Client APIs may not be able to respect the requested rendering buffer.
To determine the actual buffer that a context will render to by
default, call eglQueryContext with attribute EGL_RENDER_BUFFER (see
section 3.7.4).
To support EGL_SINGLE_BUFFER, Vulkan surfaces must support the
VkPresentModeKHR value VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:
VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR specifies that the
presentation engine and application have concurrent access to a single
image, which is referred to as a shared presentable image. The
presentation engine is only required to update the current image after
a new presentation request is received. Therefore the application must
make a presentation request whenever an update is required. However,
the presentation engine may update the current image at any point,
meaning this mode may result in visible tearing.
However, this is only available on Vulkan devices that support the
extension VK_KHR_shared_presentable_image.
Add checking in Surface::initialize() to update Surface::mRenderBuffer
to EGL_BACK_BUFFER if the backend implementation does not support
EGL_SINGLE_BUFFER. This includes adding supportsSingleRenderBuffer() to
query the backend if it supports single render buffer mode, which
defaults to False. The Vulkan backend overrides this and the result is
based on support for VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR.
Bug: b/412446258
Test: EGLLockSurface3Test.WindowMsaaSurfaceReadTest/ES2_Vulkan_NoFixture
Test: EGLSingleBufferTest.VerifyMutableRenderBufferKHR/*
Change-Id: I4e6d56f01a895a5bd887580e6ffa34d574c87fad
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6506764
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
b77f8af7
|
2025-04-02T19:01:48
|
|
Vulkan: Ignore SUBOPTIMAL on Android without pre-rotate
Android returns `VK_SUBOPTIMAL_KHR` when window orientation changes,
while ignores size changes. When "enablePreRotateSurfaces" is disabled,
each present will return `VK_SUBOPTIMAL_KHR` if `currentTransform` is
not `VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR`, causing swapchain recreate
on each swap. This behavior makes disabling "enablePreRotateSurfaces" on
Android worse than suboptimal.
New "presentSubOptimalReturnedOnTransformChange" feature is currently
enabled only on Android for the reason described above. It may be
enabled for other platforms in the future if required.
Change also improves error handling, by moving `deferAcquireNextImage()`
call right after the `queuePresent()`, before any other call that may
fail. This will avoid repeated present of the same image if something
fails after successful `queuePresent()` call.
The `checkForOutOfDateSwapchain()` and `computePresentOutOfDate()` was
combined into a single method to improve error handling and to simplify
the code.
Bug: angleproject:397848903
Bug: angleproject:42266082
Bug: angleproject:42262166
Change-Id: I7ba2389ad2ddafc0c77c3068cd85ac9b9251ccdd
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6424753
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
ecc378cc
|
2025-03-03T16:43:33
|
|
Reland "Dont use Subject/Observer for SwapchainImageChanged"
This is reland of the following CL
https://chromium-review.googlesource.com/c/angle/angle/+/6319893
Because we do deferred ANI (VkAcquireNextImage) call until image is
needed, we need a way to force Context to go through
FramebufferVk::syncState call (FramebufferVk::syncState calls
WindowSurfaceVk::getAttachmentRenderTarget, which end up calling ANI.
Right now we uses subject/observer mechanism, by sending
angle::SubjectMessage::SwapchainImageChanged to all observers of
WindowSurfaceVk. In this case it is egl::Surface. Then eglSurface
redirects this message to its observers, which are all gl::Framebuffer's
attachments: color, depth, stencil. Even though only color attachment
needs to be notified, but because we don't have a separate list of
observers, depth/stencil attachment also receive the notification and
they early out. Then gl::Framebuffer sets
DIRTY_BIT_COLOR_BUFFER_CONTENTS_0 dirty bit and send the
angle::SubjectMessage::DirtyBitsFlagged to Context, which dirty DrawFBO
and ReadFBO and dirty cached state. Note that this is specific for swap
image changed case, there is no surface property change (surface
property change will still trigger the subject/observer message with
SubjectMessage::SubjectChanged message, but this occurs rarely). This
gets worse for apps that uses multiple contexts, for the example
pokemon_masters_ex has three contexts, each context has its own default
frame buffer that attach to the same surface, and we never remove
non-current context from the observer list. This end up with
egl::Surface has 12 observers and for every frame, it loop over the list
of 12 observers and send message (virtual function call) to each of
them. Color attachment also ends up sending two messages to Context, one
for Read FBO and another for Draw FBO. There are total 21 virtual
function calls. Even for single context usage, you have 6 virtual
function calls, for every frame.
EGL spec says "an EGLSurface must be current on only one thread at a
time", any other context must call EGLMakeCurrent in order to use this
surface, which will add all necessary dirty bits at that time. So we
really only need to notify current context. In this CL,
SwapchainImageChanged no longer uses subject/observer mechanism, so this
message is removed.
This CL still uses subject/observer mechanism to send DirtyBitsFlagged
from Framebuffer back to context. We could call setDrawFramebufferDirty
and setReadFramebufferDirty directly, but that will require to remove
the "const" decoration out of gl::Context which generates too much code
diff, so onStateChange(angle::SubjectMessage::DirtyBitsFlagged) is still
used.
Bug: angleproject:400711938
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6319893
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Change-Id: I017b0e8934b5194a520828fa5c4af1d6e3ef9aac
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6404621
|
|
|
8cf89716
|
2025-03-14T20:17:07
|
|
Vulkan: Remove perFrameWindowSizeQuery feature
Feature was enabled for all platforms in order for surface to be resized
before acquire next image (not only after swap). Remove it, as if it's
always enabled to simplify the code.
Bug: angleproject:397848903
Bug: angleproject:42262287
Bug: angleproject:42262286
Bug: angleproject:40096601
Change-Id: I768772e30f5f38f68992e5b82c84430732aa77d9
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6354166
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
081934f6
|
2025-03-12T15:22:31
|
|
Vulkan: Add avoidInvisibleWindowSwapchainRecreate feature
There is a bug on some NVIDIA drivers on Linux X11 when
`vkAcquireNextImageKHR()` constantly returns `VK_ERROR_OUT_OF_DATE_KHR`
if recreate the swapchain while window is not visible.
If not recreate the swapchain after window resize - nothing happens,
acquire and present works without errors. But if recreate the swpahchain
to the `VkSurfaceCapabilitiesKHR::currentExtent` the next
`vkAcquireNextImageKHR()` will return `VK_ERROR_OUT_OF_DATE_KHR`. ANGLE
will retry to recreate the swapchain one more time and fail the call.
Enabling the "avoidInvisibleWindowSwapchainRecreate" feature will avoid
swapchain recreation when window size changes while it is not visible.
Test: angle_end2end_tests --gtest_filter=EGLSurfaceTest.ResizeInvisibleWindow/*
Bug: angleproject:397848903
Bug: angleproject:42264022
Bug: angleproject:42263074
Change-Id: I48588bf467d15c0e84b923092e06a42c22084dcc
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6348739
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
caf14998
|
2025-02-25T17:28:05
|
|
Vulkan: Fix window surface resize and size query
Added `mSizeState` enum member. When it is not `Resolved`, surface size
is not yet resolved and may change any time in response to native window
resize. Otherwise, surface size is resolved and will not change until
next swap.
Updated `getUserWidth()`/`getUserHeight()` methods. They return
current window size when surface size is not resolved, or current
surface size, otherwise. Window size is queried either by
`getCurrentWindowSize()`, when surface is sized by swapchain, or
by querying vulkan surface capabilities.
The "perFrameWindowSizeQuery" feature controls when `mSizeState` is
updated. Initially it is not resolved. Marked as not resolved in
`invalidateSwapchain()`, and in `deferAcquireNextImage()` when the
feature is enabled. It is marked as resolved after swapchain is created
when feature is disabled, or in `AcquireNextImageUnlocked()` function
after acquire next image, otherwise.
Enabled some tests that were previously failing. Replaced old resize
tests with new versions.
Test: angle_end2end_tests --gtest_filter=EGLSurfaceTest.Resize*/*
Bug: angleproject:397848903
Bug: angleproject:373659619
Bug: angleproject:153329980
Bug: angleproject:42266013
Bug: angleproject:42265843
Bug: angleproject:42265529
Bug: angleproject:42264022
Bug: angleproject:42263074
Bug: angleproject:42261800
Bug: angleproject:40096826
Change-Id: I3ad836960a68229fab6c94624022f1a0aaf2c3e5
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6300645
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
|
e44357c6
|
2025-03-25T15:50:15
|
|
Vulkan: Do not defer ANI in shared present mode
Calling ANI in shared present mode is not necessary after the initial
acquire. Skip calling `deferAcquireNextImage()` in that mode.
For code simplicity and as a preparation for (anglebug.com/400711938),
the `invalidateSwapchain()` method is now also defers ANI and notifies
`SubjectMessage::SurfaceChanged` to the parent class. `Framebuffer`
message handling was updated to also reset color buffer dirty bit and
to notify `SubjectMessage::DirtyBitsFlagged` if needed, as in the
`SubjectMessage::SwapchainImageChanged` message case (which will be
removed in future CL). This way, single `SubjectMessage::SurfaceChanged`
message is enough to handle swapchain recreate.
The `VK_SUBOPTIMAL_KHR` is no longer treaded as OUT_OF_DATE when in
shared present mode. Added for consistency (since we are already
skipping "perFrameWindowSizeQuery" checks), to preserve content, and to
match the Android native GLES driver behavior.
Call `invalidateSwapchain()` when swapchain operations fail to avoid
repeated swapchain use and to be able to recover from the error.
The `checkForOutOfDateSwapchain()` was split into two methods:
- checkForOutOfDateSwapchain():
- Called only after present.
- Checks present out of date result and present mode compatibility.
- Invalidates the swapchain and updates the present mode if the above
checks fails.
- prepareSwapchainForAcquireNextImage():
- Calls `queryAndAdjustSurfaceCaps()` and `recreateSwapchain()`
if swapchain is invalid.
- Calls `queryAndAdjustSurfaceCaps()` and checks surface properties
when "perFrameWindowSizeQuery" is enabled. Then calls
`recreateSwapchain()` if something changed.
Other changes:
- The `prepareForAcquireNextSwapchainImage()` method was replaced with
`prepareSwapchainForAcquireNextImage()`.
- Removed `doDeferredAcquireNextImageWithUsableSwapchain()` and
`postProcessUnlockedAcquire()` methods because of redundancy.
- Move image invalidation code into `acquireNextSwapchainImage()` to
make `doDeferredAcquireNextImage()` simpler.
- Convert `resizeSwapchainImages()` into `createSwapchainImages()` for
simplicity.
Updated old and added new tests.
Test: angle_end2end_tests --gtest_filter=EGLSurfaceTest.ReadFramebufferBindingSyncState/*
Test: angle_end2end_tests --gtest_filter=EGLSingleBufferTest.OnCreateWindowSurface/*
Test: angle_end2end_tests --gtest_filter=EGLSingleBufferTest.OnSetSurfaceAttrib/*
Test: angle_end2end_tests --gtest_filter=EGLSingleBufferTest.WindowResize/*
Test: angle_end2end_tests --gtest_filter=EGLSingleBufferTest.WindowRotation/*
Bug: angleproject:400711938
Bug: angleproject:397848903
Bug: angleproject:42262606
Change-Id: I2247417aa8b7b5afc10a8420083aeb845895aec9
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6387920
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
3cfc0ce2
|
2025-03-24T07:41:33
|
|
Revert "Vulkan:Dont use Subject/Observer for SwapchainImageChanged"
This reverts commit 48103cb2f2b292cb50cc5a29546b358b2e47fd29.
Reason for revert: assert fails
https://ci.chromium.org/ui/p/angle/builders/ci/android-arm64-exp-test/7085/overview
I 22:27:33.697 77.533s _RunTestsOnDevice(17221FDF6000A4) [ RUN ] EGLAndroidAutoRefreshTest.SwapCPUThrottling/ES3_Vulkan_NoFixture
INFO:root:ERR: SurfaceVk.cpp:3165 (getCurrentFramebuffer): ! Assert failed in getCurrentFramebuffer (../../src/libANGLE/renderer/vulkan/SurfaceVk.cpp:3165): mAcquireOperation.state == ImageAcquireState::Ready
Original change's description:
> Vulkan:Dont use Subject/Observer for SwapchainImageChanged
>
> Because we do deferred ANI (VkAcquireNextImage) call until image is
> needed, we need a way to force Context to go through
> FramebufferVk::syncState call (FramebufferVk::syncState calls
> WindowSurfaceVk::getAttachmentRenderTarget, which end up calling ANI.
> Right now we uses subject/observer mechanism, by sending
> angle::SubjectMessage::SwapchainImageChanged to all observers of
> WindowSurfaceVk. In this case it is egl::Surface. Then eglSurface
> redirects this message to its observers, which are all gl::Framebuffer's
> attachments: color, depth, stencil. Even though only color attachment
> needs to be notified, but because we don't have a separate list of
> observers, depth/stencil attachment also receive the notification and
> they early out. Then gl::Framebuffer sets
> DIRTY_BIT_COLOR_BUFFER_CONTENTS_0 dirty bit and send the
> angle::SubjectMessage::DirtyBitsFlagged to Context, which dirty DrawFBO
> and ReadFBO and dirty cached state. Note that this is specific for swap
> image changed case, there is no surface property change (surface
> property change will still trigger the subject/observer message with
> SubjectMessage::SubjectChanged message, but this occurs rarely). This
> gets worse for apps that uses multiple contexts, for the example
> pokemon_masters_ex has three contexts, each context has its own default
> frame buffer that attach to the same surface, and we never remove
> non-current context from the observer list. This end up with
> egl::Surface has 12 observers and for every frame, it loop over the list
> of 12 observers and send message (virtual function call) to each of
> them. Color attachment also ends up sending two messages to Context, one
> for Read FBO and another for Draw FBO. There are total 21 virtual
> function calls. Even for single context usage, you have 6 virtual
> function calls, for every frame.
>
> EGL spec says "an EGLSurface must be current on only one thread at a
> time", any other context must call EGLMakeCurrent in order to use this
> surface, which will add all necessary dirty bits at that time. So we
> really only need to notify current context. In this CL,
> SwapchainImageChanged no longer uses subject/observer mechanism, so this
> message is removed.
>
> This CL still uses subject/observer mechanism to send DirtyBitsFlagged
> from Framebuffer back to context. We could call setDrawFramebufferDirty
> and setReadFramebufferDirty directly, but that will require to remove
> the "const" decoration out of gl::Context which generates too much code
> diff, so onStateChange(angle::SubjectMessage::DirtyBitsFlagged) is still
> used.
>
> Bug: angleproject:400711938
> Change-Id: I61354516fd0aa307714b7abd30c6b6e45ff7b496
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6319893
> Commit-Queue: Charlie Lao <cclao@google.com>
> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
> Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Bug: angleproject:400711938
Change-Id: Ib7899d1ac63a1f86af0953a1d25922578c470fc9
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6387755
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Yuly Novikov <ynovikov@chromium.org>
|
|
|
48103cb2
|
2025-03-03T16:43:33
|
|
Vulkan:Dont use Subject/Observer for SwapchainImageChanged
Because we do deferred ANI (VkAcquireNextImage) call until image is
needed, we need a way to force Context to go through
FramebufferVk::syncState call (FramebufferVk::syncState calls
WindowSurfaceVk::getAttachmentRenderTarget, which end up calling ANI.
Right now we uses subject/observer mechanism, by sending
angle::SubjectMessage::SwapchainImageChanged to all observers of
WindowSurfaceVk. In this case it is egl::Surface. Then eglSurface
redirects this message to its observers, which are all gl::Framebuffer's
attachments: color, depth, stencil. Even though only color attachment
needs to be notified, but because we don't have a separate list of
observers, depth/stencil attachment also receive the notification and
they early out. Then gl::Framebuffer sets
DIRTY_BIT_COLOR_BUFFER_CONTENTS_0 dirty bit and send the
angle::SubjectMessage::DirtyBitsFlagged to Context, which dirty DrawFBO
and ReadFBO and dirty cached state. Note that this is specific for swap
image changed case, there is no surface property change (surface
property change will still trigger the subject/observer message with
SubjectMessage::SubjectChanged message, but this occurs rarely). This
gets worse for apps that uses multiple contexts, for the example
pokemon_masters_ex has three contexts, each context has its own default
frame buffer that attach to the same surface, and we never remove
non-current context from the observer list. This end up with
egl::Surface has 12 observers and for every frame, it loop over the list
of 12 observers and send message (virtual function call) to each of
them. Color attachment also ends up sending two messages to Context, one
for Read FBO and another for Draw FBO. There are total 21 virtual
function calls. Even for single context usage, you have 6 virtual
function calls, for every frame.
EGL spec says "an EGLSurface must be current on only one thread at a
time", any other context must call EGLMakeCurrent in order to use this
surface, which will add all necessary dirty bits at that time. So we
really only need to notify current context. In this CL,
SwapchainImageChanged no longer uses subject/observer mechanism, so this
message is removed.
This CL still uses subject/observer mechanism to send DirtyBitsFlagged
from Framebuffer back to context. We could call setDrawFramebufferDirty
and setReadFramebufferDirty directly, but that will require to remove
the "const" decoration out of gl::Context which generates too much code
diff, so onStateChange(angle::SubjectMessage::DirtyBitsFlagged) is still
used.
Bug: angleproject:400711938
Change-Id: I61354516fd0aa307714b7abd30c6b6e45ff7b496
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6319893
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
|
|
|
daaae2bd
|
2025-02-24T19:36:39
|
|
Vulkan: Remove surface caps query from createSwapChain
This is mainly a refactoring with minor bug fixes.
The `createSwapChain()` is called at initialize and at swapchain
recreate. Before recreate there is always `queryAndAdjustSurfaceCaps()`
call, which queries current surface sizes and min image count. However,
surface capabilities may be queried again from `createSwapChain()` to
get compatible present modes and the min image count.
Problem is that surface caps `currentExtent` may change after the second
query in the `createSwapChain()`, while the `extents` parameter is
already calculated. Such situation will violate the specification.
To eliminate the possibility of the above problem and to simplify the
code, query of compatible present modes is moved to the
`queryAndAdjustSurfaceCaps()`. To save performance,
`mCompatiblePresentModes` is only updated if swapchain is already
invalid (recreate is imminent). Function is now also handles
`mEmulatedPreTransform` to further simplify the code.
The `mSurfaceCaps` member was replaced with local variable. The
`mIsSurfaceSizedBySwapchain` boolean is added instead to check it in the
`getUserWidth()`/`getUserHeight()` methods. This also fixes a possible
bug (anglebug.com/168327817) on Fuchsia when this expression could be
false:
mSurfaceCaps.currentExtent.width == kSurfaceSizedBySwapchain
This is because previously `queryAndAdjustSurfaceCaps()` updated
`mSurfaceCaps` with the values from `getCurrentWindowSize()`. It
seems that the bug never happened on practice, otherwise the ASSERT
in the same function would fail.
The `prepareForAcquireNextSwapchainImage()` is used at initialize
instead of `createSwapChain()` to remove code duplication.
Fixed (anglebug.com/168327817) checking `mPreTransform` without enabled
"enablePreRotateSurfaces" feature.
Bug: angleproject:397848903
Bug: angleproject:168327817
Change-Id: I02e8e3b815b30350e12476853d8dcffed3fe7c38
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6298736
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
ac251fa8
|
2025-02-24T17:31:58
|
|
Vulkan: Remove doDeferredAcquireNextImage ContextVk dependency
This is the continuation of the previous CL. After this change
`lockSurface()` calls `doDeferredAcquireNextImage()` as the rest of the
code do.
The `ImageHelper::invalidateSubresourceContentImpl()` required
`ContextVk` pointer before this change.
The `ContextVk` is only used to print the performance warning when
`layerIndex` exceed the maximum count, which is not possible in case of
a `WindowSurfaceVk`. Added `layerLimitReachedOut` pointer instead of
writing the warning. It is processed in
`invalidateSubresource[Stencil]Content()`. Added
`invalidateEntireLevel[Stencil]Content()` which do not require
`ContextVk` to use in the `WindowSurfaceVk`.
Bug: angleproject:397848903
Bug: angleproject:42264593
Change-Id: I58451a4818ad56fa196c3c971df3a5f7793f2bfe
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6298735
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
2f5a91ba
|
2025-02-24T17:25:10
|
|
Vulkan: Remove checkForOutOfDateSwapchain ContextVk dependency
This is the continuation of the previous CL. After this CL it is now
possible to call `prepareForAcquireNextSwapchainImage()` from
`lockSurface()` that will also do necessary swapchain recreation in
case of window resize.
These methods required `ContextVk` pointer before this change:
- RenderTargetVk::releaseImageAndViews()
- replaced with `releaseSwapchainImage()` that does not release
framebuffer because Window Surface framebuffers are not managed by
the cache.
- added `release()` method that does release the framebuffer.
- WindowSurfaceVk::releaseSwapchainImages()
- use `Renderer::collectGarbage()` instead of
`ContextVk::addGarbage()`.
- use `ImageHelper::releaseImage()` instead of
`ImageHelper::releaseImageFromShareContexts()`. The
`finalizeImageLayoutInShareContexts()` was not required since
renderpass must be already ended, because swapchain recreate is only
possible after present. Removal of `addToPendingImageGarbage()` is
not going to cause OOM problems, because repeated swapchain
recreate calls are not possible without swap (submissions).
Bug: angleproject:397848903
Bug: angleproject:42264593
Change-Id: Iacfa3a144aa980659569b7100be25a44ebb9f0a0
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6298734
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
354a5463
|
2025-02-24T16:52:06
|
|
Vulkan: Remove recreateSwapchain ContextVk dependency
In the upcoming change, swapchain will be invalidated in swap, while
recreate deferred until ANI. After such invalidation, `lockSurface()`
wold not be possible. Even that currently swapchain may be invalid only
after previous recreate failure, this change adds `recreateSwapchain()`
call into `lockSurface()` because it is now possible and as a
preparation for the upcoming change.
The `recreateSwapchain()` is split into `invalidateSwapchain()` and
`recreateSwapchain()` methods. The invalidate must be called before the
recreate.
Bug: angleproject:397848903
Bug: angleproject:42264593
Change-Id: Ida4a98a985f9fbb527cdf8c81c088ae1210f409c
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6298733
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
79faadf7
|
2025-02-19T16:04:19
|
|
Vulkan: Simple WindowSurfaceVk refactoring
Changes:
- Update `ImageAcquireState` enumeration.
- Make `getCurrentWindowSize()` const. Some implementations are now
using local `surfaceCaps` variable instead of `mSurfaceCaps`, however
this will not affect reset of the logic.
- Remove `extentsOut` parameter from `createSurfaceVk()` and call
`getCurrentWindowSize()` explicitly only when needed.
- Remove `forceSwapchainRecreate` parameter since it is always has false
as an argument.
- Remove redundant `impl::` namespace.
- Make `queryAndAdjustSurfaceCaps()` const.
Bug: angleproject:397848903
Change-Id: I955be15fb4709e137f2ad8a165fd04a3fe626fbf
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6298732
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
e70d1298
|
2025-02-18T14:32:35
|
|
Vulkan: Rework SurfaceVk::mUse tracking logic
Original commit that introduced `mUse` had a bug and was then reverted:
Vulkan: SurfaceVk should only wait for GPU work that uses it
https://crrev.com/c/angle/angle/+/4220723
The reland fixed the original issue by adding
"contextVk::mLastSubmitQueueSerial" into "Surface::mUse" before calling
finish:
Reland "Vulkan: SurfaceVk should only wait for GPU work that uses it"
https://crrev.com/c/angle/angle/+/4406891
However, the real issue was that the `finish()` call (called because of
the "waitIdleBeforeSwapchainRecreation" feature) was done after
`releaseSwapchainImages()`, which resets all resource uses. Because of
this bug, `finish()` ignored all uses of swapchain images, causing GPU
crash on Mali. Crash was not because of semaphores that was not tracked
by resource use. Adding "mLastSubmitQueueSerial" fixed the crash simply
because it accounts for all uses ever made by the Context.
This change fixes this issue by calling `mergeImageResourceUses()` at
the beginning of `releaseSwapchainImages()`. Adds missing retain when
transitioning into the `ImageLayout::Present`. Updates one-off submit
tracking by updating use of the image, rather than `SurfaceVk::mUse`
directly. Explicitly tracks present semaphore submission. All these
changes allow to remove adding `ContextVk::mSubmittedResourceUse`
before calling `finish()` and in the `unMakeCurrent()`.
I confirmed that this fix works by forcing `oldSwapchain` destruction
(as if it was never used) and "waitIdleBeforeSwapchainRecreation"
enabled. GPU crash happens on SM-S921B if remove addition of
`mSubmittedResourceUse` before `finish()` call, and fixed again by
calling `mergeImageResourceUses()` in the `releaseSwapchainImages()`.
So the `mergeImageResourceUses()` fixes the issue without potentially
waiting for unrelated submissions from the `mSubmittedResourceUse`.
After this change, surface use tracking should work according to the
original intent.
Bug: angleproject:397848903
Bug: b/267806287
Change-Id: Ic8197e33d0c19aad274b5f9da6f9c7377a166b60
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6277446
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
318d4038
|
2025-02-18T13:19:28
|
|
Vulkan: Fix present optimization w.r.t shared present mode
Since the implementation of "EGL_KHR_mutable_render_buffer" mode
(angleproject:42262606), the renderpass optimization for present
(b/153885625) was not working correctly. It sill tries to transition
into `ImageLayout::Present`, but instead of entirely skipping the
transition, it inserts the barrier even when renderpass is still opened.
When both "supportsSharedPresentableImageExtension" and
"preferDynamicRendering" are enabled, code will hit ASSERT in
`flushToPrimary()` when attempting to record `ImageLayout::Present`
barrier into the primary command buffer.
Above issue is fixed by skipping the transitioning into
`ImageLayout::Present` when in shared present mode.
Other changes and fixes:
- removed renderpass flush when resolving with renderpass, since it is
not necessary (angleproject:42265256).
- above change reveled a bug in `finalizeImageLayout(&mColorImageMS)`
call. This call reverts the layout in the previous finalize call
from Present to ColorWrite. So it must have been inserted before
finalizing the swapchain image. Issue fixed by removing both finalize
calls.
- updated condition to skip invalidate w.r.t shared present mode
(b/229689340), that was missed during implementation of
"EGL_ANDROID_front_buffer_auto_refresh" (angleproject:42265697).
Test: angle_end2end_tests --gtest_filter=EGLSurfaceTest.PresentLayoutTransitionWithMSAA/*
Bug: b/153885625
Bug: angleproject:42262606
Bug: angleproject:42265256
Bug: b/229689340
Bug: angleproject:42265697
Change-Id: Ifad8aea8548fa7bfac27941812c435b2af655309
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6277445
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
fb118e41
|
2025-01-22T13:26:31
|
|
Vulkan: Always defer acquireNextSwapchainImage() call
This change is a preparation before the follow up EGL_WIDTH/EGL_HEIGH
eglQuerySurface rework.
There is no need to acquire initial swapchain image after surface
initialization. Skipping ANI may speed-up apps startup in some cases.
The operation is also removed from swap (in case of out-of-date
swapchain) for consistency and as a preparation for the follow up
change.
Change also enables "perFrameWindowSizeQuery" for NVIDIA on Windows
because of the "SurfaceDimensionsChangeAndFragCoord" test failure.
Test fails because `vkQueuePresentKHR()` does not return
`VK_ERROR_OUT_OF_DATE_KHR` when presenting old image size after the
window resize, even despite that surface caps currentExtent has already
new size. Issue is not permanent, and may "fix" itself if add few
empty swap buffers before starting the test or do ANI in the initialize
(which one will work depends on GPU).
Above issue is observed on the driver 546.01 (currently used by bots).
Old 531.68 and new 566.36 does not have this issue (tested on
RTX 3060 Laptop). The 546.01 driver, however, fails on that same
system even on the base CL (without this change).
Bug: angleproject:153329980
Bug: angleproject:42264593
Change-Id: I261e1f573a6b892f1ba4282dd17f17289c2f4184
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6182599
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
e6115fdd
|
2025-01-27T19:37:25
|
|
Vulkan: Fix and simplify Wayland window resize
The `doDeferredAcquireNextImage()` may only be called with
`forceSwapchainRecreate == true` argument when in
`ImageAcquireState::NeedToAcquire` state. In any case, method must not
be called when state is `ImageAcquireState::Ready`.
Instead of adding state check to the
`WindowSurfaceVkWayland::getAttachmentRenderTarget()` method, this
change removes this method entirely, since calling
`doDeferredAcquireNextImage()` is not required (as well as the
`mResided` member). The `WindowSurfaceVkWayland::mExtents` will be
compared with the current extent in the `checkForOutOfDateSwapchain()`
since "perFrameWindowSizeQuery" feature is enabled for Wayland.
Bug: angleproject:40096815
Change-Id: I31608d52ba72305cbb31220f21829ad18f9d2ce7
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6203062
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
b5809efa
|
2025-01-16T17:56:47
|
|
Delay eglSwapInterval() effect until swap
... and fix resetting effect of `eglSwapInterval()` call by changing
the `EGL_RENDER_BUFFER` attribute, and resetting desired shared present
mode when calling `eglSwapInterval()`.
Bug: angleproject:390333526
Change-Id: I473c7d4c5929e2179bbcd378b3695d10213644de
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6169922
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
c1214ec2
|
2025-01-22T14:22:56
|
|
Vulkan: Rename Context to ErrorContext
In preparation for adding another Context (derived by GL and CL
contexts), which includes logic that pertains to command recording (such
as barrier tracking).
Bug: angleproject:390443243
Change-Id: Idf495b62e63fb9aa901a2f16447fdaf3c2acd90b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6191248
Auto-Submit: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
16d8325f
|
2025-01-16T13:30:07
|
|
Vulkan: Make WindowSurfaceVk::setAutoRefreshEnabled thread safe
Bug: angleproject:379762019
Change-Id: I20feb72c4777a8dbd2058ced8a958d08b6c218ab
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6175131
Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
a1be7e61
|
2024-11-26T14:39:18
|
|
Implement EGL_EXT_surface_compression
This patch adds implementation of EGL_EXT_surface_compression to
ANGLE, including new API eglQuerySupportedCompressionRatesEXT and
adding EGL_SURFACE_COMPRESSION_EXT in EGLQuerySurface and
EGLCreateWindowSurface/EGLCreatePlatformWindowSurface.
Angle end2end test is added to verify the extension.
Bug: angleproject:375496226
Change-Id: I06926930d94485a378fc831d552cf55fe7938a57
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6073355
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
9c67a505
|
2024-12-11T14:29:59
|
|
Vulkan: Rename CommandProcessor.* to CommandQueue.*
Bug: angleproject:42262955
Change-Id: I5585309479d8c66e9ddfa41e12a757381ebb80bd
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6089885
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Roman Lavrov <romanl@google.com>
|
|
|
c75bd915
|
2024-12-10T23:01:44
|
|
Vulkan: Remove asyncCommandQueue
It's been years and it never showed an advantage. In the meantime,
performance without this feature seems close to native drivers (i.e. the
feature has lost its appeal) and it's frequently a source of
complication and bugs.
Bug: angleproject:42262955
Bug: angleproject:42265241
Bug: angleproject:42265934
Bug: angleproject:42265368
Bug: angleproject:42265738
Bug: angleproject:42266015
Bug: angleproject:377503738
Bug: angleproject:42265678
Bug: angleproject:173004081
Change-Id: Id8d7588fdbc397c28c1dd18aafa1f64cbe77806f
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6084760
Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
Reviewed-by: mohan maiya <m.maiya@samsung.com>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
cecefe53
|
2024-11-21T22:11:17
|
|
Vulkan: Improve recreateSwapchain() error handling
The `WindowSurfaceVk::recreateSwapchain()` method may fail in many
points. After failing, state of `WindowSurfaceVk` may become invalid,
causing undefined behavior.
Invalid state examples:
- Skip adding `cleanupData` into the `mOldSwapchains` while
`mPresentHistory already cleared (resource leak).
- `mSwapchain` may remain `VK_NULL_HANDLE` after the failure.
- `lastSwapchain` may be not retired, causing subsequent swapchain
creation to fail.
Change adds `mLastSwapchain` member to continue tracking last created
swapchain during the `mSwapchain` recreation process until it is
retired. This process now may span multiple API calls. The `mSwapchain`
pointer is invalidated as soon as recreate starts - to indicate that we
do not have usable swapchain and still need to create one.
Notable difference with the old code is that old swapchain and present
history are now collected into the `mOldSwapchains` after new swapchain
is created (or old swapchain is retired in case of a failure). Because
of this, code can now be simplified and easily refactored into a
separate method. The `kMaxOldSwapchains` is now also checked after old
swapchain is collected - this is to prevent resource leak if `finish()`
fails. Added `cleanUpOldSwapchains()` call to reduce a chance of hitting
the `kMaxOldSwapchains` limit.
Change also renamed `presentOutOfDate` parameter where it does not
always make sense. As a side effect, fixed a bug when calling
`prepareForAcquireNextSwapchainImage()` with true, is then replaced
with false in the `computePresentOutOfDate()` call.
Bug: angleproject:380234227
Change-Id: Ie6d85c1b9760cda68c8fc9368235756659a9bdac
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6040159
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
f458f865
|
2024-11-12T16:52:42
|
|
Vulkan: Update AcquireNextImageUnlocked() implementation
Main goal of this change is to simplify acquire next image operation
state change tracking.
Key members before this change:
1. `mAcquireOperation.needToAcquireNextSwapchainImage`
2. `unlockedAcquireResult.acquireSemaphore`
Possible states:
1: 2:
false NULL -> image is acquired or no need
true ANY -> need to prepare for and do unlocked ANI
false HANDLE -> need to process ANI result
Only `mAcquireOperation.state` is used after this change.
Possible states:
Ready -> image is acquired or no need
NeedToAcquire -> need to prepare for and do unlocked ANI
NeedToProcessResult -> need to process ANI result
Value of `unlockedAcquireResult.acquireSemaphore` is now only used
as semaphore in the post process and not as boolean, indicating that
result needs processing.
Change adds a lot of ASSERTs to protect from invalid scenarios. In order
for these ASSERTs to work as expected, `deferAcquireNextImage()` is now
called regardless if swapchain is out-of-date or not.
Another functional change is that `postProcessUnlockedAcquire()` does
not mark image as processed at the start and then defers ANI in case of
a failure (so the next ANI fail again), but instead keeps the current
state (NeedToProcessResult) allowing failure to be processed again
without repeating ANI call in case if there will be no swapchain
recreation. State is set to `Ready` only after processing is successful.
Bug: angleproject:42265346
Bug: angleproject:42266579
Change-Id: I4a6a66fa3b6f25a788a8959eff5848b7ec5bdd27
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6018094
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
|
ea86503c
|
2024-11-20T19:47:49
|
|
Vulkan: Remove vkAcquireNextImageKHR multi-threading support
Currently, it is not possible to call `TryAcquireNextImageUnlocked()`
from multiple threads. However, original implementation added
multi-threading support for future use.
Possible future use:
- First thread (where Surface is current) calls
`eglPrepareSwapBuffersANGLE()` which will call
`TryAcquireNextImageUnlocked()` in the unlocked tail call (without the
share group lock).
- Other thread (where shared Context is current) calls some EGL/GLES
API under the share group lock, that may cause calling
`doDeferredAcquireNextImage()` on the Surface from the first thread.
Calling this method may call `TryAcquireNextImageUnlocked()` under the
share group lock, while it is also called from the first thread in the
unlocked tail call. Calling `doDeferredAcquireNextImage()` may also
cause swapchain recreation.
Taking into account above scenario, current implementation has following
bugs:
1. Possibility to recreate the swapchain from other thread, while first
thread is going to or calling the `TryAcquireNextImageUnlocked()`
function:
a) Other thread may call `prepareForAcquireNextSwapchainImage()`
because `NeedToProcessAcquireNextImageResult()` is still false
until first thread finishes `TryAcquireNextImageUnlocked()` call.
Also, checking `NeedToProcessAcquireNextImageResult()` from other
thread is not thread safe.
b) Other thread finished `TryAcquireNextImageUnlocked()` first, but
with `VK_ERROR_OUT_OF_DATE_KHR` error. First thread still did not
get the chance to call this function because of OS's thread
scheduling delays. Other thread will set
`needToAcquireNextSwapchainImage = true` and will start to
recreate a swapchain. At this time, first thread will start
executing `TryAcquireNextImageUnlocked()`, and because bool is
true - it will actually perform ANI during recreate from other
thread.
2. Possibility to call `TryAcquireNextImageUnlocked()` with old
swapchain. This is similar to (1), but this time call is delayed
after swapchain is recreated.
Since above scenario currently is not possible and the described future
scenario is unlikely to ever happen, instead of fixing above problems
this CL removes the multi-threading support to simplify the code and
make these bugs N/A.
Change removes word "try" from structures, members, and functions
because without multithreading there is no need for that and just adds
unnecessary complication.
It also removes most of the "share group lock" mentions because now this
information is irrelevant and may cause confusion. What is relevant is
that `AcquireNextImageUnlocked()` MUST only be called from a thread
where Surface is current and only CAN access members that is only ever
accessed from this thread (regardless if the lock is taken or not).
For example, if in the future `unlockedAcquireResult` will be accessed
from other thread but with the share group lock held, while
`AcquireNextImageUnlocked()` will still only be called from the current
thread - then this will be a race condition.
Bug: angleproject:42265346
Bug: angleproject:42266579
Change-Id: Ie9be408c0a3b3c1f37ec80727ce5ad2cb8932dad
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6018093
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
1608d0be
|
2024-10-10T16:53:15
|
|
Vulkan: Isolate framebuffer fetch no-RP-break optim from DR
Prior to [1], changes to framebuffer fetch usage by shaders caused a
render pass break. This was due to a limitation of render pass
compatibility rules. It also caused other headache, such as needing to
clear the render pass cache, recreating pipelines etc.
[1]:https://chromium-review.googlesource.com/c/angle/angle/+/3697308
In [1] an important optimization was implemented for tiling GPUs where
ANGLE permanently switched to framebuffer fetch mode on first
encountering framebuffer fetch use. From that point on, ANGLE would
always make every render pass framebuffer fetch compatible.
In reality, the render pass break was unnecessary, which became apparent
with dynamic rendering (for example that whether the render pass
includes input attachments has no bearing on a pipeline that doesn't use
input attachments at all). In [2], dynamic rendering kept the render
pass break + permanent switch behavior for simplicity.
[2]:https://chromium-review.googlesource.com/c/angle/angle/+/5637155
This change untangles the optimization done for legacy render passes
from dynamic rendering, allowing dynamic rendering to start every render
pass without framebuffer fetch and enable it later if a framebuffer
fetch program is used.
This is in preparation for supporting depth/stencil framebuffer fetch,
where a perma-switch is troublesome (for example in combination with
read-only depth/stencil feedback loops).
Bug: angleproject:352364582
Change-Id: I31221cf22a28d58b9b2bf188e9c0b786cd0fe3d2
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5923120
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
fdec6935
|
2024-09-20T16:29:03
|
|
Workaround supportsSurfaceMaintenance1 on Linux with llvmpipe
Presence of multiple ICD appears to confuse the loader and we end up
with support reported but vkGetPhysicalDeviceSurfaceCapabilities2KHR
not actually working (see bug for more detials)
Bug: angleproject:368647924
Change-Id: Idc813b99f873643d067cc4b4e38f1ed5249500b4
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5875015
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Roman Lavrov <romanl@google.com>
|
|
8c12874c
|
2024-09-12T11:26:29
|
|
vulkan: add double buffer swapchain for fifo mode.
Double buffer swapchain usually drop the performance.
But at B* the default fps cap for silver device still at 30fps.
This change is for reduce latency.
Bug: b/311022968
Change-Id: Ida4044f439bbe3f235d53f5d1d2f945533cbb094
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5858255
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
177d15b3
|
2024-08-23T19:34:34
|
|
Vulkan: Simplify WindowSurfaceVk::prepareSwap() method
In case of swapchain recreate inside `prepareSwap()`, perform unlocked
ANI call as usual. ANI processing will be done late in `swap()` or
`getBufferAge()`. This is possible, because surface `getWidth/Height()`
is no longer require valid `mColorRenderTarget`.
Because of the above, `swapchainRecreatedOut` parameter was removed.
Additionally, `getBufferAge()` now uses
`doDeferredAcquireNextImageWithUsableSwapchain()` in order to process
possible VK_ERROR_OUT_OF_DATE_KHR error and recreate the swapchain,
instead of failing.
Test: angle_end2end_tests --gtest-filter=EGLSingleBufferTest.AcquireImageFromSwapImpl*
Bug: angleproject:6851
Bug: angleproject:8133
Change-Id: Ieb375781da2b1108d0a5e11dbb012885a946688e
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5806335
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
636d838e
|
2024-08-27T16:30:04
|
|
Vulkan: Decouple Window Surface width/height from color RT
`mColorRenderTarget` is invalidated in `releaseSwapchainImages()`
method, when swapchain is recreated. It remains invalid until ANI
result is processed in the `postProcessUnlockedTryAcquire()` method.
In case if swapchain recreate and processing of the results are done
in different API calls (prepareSwap and swap), other thread way query
invalid render target size using `eglQuerySurface()` API. Currently
this should not be possible, but may change in the future.
Another way to have invalid render target, is if ANI fails after
swapchain recreate.
To avoid above problems, surface size is cached after swapchain is
recreated. Implementation is moved to the `SurfaceVk` base class.
The `WindowSurfaceVk::getRotatedWidth/Height()` methods were unused.
`mColorRenderTarget` is now only acessed after ANI result is processed.
Bug: angleproject:1319
Change-Id: Ibc007f1e8d30b6281be93c4561e05dd2f14f44d3
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5816834
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
|
7d461b21
|
2024-07-10T14:11:53
|
|
Revert "Vulkan: Use VK_KHR_dynamic_rendering[_local_read]"
This reverts commit c379ff48043a47e444c388c45270db40d3172d50.
Reason for revert: Regresses CPU perf and memory when _not_ using DR
Original change's description:
> Vulkan: Use VK_KHR_dynamic_rendering[_local_read]
>
> Bug: angleproject:42267038
> Change-Id: I1f4eb0f309992a9c1c287a69520dadf5eff23b26
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5637155
> Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
> Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
> Reviewed-by: Charlie Lao <cclao@google.com>
Bug: angleproject:42267038
Change-Id: I3865f0d86813f0eeb9085a92875a33bd449b907f
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5691337
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
c379ff48
|
2024-06-10T22:01:57
|
|
Vulkan: Use VK_KHR_dynamic_rendering[_local_read]
Bug: angleproject:42267038
Change-Id: I1f4eb0f309992a9c1c287a69520dadf5eff23b26
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5637155
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
|
c3a1cae4
|
2024-04-15T14:58:55
|
|
Use angle::SimpleMutex everywhere in libGLESv2
Only cases left that use std::mutex are:
- Share group and the context ErrorSet mutexes as they need try_lock()
- Anywhere mutexes are used in conjunction with std::condition_variables
(as they explicitly require std::mutex)
Bug: angleproject:8667
Change-Id: Ib6d68938b0886f9e7c43e023162557990ecfb300
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5453294
Reviewed-by: Roman Lavrov <romanl@google.com>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
9475ac40
|
2023-11-15T10:25:06
|
|
Vulkan: Make efficient MSAA resolve possible
Prior to this change, using a resolve attachment to implement resolve
through glBlitFramebuffer was done by temporarily modifying the source
FramebufferVk's framebuffer description. This caused a good deal of
complexity; enough to require the render pass to be immediately closed
after this optimization.
The downsides to this are:
- Only one attachment can be efficiently resolved
- There is no chance for the MSAA attachment to be invalidated
In this change, resolve attachments that are added because of
glBlitFramebuffer are stored in the command buffer, with the
FramebufferVk completely oblivious to them. When the render pass is
closed, either the FramebufferVk's original framebuffer object is used
(if no resolve attachments are added) or a temporary one is created to
include those resolve attachments.
With the above method, the render pass is able to accumulate many
resolve attachments as well as have its MSAA attachments be invalidated
before it is flushed.
For a FramebufferVk that is resolved in this way, there used to be two
framebuffers created each time and thrown away as the code alternated
between starting a render pass without a resolve attachment and then
closing with one. With this change, there is now one framebuffer
(without resolve attachments) that is cached in FramebufferVk (and is
not recreated every time), and only the framebuffer with resolve
attachments is recreated every time.
Ultimatley, when VK_KHR_dynamic_rendering is implemented in ANGLE, there
would be no framebuffers to create and destroy, and this change paves
the way for that support too.
WindowSurfaceVk framebuffers are still imagefull. Making them imageless
adds unnecessary complication with no benefit.
-----------------
To achieve efficient MSAA rendering on tiling hardware, applications
should do the following:
```
glBindFramebuffer(GL_FRAMEBUFFER, msaaFBO);
// Clear the framebuffer to avoid a load
// Or invalidate, if not needed to load:
// glInvalidateFramebuffer(GL_DRAW_FRAMEBUFFER, ...);
glClear(...);
// Draw calls
// Resolve into the single sampled framebuffer
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, resolveFBO);
glBlitFramebuffer(...);
// Immediately discard the contents of the MSAA buffer, to avoid store
glInvalidateFramebuffer(GL_READ_FRAMEBUFFER, ...);
```
The above would translate to the following Vulkan render pass:
- MSAA LOAD_OP_CLEAR/DONT_CARE
- MSAA STORE_OP_DONT_CARE
- Resolve LOAD_OP_DONT_CARE
- Resolve STORE_OP_STORE
This makes sure the MSAA data doesn't leave the tile memory and greatly
reduces bandwidth usage.
Once anglebug.com/4892 is fixed, this would also allow the MSAA image
to never be allocated either.
Bug: angleproject:7551
Bug: angleproject:8625
Change-Id: Ia9f4d20863d76a013d8495033f95c7b39f77e062
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5388492
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Reviewed-by: Amirali Abdolrashidi <abdolrashidi@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
60aaf4a0
|
2024-03-14T12:58:56
|
|
Vulkan: Move renderer to namespace vk
This class is agnostic of EGL. This change moves it to namespace vk for
use with the OpenCL implementation
Bug: angleproject:8564
Change-Id: I57f7807d6af8b3d5d7f8efbaf8b5d537a930f881
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5371324
Reviewed-by: Austin Annestrand <a.annestrand@samsung.com>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
aba3705b
|
2024-03-02T21:58:34
|
|
Vulkan: Completely remove egl::Display from RendererVk
This class is now independent of EGL. The only mentions of EGL is
egl::ContextPriority, which is just an enum and is tolerable for now.
OpenCL can now instantiate RendererVk without having to create a temp
egl::Display.
Bug: angleproject:8564
Change-Id: Ia78cfcb3a48c97f397441cf7cda71d74cfaddd8f
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5335581
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Auto-Submit: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
f7eb7efb
|
2023-11-28T11:20:57
|
|
Vulkan: Fix camera panorama hang
When EGL attributes does not speficy color space, right now we pick
VK_COLOR_SPACE_SRGB_NONLINEAR_KHR. This overwrites the color space
people set via ANativeWindow. This causes camera goes into CSC
conversion and errors out and stops media codec pipeline and causes
camera to hang. This CL enables mapUnspecifiedColorSpaceToPassThrough
feature flag for all platform that supports VK_EXT_swapchain_colorspace
so that it will pick VK_COLOR_SPACE_PASS_THROUGH_EXT and vulkan
swapchain code will try to keep whatever color space surface already
has. The feature flag is still kept here in case there is regression and
we need to experiment this feature flag again. We can remove it once
everything settles down.
This CL also adds updateColorSpace() and getActualFormatID() to
de-duplicate the logic of R8G8B8_UNORM overriding and use of
VK_COLOR_SPACE_PASS_THROUGH_EXT.
Bug: b/309480316
Bug: b/302196568
Change-Id: I0952fe78c2bfd59446391c553745b2b5cb152a9d
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5066801
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Chris Forbes <chrisforbes@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
c5eb810b
|
2023-11-14T15:01:25
|
|
Remove angle::Result::Incomplete entirely
Bug: angleproject:8414
Change-Id: I8d607614614360b65c530e3e7647d8a7ba38b18e
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5031191
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
|
|
|
dbffa5d3
|
2023-05-30T15:43:45
|
|
Vulkan: Update present history logic
Keeping old Swapchain's `ImagePresentOperation`s with Fences can lead to
multiple "old swapchains" lists. This may cause situations exceeding
the `kMaxOldSwapchains` limit.
Instead of marking `ImagePresentOperation` as corresponding to an older
swapchain, accumulate all present history in the `mOldSwapchains`.
Since Fences are only used when VK_EXT_swapchain_maintenance1 is
supported, instead of attaching "old swapchains" to the first present
operation, they are destroyed when present Fences are signaled in the
new `cleanUpOldSwapchains()` method.
Also this CL fixes a bug:
if (mPresentHistory.empty() || mPresentHistory.back().imageIndex == kInvalidImageIndex)
The above condition will always pass when VK_EXT_swapchain_maintenance1
is supported.
Bug: angleproject:7847
Change-Id: I1a41944456756b8af740f1903c873823323a2e0b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4505952
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
552e7468
|
2023-05-26T18:39:55
|
|
Vulkan: Do not use ANI Fence in present semaphore recycling
Fences from `vkAcquireNextImageKHR()` has many problems on some
Intel drivers, and one of them does not have a workaround. Instead of
using ANI Fence, this change will use `swapSerial`, that has execution
dependency on ANI semaphore. As result, semaphore recycling will be
delayed a little longer, until the Device finises rendering to the
image. On practice, this will not significantly affect the total number
of allocated semaphores.
As a bonus, this change also fixes a bug with Shared Present Mode:
Current logic assumes that PE will only signal image's ANI fence after
waiting on previous present semaphore with this image. In reality, PE
returns same image index and fence that is always signaled.
Additionally, ANI call is not required at all.
There is no 100% safe solution when not using:
VkSwapchainPresentFenceInfoEXT
This CL will recycle present semaphores only after next present
semaphore is signaled. This not only ensures, that present semaphores
are not reused inflight, but also gives time to PE to finish waiting on
the semaphore until next present.
Bug: angleproject:8155
Bug: angleproject:7847
Change-Id: Ia112190d77ea7e04f8f9755cf56f5387744dc599
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4572426
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
7fd01d03
|
2023-04-19T00:54:24
|
|
Vulkan: Throttle the CPU without holding the global lock
CPU throttling goes through CommandQueue and is thread-safe. Performing
it in an unlocked tail call allows other unrelated EGL calls to go
through.
Bug: angleproject:8135
Change-Id: Idb3841be5d8ea8c4b76217f6707be26b28ea39c2
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4444027
Reviewed-by: Igor Nazarov <i.nazarov@samsung.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
|
d6481cdf
|
2023-04-18T22:36:39
|
|
Vulkan: Make eglPrepareSwapBuffersANGLE thread-safe
This function now only calls vkAcquireNextImageKHR without any further
processing of its results. That is deferred to the following
eglSwapBuffers call which does that under the share group lock.
The vkAcquireNextImageKHR call, together with the allocation of its
related semaphore and fence are protected by a fine-grained lock.
mNeedToAcquireNextSwapchainImage is turned atomic to guard against races
to call vkAcquireNextImageKHR from multiple contexts. Note that the
latter is not currently possible, but will be once calling
vkAcquireNextImageKHR is moved to the end of the render pass.
Bug: angleproject:6851
Bug: angleproject:8133
Change-Id: If2eeab475b4acf0621fd930c43d9d86a78a9197b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4445495
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Igor Nazarov <i.nazarov@samsung.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
aa1dc5da
|
2023-05-03T19:36:04
|
|
Revert "Vulkan: Simplify present history logic"
This reverts commit 1dee7cad284dda0c7c3ca18c10d8b7764353c7b0.
Reason for revert:
error: SurfaceVk.cpp:784 (destroy): ! Assert failed in destroy (..\..\src\libANGLE\renderer\vulkan\SurfaceVk.cpp:784): fence.getStatus(device) == VK_SUCCESS
Example builds:
https://ci.chromium.org/ui/p/angle/builders/try/win-test/13341/overview
https://ci.chromium.org/ui/p/angle/builders/try/win-test/13345/overview
Original change's description:
> Vulkan: Simplify present history logic
>
> Instead of marking `ImagePresentOperation` as corresponding to an older
> swapchain, accumulate all present history in the `mOldSwapchains`.
>
> Keeping old Swapchain's `ImagePresentOperation` with Fences can lead to
> multiple "old swapchains" lists. This may cause situations exceeding
> the `kMaxOldSwapchains` limit.
>
> Keeping items with Fences may help cleanup resources faster, but I think
> that it is not worth the code complexity. It also should be safe to
> recycle Fences at the same time as the Semaphores (when the first image
> is recycled).
>
> Also this CL may fix bug:
> if (mPresentHistory.empty() || mPresentHistory.back().imageIndex == kInvalidImageIndex)
> The above condition will always pass when using actual present Fences
> (VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT).
>
> Bug: angleproject:7847
> Change-Id: I39d854b03733dcb976c6bd7eb5f848d0cbece5d6
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4481251
> Reviewed-by: Charlie Lao <cclao@google.com>
> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
> Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Bug: angleproject:7847
Change-Id: Icf0cf5b12dd1efa682abebd83699b8d87dc07427
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4502778
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
1dee7cad
|
2023-01-17T18:01:49
|
|
Vulkan: Simplify present history logic
Instead of marking `ImagePresentOperation` as corresponding to an older
swapchain, accumulate all present history in the `mOldSwapchains`.
Keeping old Swapchain's `ImagePresentOperation` with Fences can lead to
multiple "old swapchains" lists. This may cause situations exceeding
the `kMaxOldSwapchains` limit.
Keeping items with Fences may help cleanup resources faster, but I think
that it is not worth the code complexity. It also should be safe to
recycle Fences at the same time as the Semaphores (when the first image
is recycled).
Also this CL may fix bug:
if (mPresentHistory.empty() || mPresentHistory.back().imageIndex == kInvalidImageIndex)
The above condition will always pass when using actual present Fences
(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT).
Bug: angleproject:7847
Change-Id: I39d854b03733dcb976c6bd7eb5f848d0cbece5d6
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4481251
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
cd6a58f2
|
2023-04-18T12:45:10
|
|
Vulkan: Make eglPrepareSwapBuffersANGLE less special
This function now uses the UnlockedTailCall mechanism so it doesn't
require as much special-case code generation.
This change does not fix the bug that this function is doing too much
work without holding any locks. That will be done in a follow up.
Bug: angleproject:6851
Bug: angleproject:8133
Change-Id: I77f4d514ff4aeef85bc1cc59214f7caa23aca7df
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4443186
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
9ae918cb
|
2023-02-03T15:14:00
|
|
Reland "Vulkan: SurfaceVk should only wait for GPU work that uses it"
This is a reland of commit 5b63e1dc1d5e96018d0ad30582265a612d309f3b
The added fix is add contextVk::mLastSubmitQueueSerial into
Surface::mUse before calling finish.
Original change's description:
> Vulkan: SurfaceVk should only wait for GPU work that uses it
>
> Right now when we destroy swapchain, we call mRenderer->finish() to
> finish everything, even though the work is unrelated to this surface.
> This CL changes it to only wait for ResourceUse of all images in the
> swapChain.
>
> Bug: b/267806287
> Change-Id: I33d136ad50961fbf5fbb200ff0f89f1dbf23585d
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4220723
> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
> Commit-Queue: Charlie Lao <cclao@google.com>
Bug: b/267806287
Change-Id: I160fd22595fcf292cc53c055e0678befa3b8501b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4406891
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
d58fbf04
|
2023-04-05T12:32:09
|
|
Vulkan: Wait for surface ANI semaphore only if image is used
Right now there is a bug that surface's ANI semaphore is added to
context when WindowSurfaceVk::getAttachmentRenderTarget get called,
which gets called from FramebufferVk::syncState, which is before we end
the previous render pass, due to the endRenderpass usually is deferred
until next renderPass starts. This caused ANI semaphore gets added to
the previous render pass's submission, which does not use surface, and
thus a bubble in GPU execution pipeline where the user FBO rendering
gets unnecessarily blocked until ANI semaphore is signaled. This lowers
GPU utilization and thus GPU frequency gets dropped and frame time
increased. This CL stores ANI semaphore to ImageHelper object and when
barrier is generated, the ANI semaphore is moved to CommandBuffer. When
CommandBuffer gets flushed and submitted, it gets added to the
waitSemaphores vector and submitted to vulkan. Since all use of swap
chain image must go through barrier code first (you need at least change
layout), this ensures ANI semaphore gets waited in exact and robust way.
Only the submission that references the swap chain image will be waited.
With this CL, professional_baseball_spirits reduces frame time from 3.8
ms to 2.7 ms, achieving parity with native GLES on pixel 7 pro.
Bug: b/275624771
Change-Id: Ifa6cacf9e3bc147bfde54eb7def2fca48c50aca0
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4400011
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
7ee61366
|
2023-03-09T16:18:56
|
|
Revert "Vulkan: SurfaceVk should only wait for GPU work that uses it"
This reverts commit 5b63e1dc1d5e96018d0ad30582265a612d309f3b.
Reason for revert: angle_deqp_internal_main_presubmit device lost in android rolls https://anglebug.com/8073
Original change's description:
> Vulkan: SurfaceVk should only wait for GPU work that uses it
>
> Right now when we destroy swapchain, we call mRenderer->finish() to
> finish everything, even though the work is unrelated to this surface.
> This CL changes it to only wait for ResourceUse of all images in the
> swapChain.
>
> Bug: b/267806287
> Change-Id: I33d136ad50961fbf5fbb200ff0f89f1dbf23585d
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4220723
> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
> Commit-Queue: Charlie Lao <cclao@google.com>
Bug: b/267806287
Bug: angleproject:8073
Change-Id: Id0bfe7be670b7d44ed91e61f2c98a189bd1f214c
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4324718
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Roman Lavrov <romanl@google.com>
|
|
|
ad7949c6
|
2023-01-17T19:24:59
|
|
Vulkan: Remove "rx::vk::ImageHelper" move constructor.
Move constructor was only used in the "rx::SwapchainImage" structure.
This CL replaces "image" member with "std::unique_ptr<vk::ImageHelper>".
This will remove source of bugs.
Bug: angleproject:8052
Change-Id: Ic16f674095233baaa56fbe8a8fb7ef3e323a7331
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4294905
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
|
|
|
5b63e1dc
|
2023-02-03T15:14:00
|
|
Vulkan: SurfaceVk should only wait for GPU work that uses it
Right now when we destroy swapchain, we call mRenderer->finish() to
finish everything, even though the work is unrelated to this surface.
This CL changes it to only wait for ResourceUse of all images in the
swapChain.
Bug: b/267806287
Change-Id: I33d136ad50961fbf5fbb200ff0f89f1dbf23585d
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4220723
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
e1dfc00a
|
2023-02-15T16:21:37
|
|
Vulkan: Make waitForPendingPresent drain work in the calling thread
Since we are waiting, there is no point to have work done in
CommandProcessor's worker thread. It can just wait and drain the task in
the calling thread. This is consistent with
waitForResourceUseToBeSubmitted. This allows us to remove mutex and
condition variable from SwapchainStatus.
Bug: b/269524271
Change-Id: I9d7e17c77c879b6957fc3b74aab02f7f5c9db052
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4257252
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Ian Elliott <ianelliott@google.com>
|
|
|
ceb49b1c
|
2023-01-17T19:21:43
|
|
Vulkan: Fix crashes when Surface is not current.
It is possible to destroy Surface while some resources are still
in use (by CPU/GPU):
1. Make Surface current.
2. Draw something.
3. Make other Surface current (same Context).
4. (optional - if test Surface is Window Surface) Draw something.
5. Delete Surface.
6. UnMake the Context from current.
7. Different crashes possible depending on Surface type and what
is done in step 2.
Bug: angleproject:8017
Test: angle_end2end_tests --gtest_filter="EGLSurfaceTest.DestroyNotCurrent*Surface*"
Change-Id: I3102aa237075b301b3222b420415753c83ba192a
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4227073
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
|
7da34485
|
2023-01-17T16:17:51
|
|
Vulkan: Changed "asyncCommandQueue" Pending Present info logic.
Required for future commits.
Details:
- Fixes possible stale result in "CommandProcessor::mSwapchainStatus"
after WindowSurfaceVk destruction.
- Fixes possible dead-lock when the old "getLastPresentResult()" method
might be called more than once.
- New implementation allows waiting multiple times
(and multiple threads) for the same Present result.
Before commit:
31c4093651079775acf34ea1bb06bdabb4ea4386
Vulkan: Rework present semaphore recycling
There was assert in CTS:
dEQP-EGL.functional.swap_buffers_with_damage.resize_before_swap.*
Assert failed in ~SwapchainCleanupData (../../src/libANGLE/renderer/vulkan/SurfaceVk.cpp:669): swapchain == VK_NULL_HANDLE
Because of the stale "CommandProcessor::mSwapchainStatus"
and a race-condition as the result.
The "Vulkan: Rework present semaphore recycling" did not fix
the problem, but rather changed undefined behavior symptom.
Bug: None
Change-Id: Idf08a29265a43c711941b142001eb4380e2aa2b6
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4194184
Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
b6cc5754
|
2023-01-17T16:17:22
|
|
Vulkan: Fixed Wait Semaphores problems.
This feature fixes 2 problems.
1. Swapchain Image Acquire Semaphore added to wait list AFTER
rendering commands:
- Make Window Surface current.
- Clear Window Surface (Image is Acquired).
- Perform rendering to the Window Surface.
- Change to other Surface (for example: PbufferSurface) using
the same Context.
- Unmake Context from current to ensure commands are submitted.
- Rendering commands to the Window Surface will be submitted
without Acquire Semaphore.
2. Context from other thread may submit command of another Context
without proper Wait Semaphores:
- Make Window Surface current in the first context.
- Clear Window Surface (Image is Acquired).
- Perform rendering to the Window Surface.
- Call "glBeginQuery()/glEndQuery()" (or other commands) - this will
flush command to the Primary Command Buffer without submitting.
- In other Thread and Context make some Surface current
(for example: PbufferSurface).
- Clear that surface with scissor and unmake Context from current
to ensure commands are submitted.
- Rendering commands to the Window Surface from the first Context
will be submitted without Acquire Semaphore.
- Problem will happen even if add Wait Semaphore BEFORE writing
rendering commands.
Bug: angleproject:7995
Test: angle_end2end_tests --gtest_filter="EGLSurfaceTest.WaitSemaphoreAddedAfterCommands*"
Test: angle_end2end_tests --gtest_filter="EGLSurfaceTest.CommandsSubmittedWithoutWaitSemaphore*"
Change-Id: I28174ff98fdd09b4117962fc0810cfeeb2a4d1f1
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4194182
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
|
28da0a3e
|
2022-11-28T14:43:10
|
|
Vulkan: Avoid swapchain recreation on present mode change
Bug: angleproject:7878
Change-Id: I5a36c206dc8feb640fc684f92c10c26628633601
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4088907
Reviewed-by: Ian Elliott <ianelliott@google.com>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Jeff Vigil <j.vigil@samsung.com>
|
|
|
ffbb65bc
|
2022-11-28T13:31:48
|
|
Vulkan: Use VK_EXT_swapchain_maintenance1 for present fences
Bug: angleproject:7878
Change-Id: Ic3a43c663789a6489cff261848d9ad4a408ca53a
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4088905
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Ian Elliott <ianelliott@google.com>
|
|
|
2e5ca217
|
2022-11-18T10:44:49
|
|
Vulkan: Let each current context has its own QueueSerial.
This CL makes every current context has its own queueSerial. At context
creation time or when context becomes current, it allocates a QueueIndex
from renderer. When it becomes non-current, it releases QueueIndex for
others to reuse. This way we significantly reduces the max number of
QueueIndexs for reasonable usage. Each CommandBuffer has its own unique
QueueSerial and we use that to determine if a resource is being used by
the given CommandBuffer. The QueueSerial for RenderPassCommands is
deferred until renderPass starts, and when we generate queueSerial for
renderPassCommands, we also reserve a range of serials for
outsideRenderPassCommands so that we can do incremental submission of
outsideRenderPassCommands without need to close renderPassCommands. In
rare situation, if that reserved serials runs out, we also close
renderPassCommands to ensure the ordering of serials matches ordering of
command buffers.
With per current context queue serial, this CL is able to set resource
queue serial as it is being used. This CL completely removes usage of
ResourceUseList class since it was introduced due to deferred setSerial.
This CL also get rid of refCount from ResourceUse since there we no
longer add it to a ResourceUseList. With that, we also able to remove
SharedResourceUse class since access to ResourceUse itself is now thread
safe since we are able to make a copy of it when we add it to
GarbageList.
Because RenderPassCommands now has its own unique QueueSerial as it
encodes command, we can use it to detect if a resource is being used by
it or not, thus this CL also removes usage of CommandBufferID.
Bug: b/255414841
Change-Id: I36dcbeaa7bc996f04e6c04bf9ad44cd0d630f61a
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4038096
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
2ecb3217
|
2022-11-28T15:24:39
|
|
Vulkan: Turn CPU throttling into fail safe
CPU throttling is moved back to after queue present instead of before.
Doing it before was a mistake, as the app had already recorded the
command buffers, there was no point in delaying its submission.
Proper throttling would have been moving the wait from after recording
commands (before present of frame i+2) to before recording (after
present of frame i+1). However, throttling is the responsibility of the
app and this change triggers throttling one frame later (after present
of frame i+2) as a fail safe.
Currently, CPU throttling is relied upon for acquire semaphore
recycling. If the two are untangled, CPU throttling can be removed.
CPU throttling can also be trivially weakened by increasing
kSwapHistorySize (currently 2).
Bug: angleproject:7268
Change-Id: Ib7a8be6f8e72c6b8589d4e8b5de7ceaf6a28bb8e
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4060454
Reviewed-by: Ian Elliott <ianelliott@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
|
31c40936
|
2022-11-25T12:28:27
|
|
Vulkan: Rework present semaphore recycling
Present semaphores and old swapchains are now associated with a fence
for clean up. The fence is the one coming from the _next_ acquire of
the same image index.
See doc/PresentSemaphores.md for more details.
Bug: angleproject:7847
Change-Id: I16891ccf6df7ac39d8b17328aac35afc422eede0
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4058286
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Ian Elliott <ianelliott@google.com>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
|
7dd8478e
|
2022-11-17T10:11:02
|
|
Vulkan: Make ResourceUse::serial an FastVector of Serials
In preparation for per context queue serial, this CL makes
ResourceUse::serial a FastVector of Serial. Right now we still limited
to one serial index so that it still work the same way as before. This
CL adds necessary data type and change the function names to reflect
that tracking GPU progress needs a ResourceUse object instead of a
single Serial number.
Bug: b/255414841
Change-Id: Ic60cdf5ec8da45d1821f65a55947f5c553f65737
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4034548
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
c19ec948
|
2022-08-23T10:43:59
|
|
Vulkan: Implement imageless framebuffers
* Added the attachment image and create info objects to be used
for imageless framebuffers created in getFramebuffer().
* New helper class for framebuffers in RenderPassCommandBufferHelper:
MaybeImagelessFramebuffer, which includes a framebuffer object, if
the framebuffer is imageless, and the image views. This is to make
sure that the args for render pass begin info will be correctly set
up according to the status of the used framebuffer.
* Refactored the collection of attachments in getFramebuffer() into
a new function, getAttachmentsAndImagesFromRenderTargets(). It also
returns their corresponding ImageHelper* objects used to create the
framebuffer (from their image properties).
* New struct: RenderTargetInfo; which keeps track of render targets
and whether resolve image should be used for the render pass in the
form of the enum class RenderTargetImage.
* Added a new arg to getFramebuffer(): resolveRenderTargetIn; to use
when there is a valid resolveImageViewIn.
* Without using the framebuffer cache, we would require to handle
the framebuffer destruction by adding it to the garbage instead
of releasing it. For example, FramebufferVk::destroy() now adds
mCurrentFramebuffer to the garbage.
* Added new framebuffer unit tests.
* Added tests where two textures with different attributes are bound
to the same framebuffer before drawing, one after another.
* Added test where a blit occurs from a multisample texture into a
non-zero level of a resolve texture, each bound to a separate FBO.
* Added a new perf test to compare performance for enabled imageless
framebuffers vs disabled. (Credit: cclao)
Bug: angleproject:7553
Change-Id: Iacdbd73aaa01cbb0e37abf01ae4892bdfdd4b12f
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3827644
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Amirali Abdolrashidi <abdolrashidi@google.com>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
79aa846e
|
2022-08-17T13:40:33
|
|
Reland "Not recreate Framebuffer for eglMakeCurrent() call"
This is a reland of commit bf9c815263455403e587a9d2b0fdb9fb8e964208
Original change's description:
> Not recreate Framebuffer for eglMakeCurrent() call
>
> Right now, in eglMakeCurrent() call, ANGLE always release the
> default framebuffer object associated to the current context,
> and create a new default framebuffer object for the new current
> context. It impacts chrome performance, since chrome call
> eglMakeCurrent() a lot. With this CL, the default framebuffer
> will be created with gl::Context. When the surface is changed
> by eglMakeCurrent() call, ANGLE will detach the previous surface
> from the associated framebuffer, and attach the new surface to
> the next current context's default framebuffer.
>
> Bug: chromium:1336126
> Change-Id: Iaa747669250ae250245db383a716b4634df59ea4
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3827751
> Commit-Queue: Peng Huang <penghuang@chromium.org>
> Reviewed-by: Jamie Madill <jmadill@chromium.org>
> Reviewed-by: Geoff Lang <geofflang@chromium.org>
Bug: chromium:1336126
Change-Id: Iade19004a4335ac7bc6ca176a3c14d34afff8c9e
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3877405
Auto-Submit: Peng Huang <penghuang@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
|
|
|
02e8497f
|
2022-09-07T01:12:31
|
|
Revert "Not recreate Framebuffer for eglMakeCurrent() call"
This reverts commit bf9c815263455403e587a9d2b0fdb9fb8e964208.
Reason for revert: compile errors
https://ci.chromium.org/ui/p/chromium/builders/try/linux-chromeos-rel/1303510/overview
Original change's description:
> Not recreate Framebuffer for eglMakeCurrent() call
>
> Right now, in eglMakeCurrent() call, ANGLE always release the
> default framebuffer object associated to the current context,
> and create a new default framebuffer object for the new current
> context. It impacts chrome performance, since chrome call
> eglMakeCurrent() a lot. With this CL, the default framebuffer
> will be created with gl::Context. When the surface is changed
> by eglMakeCurrent() call, ANGLE will detach the previous surface
> from the associated framebuffer, and attach the new surface to
> the next current context's default framebuffer.
>
> Bug: chromium:1336126
> Change-Id: Iaa747669250ae250245db383a716b4634df59ea4
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3827751
> Commit-Queue: Peng Huang <penghuang@chromium.org>
> Reviewed-by: Jamie Madill <jmadill@chromium.org>
> Reviewed-by: Geoff Lang <geofflang@chromium.org>
Bug: chromium:1336126
Change-Id: I7c07f62236f57523b29c536c04f9a9de79da2f4b
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3877404
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Auto-Submit: Peng Huang <penghuang@chromium.org>
Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
Commit-Queue: Yuly Novikov <ynovikov@chromium.org>
|
|
|
bf9c8152
|
2022-08-17T13:40:33
|
|
Not recreate Framebuffer for eglMakeCurrent() call
Right now, in eglMakeCurrent() call, ANGLE always release the
default framebuffer object associated to the current context,
and create a new default framebuffer object for the new current
context. It impacts chrome performance, since chrome call
eglMakeCurrent() a lot. With this CL, the default framebuffer
will be created with gl::Context. When the surface is changed
by eglMakeCurrent() call, ANGLE will detach the previous surface
from the associated framebuffer, and attach the new surface to
the next current context's default framebuffer.
Bug: chromium:1336126
Change-Id: Iaa747669250ae250245db383a716b4634df59ea4
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3827751
Commit-Queue: Peng Huang <penghuang@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
|
|
aa2a558e
|
2022-08-23T09:47:02
|
|
Vulkan: Add support for setting timestamp surface attribute
On Android the EGL wrapper handles most of the functionality required
by EGL_ANDROID_get_frame_timestamps. However if for some reason the
swapchain is recreated, the timestamp state would be lost resulting in
stuttering.
Introduce EGL_ANGLE_timestamp_surface_attribute extension that adds
support for toggling the EGL_TIMESTAMPS_ANDROID attribute of a surface.
Cache this state and recreate the swapchain accordingly.
Bug: angleproject:7489
Test: EGLSurfaceTest.TimestampSurfaceAttribute*
Test: dEQP-EGL.functional.get_frame_timestamps*
Change-Id: I3660f7137c006d904164d243a682a4ff520eabd8
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3753396
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Ian Elliott <ianelliott@google.com>
Commit-Queue: mohan maiya <m.maiya@samsung.com>
|
|
|
badfeecd
|
2022-08-10T14:38:43
|
|
Vulkan: Destroy fb1 should not affect fb2 with same attachments
If two FBOs has the same attachments. they will share the same
VkFramebuffers. Destroy one fbo should not cause trouble for the other
fbo.
Bug: chromium:1351170
Change-Id: I032da8cc12eb8556c3e325c8fd7a3de9974ae909
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3824302
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
007a4f06
|
2022-04-22T11:07:05
|
|
Vulkan: Wayland resize callback
Handle client resize requests and resize the swapchain accordingly after
next buffer swap.
Bug: angleproject:6902
Change-Id: I8bd6b0d4efac041606f15eccb6befa28594905b2
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3608089
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jeff Vigil <j.vigil@samsung.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
6cd08bc2
|
2022-06-28T22:04:07
|
|
Vulkan: Don't optimize away flush after clear for single buffer
Bug: b/237449314
Change-Id: I04421398e2e68541d4713c7e8b80715be68672b2
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3733808
Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: mohan maiya <m.maiya@samsung.com>
|
|
|
d50b2276
|
2022-06-21T12:05:28
|
|
Reland "Vulkan: Support EGL_ANDROID_front_buffer_auto_refresh"
This is a reland of commit ef60d38ecf12d6663e9ecccacbff9803b1fba7c6
There are no fixes as the revert itself was a speculative one
Original change's description:
> Vulkan: Support EGL_ANDROID_front_buffer_auto_refresh
>
> Cache value of EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID attribute
> and set swapchain present mode accordingly when recreating
> swapchain in single buffer mode.
>
> Bug: angleproject:7224
> Tests: EGLAndroidAutoRefreshTest.Basic*
> Change-Id: I2dbb92ce5c3fa047e0b02ea9011725311f346027
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3707570
> Reviewed-by: Ian Elliott <ianelliott@google.com>
> Commit-Queue: mohan maiya <m.maiya@samsung.com>
> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
> Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Bug: angleproject:7224
Bug: angleproject:7465
Change-Id: Ia876ea17169c0f1b3afdb7753570e0b1aca985f5
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3733521
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
46ddcc44
|
2022-06-27T14:53:31
|
|
Revert "Vulkan: Support EGL_ANDROID_front_buffer_auto_refresh"
This reverts commit ef60d38ecf12d6663e9ecccacbff9803b1fba7c6.
Reason for revert: crashes in end2end tests on Win Intel Vulkan
Original change's description:
> Vulkan: Support EGL_ANDROID_front_buffer_auto_refresh
>
> Cache value of EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID attribute
> and set swapchain present mode accordingly when recreating
> swapchain in single buffer mode.
>
> Bug: angleproject:7224
> Tests: EGLAndroidAutoRefreshTest.Basic*
> Change-Id: I2dbb92ce5c3fa047e0b02ea9011725311f346027
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3707570
> Reviewed-by: Ian Elliott <ianelliott@google.com>
> Commit-Queue: mohan maiya <m.maiya@samsung.com>
> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
> Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Bug: angleproject:7224, angleproject:7465
Change-Id: Ia48a31124c8e0a3e4bcd4b7dc6f62b0782b42d97
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3726099
Commit-Queue: Yuly Novikov <ynovikov@chromium.org>
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
|
|
|
ef60d38e
|
2022-06-21T12:05:28
|
|
Vulkan: Support EGL_ANDROID_front_buffer_auto_refresh
Cache value of EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID attribute
and set swapchain present mode accordingly when recreating
swapchain in single buffer mode.
Bug: angleproject:7224
Tests: EGLAndroidAutoRefreshTest.Basic*
Change-Id: I2dbb92ce5c3fa047e0b02ea9011725311f346027
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3707570
Reviewed-by: Ian Elliott <ianelliott@google.com>
Commit-Queue: mohan maiya <m.maiya@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
|
|
|
6e258863
|
2022-05-09T18:45:02
|
|
Vulkan: Use packed enum for present modes
This will be useful for cases where ANGLE would need a non-Vulkan
present mode.
Bug: angleproject:7217
Change-Id: I3428ac9fb20788543cb24a0aa5f140e992e94001
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3636057
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
95c1ff52
|
2022-02-24T08:31:52
|
|
EGL: Fix EGL_KHR_mutable_render_buffer
Fixes for eglSurfaceAttrib error cases.
Improve query for render buffer
Add test case to EGLSurfaceTest
Test: angle_end2end_test --gtest_filter=EGLSingleBufferTest
Bug: angleproject:7134
Change-Id: I4fa568c9530312003dc17111be212bf5b66d97fb
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3556088
Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
2dd13ebb
|
2022-04-21T11:25:00
|
|
Track Surface color & depth/stencil init separately.
This clears up some trace testing confusion due when robust
resource init is enabled, and the app clears color but not
depth on the default surface.
Bug: angleproject:7221
Change-Id: Id97871aec32ad831b663aaa9116e04b582ab5a36
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3600375
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
|
|
|
607d398e
|
2022-03-14T16:32:21
|
|
Vulkan: Optimize resolve of multisample swapchains
* Resolves the multisampled image if the last render pass
draws into the default framebuffer.
* Added test to check the number of resolves in the optimization
subpass (credit: Xinyi He)
* Added test to check the number of resolves outside the subpass.
* Added disabled test to see if the subpass resolve works.
Bug: angleproject:6762
Change-Id: I86a8db3387851ab97d5f7a3d8a0ff26961254c14
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3523062
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Amirali Abdolrashidi <abdolrashidi@google.com>
|
|
e74d0e81
|
2022-02-11T18:05:12
|
|
Vulkan: Implement EGL_KHR_partial_update
This change provides a trivial implementation of partial
update that does nothing, making apps that want this
extension happy. A possible efficient Vulkan implementation
would use the damage set to narrow down render area, but it
appears to only be useful for only some TBDR hardware.
Bug: angleproject:6960
Reviewed-by: Antonio Caggiano <antonio.caggiano@collabora.com>
Change-Id: Ic553ac9590c336093f1bf25a6521574622599bf6
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3427640
Reviewed-by: Ian Elliott <ianelliott@google.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Auto-Submit: Constantine Shablya <constantine.shablya@collabora.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
7d7cca47
|
2022-01-17T18:00:25
|
|
Vulkan: Update default FBO when fetch in use
If the fetch mode of the default framebuffer changes, lazily create
and use a new set of framebuffers (one per swapchain image) that are
setup for fetch (i.e. have a matching renderpass).
Test: FramebufferFetchES31.DefaultFramebufferTest
Test: FramebufferFetchES31.DefaultFramebufferMixedProgramsTest
Bug: angleproject:6893
Change-Id: Iff2b73d7c34b9b8ca9429c3f24aa700c2746cc81
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3401933
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Cody Northrop <cnorthrop@google.com>
|
|
|
e03f1753
|
2022-01-06T09:48:12
|
|
EGL: mutable_render_buffer deferredFlush fix
When in SINGLE_BUFFER mode, need to get around
deferredFlush and call Swapbuffers to force update
This must do status check for OUT_OF_DATE.
Bug: angleproject:6878
Change-Id: I34b7381f6799879bf6f6d490aba02feffc5c3748
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3373739
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Brandon Schade <b.schade@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
d6dd0cb5
|
2021-09-21T15:26:13
|
|
EGL: EGL_KHR_lock_surface3 backend
Add vulkan implementation
Add test: EGLLockSurface3Test
Test: angle_end2end_test --gtest_filter=EGLLockSurface3Test
Bug: angleproject:6062
Change-Id: Id5bfe37895b550392d11e9e9cc1262c1f0288c42
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3174323
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
926b43e7
|
2022-01-06T13:31:54
|
|
Reland: Frontend: separate lock in swap prep
Swapchain-based backends like Vulkan might block a lot in
vkAcquireNextImageKHR, which is bad for overall fast progress if we also
hold the global EGL lock there.
This CL starts to split the global EGL lock. We release the EGL lock
when performing vkAcquireNextImageKHR, and only maintain a lock for
surfaces.
This is done via a new custom entry point, EGL_PrepareSwapBuffers, so
that we can control how the global lock is used throughout the entire
call.
Bug: angleproject:6851
Change-Id: I095cd8b3bdbb13c842cab0a46148e2122582cdfd
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3373426
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Lingfeng Yang <lfy@google.com>
|
|
|
9d668d6c
|
2022-01-07T18:18:23
|
|
Revert "Frontend: separate lock in swap prep"
This reverts commit 40c5cb255c0a07bdab574aa076ee603e7d791ab3.
Reason for revert: Regression in TSAN caused by this CL:
https://ci.chromium.org/ui/p/angle/builders/ci/linux-tsan-test/352/overview
Original change's description:
> Frontend: separate lock in swap prep
>
> Swapchain-based backends like Vulkan might block a lot in
> vkAcquireNextImageKHR, which is bad for overall fast progress if we also
> hold the global EGL lock there.
>
> This CL starts to split the global EGL lock. We release the EGL lock
> when performing vkAcquireNextImageKHR, and only maintain a lock for
> surfaces.
>
> Bug: angleproject:6851
> Change-Id: I329d5c4c579718a4980c4261590f77099ce1400e
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3361249
> Reviewed-by: Charlie Lao <cclao@google.com>
> Reviewed-by: Geoff Lang <geofflang@chromium.org>
> Commit-Queue: Lingfeng Yang <lfy@google.com>
Bug: angleproject:6851
Change-Id: Ie03b784021f7b8b5c1ef95a911ef7da4029abd46
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3373165
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
|
|
|
40c5cb25
|
2022-01-06T13:31:54
|
|
Frontend: separate lock in swap prep
Swapchain-based backends like Vulkan might block a lot in
vkAcquireNextImageKHR, which is bad for overall fast progress if we also
hold the global EGL lock there.
This CL starts to split the global EGL lock. We release the EGL lock
when performing vkAcquireNextImageKHR, and only maintain a lock for
surfaces.
Bug: angleproject:6851
Change-Id: I329d5c4c579718a4980c4261590f77099ce1400e
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3361249
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Lingfeng Yang <lfy@google.com>
|
|
|
16ce5226
|
2021-12-01T16:58:49
|
|
Vulkan: Re-enable RGB8 for pbuffers.
pbuffers support was removed from RGB8 EGL configs to prevent mismatched
surface formats for surfaces backed by external memory, since ANGLE
overrides RGB8->RGBA8 for all surfaces. However, ANGLE no longer
supports surfaces backed by external memory with the Vulkan backend, so
we can re-enable RGB8 for pbuffers.
Bug: angleproject:6651
Change-Id: I7d8b666ed5e3226f067479758f44d9041dcb67b0
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3312361
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Ian Elliott <ianelliott@google.com>
Commit-Queue: Tim Van Patten <timvp@google.com>
|
|
|
fe42ac4d
|
2021-11-29T15:45:40
|
|
EGL: deferredFlush fix for PRESENT_MODE_SHARED
Add work around to deferredFlush for SINGLE_BUFFER
Fixes issue with EGL_KHR_mutable_render_buffer and
deferredFlush feature.
Bug: angleproject:6739
Change-Id: I81f87899f2c92a7e001b6aee2f88ecf7ba0d40a1
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3308224
Commit-Queue: Brandon Schade <b.schade@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
8b60855b
|
2021-09-15T15:16:10
|
|
EGL: implement EGL_KHR_mutable_render_buffer
Pass render buffer mode change to WindowSurfaceVk.
On mode change trigger OUT_OF_DATE. Then in CreateSwapchain,
if new mode, set the Presentation mode and the Image count.
OffscreenSurfaceVk ignores mode change.
Add MUTABLE_RENDER_BUFFER_BIT to GenerateDefaultConfig.
Test: dEQP-EGL.functional.mutable_render_buffer.*
Bug: angleproject:3966
Change-Id: I7b59708514bcda10f8d45ce5f9528aa840fcccfa
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3171822
Commit-Queue: Brandon Schade <b.schade@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
|
ddedcdaf
|
2021-10-14T23:35:45
|
|
Vulkan: Recycle vkAcquireNextImageKHR semaphores
This change optimizes CPU performance by recycling semaphores used for
ANI instead of creating and deleting them every frame.
Bug: angleproject:6580
Change-Id: I151ea227870ed7b8bd123cbf629a65723c4696d2
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3225085
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Ian Elliott <ianelliott@google.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
|
7aba3bc5
|
2021-10-14T23:14:37
|
|
Vulkan: Use a CircularBuffer helper class in SurfaceVk
There are two instances of circular buffer in SurfaceVk. A common
helper class is introduced by this change to consolidate the
implementation.
This is in preparation for a follow up change that introduces yet
another circular buffer in this class.
Bug: angleproject:6401
Change-Id: Id01b585567310a2528888114239a5c80ff93f1ee
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3225084
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Ian Elliott <ianelliott@google.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
|
d2b659f9
|
2021-03-25T15:40:58
|
|
EGL: implement EGL_EXT_protected_content Context
Add Validation check to Contexts and Surfaces
Add Vulkan protected memory features and properties
Add protected member to Surfaces and Contexts
Implement hasProtectedContent in Vulkan
Add QueueFamily helper, extent DeviceQueueMap
Protected Swapchains always on for Android
Add EGLProtectedContentTest
Test: angle_end2end_test --gtest_filter=EGLProtectedContentTest
Bug: angleproject:3965
Change-Id: I9352b1e594f71bb4e89cee7137a468940d186b1b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2800413
Commit-Queue: Mohan Maiya <m.maiya@samsung.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
|
49211c31
|
2021-03-02T11:22:28
|
|
Vulkan: Fix Overlay for prerotation
Bug: angleproject:5690
Change-Id: I906a259767c54e3ac9f3ac822b6d5ed5dcaa0bd5
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2725768
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Ian Elliott <ianelliott@google.com>
|
|
|
22fc9523
|
2021-02-03T15:32:48
|
|
EGL: implement EGL_EXT_buffer_age
Add extension flag.
Add Validation check to surface query.
Enable extension for vulkan.
Modify AcquireNextImage to ++frame count and tag images
with frame number.
Buffer age is the difference between current frame count
and the tagged frame number on the buffer.
getBuffeAge may need to trigger AcquireNextImage to be current.
Pass through egl extension and query.
Add EGLBufferAgeTest
Test: angle_end2end_test --gtest_filter=EGLBufferAgeTest
Test: angle_deqp_egl_tests
--deqp-case=dEQP-EGL.functional.buffer_age.*
Bug: angleproject:3529
Change-Id: I0cb94be1c3e85d6f33e82a6a1ccdc9731b6a7f23
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2684724
Commit-Queue: Mohan Maiya <m.maiya@samsung.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
|
|
60b03e62
|
2021-02-16T14:31:19
|
|
Create getRotatedExtents() and related methods
Created:
- WindowsSurfaceVk::getRotatedWidth()
- WindowsSurfaceVk::getRotatedHeight()
- RenderTarget::getRotatedExtents()
- ImageHelper::getRotatedExtents()
- ImageHelper::getRotatedLevelExtents2D()
Note: The FramebufferVk class doesn't use any of these methods
Bug: b/175793022
Change-Id: I64395688bfdb172d32853763743fc5f266a6b792
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2686102
Commit-Queue: Ian Elliott <ianelliott@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Tim Van Patten <timvp@google.com>
|
|
108b759e
|
2020-12-04T15:15:49
|
|
EGL: Update EGL headers/xml
The new EGL headers introduced 'EGL_NO_X11' which we could use
for ANGLE vulkan display/headless backend.
Changes in CL:
1. Updated include/EGL/egl*.h and scripts/egl.xml based on latest
EGL repo: https://github.com/KhronosGroup/EGL-Registry
Note: local modifications to the file were preserved in
eglext.h, search keyword 'eglext_angle.h' for detail
2. run scripts to update entry_points/loader
scripts/generate_entry_points.py
scripts/generate_loader.py
scripts/run_code_generation.py
3. Update ANGLE code on API 'eglSwapBuffersWithDamage'
4. Format with 'git cl format'
Bug: angleproject:5260
Change-Id: I70ed0dccecf0426929ef8b4775605554d66c5724
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2576314
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
e6a302a0
|
2020-11-07T10:49:15
|
|
Vulkan: Move vk::CommandQueue to RendererVk.
This consolidates most of the command processor vs queue logic in one
place. It also has a number of incidental changes related to fences:
- syncs now do not store a shared fence. instead they call command
apis to wait for a particular serial with a timeout. this is not
yet fully implemented in CommandProcessor.
- surface swap history stores a serial instead of a fence. because
the RendererVk class stores the command batches, we no longer have
to do messy things with ContextVk.
- it is no longer possible to ask for a wait on a serial that isn't
in the command queue.
Also adds mutex synchronization around the RendererVk methods.
Bug: angleproject:5217
Bug: b/172704839
Change-Id: I5faf0e24bb6ede79a927ab149b80bfa8baca4620
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2524548
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com>
Reviewed-by: Tim Van Patten <timvp@google.com>
|