|
4109a90e
|
2024-04-16T17:31:11
|
|
LinkedUniform: avoid frequent GLenum -> index conversion
Certain functions such as getElementComponents() are frequently called
in driver_overhead benchmark, causing repeated GLenum -> index
conversion of the uniform type which shows up in profiling
(driver_overhead_2 trace)
Change LinkedUniform.pod.type to LinkedUniform.pod.typeIndex storing the
UniformTypeInfo index with conversion helpers.
Bug: b/335295728
Change-Id: Iae5cd58f4e2703589d23b8e52991fc4b97c5fb08
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5458741
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Roman Lavrov <romanl@google.com>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
0c4d6446
|
2024-01-24T10:38:45
|
|
Rework uniform block <-> uniform buffer mapping
In GLES, the shader declares which buffer binding a block (uniform,
storage or atomic counter) is bound to. For example:
layout(binding = 1) uniform ubo0 { ... };
layout(binding = 2) uniform ubo1 { ... };
layout(binding = 1) uniform ubo2 { ... };
In the above, ubo0 and ubo2 use data from the buffer bound to index 2
(through glBindBufferRange), while ubo1 uses data from the buffer bound
to index 1. For uniform blocks in particular, omitting the binding
is allowed, in which case it is implicitly bound to buffer 0.
GLES allows uniform blocks (and only uniform blocks) to remap their
bindings through calls to glUniformBlockBinding. This means that the
mapping of uniform blocks in the program (ubo0, ubo1, ubo2) to the
buffer bindings is not constant. For storage blocks and atomic counter
buffers, this binding _is_ constant and is determined at link time.
At link time, the mapping of blocks to buffers is determined based on
values specified in the shaders. This info is stored was stored in
gl::InterfaceBlock::binding (for UBOs and SSBOs), and
gl::AtomicCounterBuffer::binding. For clarity, this change renames
these members to ...::inShaderBinding.
When glUniformBlockBinding is called, the mapping is updated. Prior to
this change, gl::InterfaceBlock::binding was directly updated, trumping
the mapping determined at link time. A bug here was that after a call
to glProgramBinary, GL expects the mappings to reset to their original
link-time values, but instead ANGLE restored the mappings to what was
configured at the time the binary was retrieved.
This change tracks the uniform block -> buffer binding mapping
separately from the link results so that the original values can be
restored during glProgramBinary. In the process, the support data
structures for tracking this mapping are moved to ProgramExecutable and
the algorithms are simplified. Program Pipeline Objects maintain this
mapping identically to Programs and no longer require a special and more
costly path when a buffer state changes.
This change prepares for but does not yet fix the more fundamental bug
that the dirty bits are tracked in the program executable instead of the
context state, which makes changes not propagate to all contexts
correctly.
Bug: angleproject:8493
Change-Id: Ib0999f49be24db06ebe9a4917d06b90af899611e
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5235883
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
1100cc5c
|
2024-01-23T16:18:52
|
|
Rename ShaderVariableBuffer
It was only ever aliased to AtomicCounterBuffer after refactorings that
made other buffers not use this class anymore.
Bug: b/275102061
Change-Id: I09079d52bd107ed656c4c59a11e8a8027554a5ef
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5230141
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Charlie Lao <cclao@google.com>
|
|
8fcd4a50
|
2023-09-19T14:08:14
|
|
Cleanup POD struct usage to make them more consistent
In recent months, I have made many CLs to wrap various data structures
into a trivially copy-able struct. Some of them uses different
terminology. This CL replaces all of these to use a consistent name
"pod" in the struct, and "mPod" in a class.
This CL also turns ActiveVariable methods into macros to remove the code
duplication.
This CL also moves ProgramInput/ProgramOutput struct implementations
from Program.cpp to ProgramExecutable.cpp
Bug: b/275102061
Change-Id: Ia2a4210a9ea633f3d323bebe674ee74f8b90b363
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4877335
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Roman Lavrov <romanl@google.com>
|
|
|
9ca025d2
|
2023-09-18T15:50:48
|
|
Flatten BufferVariable/ShaderVariableBuffer/InterfaceBlock struct
InterfaceBlock inherits from ShaderVariableBuffer, ShaderVariableBuffer
is not a trivially copyable struct, this made InterfaceBlock not
trivially copyable. InterfaceBlock is being used by some app traces for
uniform blocks. BufferVariable inherits from sh::ShaderVariable which is
very complicated and not trivially copyable. This CL flattens all of
these three structs to simple structs without inheritance, and wraps all
trivially copyable data into one POD struct, thus load/save are cheaper.
Bug: b/275102061
Change-Id: I96f89176ce3d3131cb1d3ea3280c3c36c257560f
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4874610
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Roman Lavrov <romanl@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
b8d5a423
|
2023-08-21T14:43:42
|
|
Add static_assert(std::is_trivially_copyable<LinkedUniform>(),"")
Since we are using memcpy for LinkedUniform, it is desirable to utilize
compile time assertion to ensure that in future if anyone modifies POD
struct (and the class of data members of POD struct) and made it that no
longer memcopy-able, we would immediately caught at compile time.
std::is_trivially_copyable<>is exactly for this reason. In order to make
this work, the POD struct and any data it uses can not have user defined
copy constructor. The problem is that right now ANGLE is using
clang_use_chrome_plugins=true, and chrome-style generates warnings if
the complex struct (has more than 10 data members) does not define a
copy constructor, and that warning causes build failure with -Werror. So
clang_use_chrome_plugins=true and std::is_trivially_copyable have this
conflicting requirements that I can not apply both. This has been raised
to compiler team, but before we get a solution from them, if we have to
make a choice, I think the better choice is to disable
clang_use_chrome_plugins and apply std::is_trivially_copyable, since the
later is more critical to ensure safety, while chrome-style is mostly
trying to minimize the code size, but won't affect
correctness/robustness. This CL sets clang_use_chrome_plugins to false,
and removes the copy constructor and copy assignment operator from
BitSetT and LinkedUniform and added static assertion
is_trivially_copyable for LinkedUniform. Same thing applied to
ProgramInput as well.
In future once we have a better solution from compile team, we can
re-enable clang_use_chrome_plugins and disable only for structs that
requires is_trivially_copyable assertion.
Bug: b/275102061
Change-Id: If33415ea61deda568d855a7dd6a4fd6042058be5
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4799342
Reviewed-by: Roman Lavrov <romanl@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
5217beb2
|
2023-08-15T13:43:12
|
|
Reland "Tightly pack LinkedUniform by using int16_t"
This is a reland of commit 152cf62b38874238095a91307e4ea9bcdedf8f46
Original change's description:
> Tightly pack LinkedUniform by using int16_t
>
> There is a check of vector size when we link uniforms and the maximum
> vector size is 4096 due to we clamp the maxUniformBlockSize to 64KB. In
> reality, if we exceeds this number, program link will take really long
> time and then hit failure. So there is no real need to keep all the
> variables in 32 bit integer. This CL changes to 16 bit integer. Further,
> sh::BlockMemberInfo and ActiveVariable data members are embeded into
> LinkedUniform struct as well so that the unused variables can be removed
> and data can be tightly packed. This also makes LinkedUniform easier to
> maintain as a simple struct with basic data types. With this change,
> LinkedUniform size is reduced from 108 bytes down to 60 bytes, 48 bytes
> reduction. Given some apps has 200-ish uniforms, this CL reduces 48
> bytes x 200 = ~9K memory just for uniforms per program (which goes
> through hash compute and decompression and file reads).
>
> Bug: b/275102061
> Change-Id: I7fae20f5b75f3239305e2094a992e3040b8c8e4c
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4754133
> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
> Commit-Queue: Charlie Lao <cclao@google.com>
Bug: b/275102061
Change-Id: I1cdec9407e930608d3239a104dcbf77c8d8e2113
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4791661
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
9f48f931
|
2023-08-16T06:38:15
|
|
Revert "Tightly pack LinkedUniform by using int16_t"
This reverts commit 152cf62b38874238095a91307e4ea9bcdedf8f46.
Reason for revert: Suspect cause of failure in for several Linux MSan Tests, e.g.
https://ci.chromium.org/ui/p/chromium/builders/ci/Linux%20MSan%20Tests/42403/overview
https://ci.chromium.org/ui/p/chromium/builders/ci/WebKit%20Linux%20MSAN/22174/overview
https://ci.chromium.org/ui/p/chromium/builders/ci/Linux%20MSan%20Tests/42403/overview
Original change's description:
> Tightly pack LinkedUniform by using int16_t
>
> There is a check of vector size when we link uniforms and the maximum
> vector size is 4096 due to we clamp the maxUniformBlockSize to 64KB. In
> reality, if we exceeds this number, program link will take really long
> time and then hit failure. So there is no real need to keep all the
> variables in 32 bit integer. This CL changes to 16 bit integer. Further,
> sh::BlockMemberInfo and ActiveVariable data members are embeded into
> LinkedUniform struct as well so that the unused variables can be removed
> and data can be tightly packed. This also makes LinkedUniform easier to
> maintain as a simple struct with basic data types. With this change,
> LinkedUniform size is reduced from 108 bytes down to 60 bytes, 48 bytes
> reduction. Given some apps has 200-ish uniforms, this CL reduces 48
> bytes x 200 = ~9K memory just for uniforms per program (which goes
> through hash compute and decompression and file reads).
>
> Bug: b/275102061
> Change-Id: I7fae20f5b75f3239305e2094a992e3040b8c8e4c
> Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4754133
> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
> Commit-Queue: Charlie Lao <cclao@google.com>
Bug: b/275102061
Change-Id: Id344e306307553731097f06edafc40bfeb73ff80
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4780494
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Geoff Lang <geofflang@chromium.org>
|
|
|
152cf62b
|
2023-08-15T13:43:12
|
|
Tightly pack LinkedUniform by using int16_t
There is a check of vector size when we link uniforms and the maximum
vector size is 4096 due to we clamp the maxUniformBlockSize to 64KB. In
reality, if we exceeds this number, program link will take really long
time and then hit failure. So there is no real need to keep all the
variables in 32 bit integer. This CL changes to 16 bit integer. Further,
sh::BlockMemberInfo and ActiveVariable data members are embeded into
LinkedUniform struct as well so that the unused variables can be removed
and data can be tightly packed. This also makes LinkedUniform easier to
maintain as a simple struct with basic data types. With this change,
LinkedUniform size is reduced from 108 bytes down to 60 bytes, 48 bytes
reduction. Given some apps has 200-ish uniforms, this CL reduces 48
bytes x 200 = ~9K memory just for uniforms per program (which goes
through hash compute and decompression and file reads).
Bug: b/275102061
Change-Id: I7fae20f5b75f3239305e2094a992e3040b8c8e4c
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4754133
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
164ac246
|
2023-08-08T15:13:10
|
|
zero-initialize all memory in LinkedUniform.
LinkedUniform is serialized directly, ensure that any padding inserted
into the struct is zero so there is no chance of uninitialized reads
during serialization.
Bug: b/275102061
Bug: chromium:1470644
Change-Id: If6b9f579938019c7e16fb306ed3b7d839953f6d2
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4762085
Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
Commit-Queue: Geoff Lang <geofflang@chromium.org>
|
|
|
719165c8
|
2023-08-04T12:13:37
|
|
Remove "const UniformTypeInfo *typeInfo" from struct LinkedUniform
This is a cached pointer to the const kInfoTable. There isn't much of
performance benefit to cache here compare to directly retrieve from the
table. This cached pointer is removed in this CL, which means we do not
need to update the pointer in the ProgramExecutable::load().
This and a few earlier CLs that attempt to do memcpy for entire
mUniforms reduced average frame time of blade_and_soul_revolution app
trace 3%, from 4.3359 ms to 4.2066ms on pixel 7 pro.
Bug: b/275102061
Change-Id: I6fd34d665234e3a5cc85344924049bf5b13aaa80
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4753933
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
|
|
|
d1117834
|
2023-08-04T10:48:22
|
|
Simplify struct LinkedUniform a bit more
In earlier CL crrev.com/c/4740298, we added mFixedSizedData structure to
group the data memebrs that can be memcpy-able into one variable, so
that we can memcpy that. Since then, we have made entire LinkedUniform
struct memcpy-able (crrev.com/c/4750443 is doing memcpy of entire
std::vector<LinkedUniform>). Thus, there is no longer a need for
mFixedSizedData. This CL removes that.
This CL also removes isStruct and inArrayOfArrays from LinkedUniform,
since they are always false.
This CL also removes some unused APIs from LinkedUniform.
Bug: b/275102061
Change-Id: I6ead3d8f179efc0d383352f7ac0efa6bf3dc8a1b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4753932
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
41d27ec3
|
2023-08-03T18:06:08
|
|
load/save entire std::vector<LinkedUniform> with one call.
Now LinkedUniform is a simple data struct with only fundamental types,
we can load the entire vector at once.
Bug: b/275102061
Change-Id: I7c030677d02517f86d960de85b0e7ae2c916a26e
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4750443
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
eff12c1e
|
2023-08-03T12:10:05
|
|
Move name and mappedName out of LinkedUniform struct
These are std::string objects. This CL moves these two data out of
LinkedUniform and into ProgramExecutable class, side by side with
mUniforms. With these two data moved out, LinkedUniform is now a simple
struct with basic data types, and I can memcpy entire vector of
uniforms.
Bug: b/275102061
Change-Id: I9ae13e7daca85f8e5f3662a4718f190bebb5f5d2
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4750442
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
9c588180
|
2023-08-02T16:39:44
|
|
Change LinkedUniform::arraySizes from std::vector to unsigned int
We always flatten multiple dimensional arrays in the uniform to a one
dimensional array, so the arraySizes can be simplified to unsigned int
instead of a vector. With this, we can now move the arraySize into the
simple mFixedSizeData struct and the normal memcpy will cover the
load/save.
Bug: b/275102061
Change-Id: I24c026f783b755f7aa691a5db5746b6309a21227
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4735275
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
22438ad8
|
2023-08-02T14:01:45
|
|
Embed ActiveVariable into BufferVariable and ShaderVariableBuffer
This CL embeds ActiveVariable into BufferVariable and
ShaderVariableBuffer struct instead of subclass. This allows us to
remove the virtual function of ~ActiveVariable(), which means
ActiveVariable is a simple struct with basic types and memcpy can be
used for load/save. Thus, in this CL, I also moved activeVariables to
LinkedUniform::mFixedSizeData structure and let memcpy handle the
load/save.
Bug: b/275102061
Change-Id: I8d21080cfdd72d4d22cef927d136ca428d9b12e4
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4722265
Reviewed-by: Roman Lavrov <romanl@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
ee019f58
|
2023-08-01T17:03:24
|
|
Group fixed sized data of LinkedUniform into a struct
Most of gl::LinkedUniform struct is a basic types and can be simply
initialized with memcpy. This CL groups these together and encapsulate
them with get APIs. The load/save is now a single memcpy for the entire
fixed size data structure of basic types.
Bug: b/275102061
Change-Id: I49120c06ec941c783790ac0ecb0ee314a4234b26
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4740298
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Roman Lavrov <romanl@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
7bb13226
|
2023-08-01T12:10:44
|
|
Pack booleans inside struct LinkedUniform into bitfields
Right now every bool is load/stored as integer, which itself is a
memcpy. This CL moves them into a bitfield and load/store with one
uint32_t, thus improves efficiency of cache load/save.
Bug: b/275102061
Bug: angleproject:8223
Change-Id: Id8e8e8861c8fcbd75dbef6056e4ff6c8ad2fc4a1
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4740292
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Roman Lavrov <romanl@google.com>
|
|
|
79973750
|
2023-07-27T17:53:24
|
|
Let UniformLinker uses its own struct instead of LinkedUniform
UniformLinker itself needs more detailed information than the final
linked uniforms. Right now they are using the same data structure. This
CL adds a new structure for linker to use. Since the linker data
structure is temporary, we never needs to load/save from cache, we have
more freedom here to use complex data types. The benefit of separate out
intermediate structure from LinkedUniform is that it allows us to
further simplify LinkedUniform structure without change much of
ProgramLinkedResource implementation. As result of this, this CL removes
field and outerArraySizes (both are std::vector type) from
LinkedUniform.
Bug: b/275102061
Change-Id: Ic1291b51b8906ac586a2f25eb1dbbe74eae8fdc5
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4727742
Reviewed-by: Roman Lavrov <romanl@google.com>
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
f24ea41e
|
2023-07-31T11:12:44
|
|
Embed sh::ShaderVariable data member into gl::LinkedUniform
ProgramExecutable::load and save function is load/save each individual
data members. Uniform can be quite large as shown in some app traces and
this causes performance problem even when program memory has a cache
hit. This CL flattens gl::LinkedUniform structure by embedding
sh::ShaderVariable data members so that we can remove unrelated members
and also prepare for further optimization in future CLs.
Bug: b/275102061
Change-Id: I7c18cb73e359fba7cd6375b4b1635e9040ef140d
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4735152
Reviewed-by: Roman Lavrov <romanl@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Charlie Lao <cclao@google.com>
|
|
|
24f4007b
|
2023-06-08T00:41:55
|
|
Vulkan: Use SPIR-V ids instead of names in the transformer
This change removes the SPIR-V transformer's reliance on type and
variable names. As a result:
- String hashing is removed from the info map data structure and the
SPIR-V transformer
- The ID discovery class is entirely removed
- Internal variable names have become a detail of the compiler alone
(and are no longer exposed as part of the compiler interface)
- Some front-end name tracking is removed ("parentStructMappedName",
etc)
This change also properly cleans up xfb emulation types that were
previously left over.
This change allows the SPIR-V compiler to emit user strings as-is
instead of prefixing them with `u_` leading to more readable debug
shaders. Additionally, it will make it possible not to emit debug info
at all. Both of these changes will be done in follow ups.
Bug: angleproject:7220
Change-Id: Iaa127496209a27aaae2e0d14c41b22fffb0b72a2
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4600610
Reviewed-by: Roman Lavrov <romanl@google.com>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
10380f4b
|
2023-06-06T11:52:08
|
|
Vulkan: Output SPIR-V ids from compiler
In this change, the shader interface variables are given SPIR-V ids by
the compiler before SPIR-V generation. Those ids are made available
through the ShaderVariable interface.
The transformer does not yet rely on this information. A follow up
change will rework the backend's name->info map and the transformer to
directly use ids instead of names.
Bug: angleproject:7220
Change-Id: Ic0a62681d4bcf3ed171c39c3ecd83e438ea068c8
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4600609
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Roman Lavrov <romanl@google.com>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
|
|
|
01f629e3
|
2023-05-26T10:23:20
|
|
Vulkan: Remove the loop when calling updateShaderBuffers
Right now there is a loop of getLinkedShaderStages when calling
mShaderBuffersDescriptorDesc.updateShaderBuffers. The shaderType
variable is only used to check if block is active or not, and get
info.binding. They can be retrieved without loop of shaderType. This CL
removes the loop so that we call
DescriptorSetDescBuilder::updateShaderBuffers only once. Similar thing
is applied to atomic counter buffer and images.
Bug: b/282194402
Change-Id: I03f3b4a391e773dfc162877802a2f940311866b8
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4554625
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
8b79410b
|
2023-04-02T22:25:12
|
|
Vulkan: Treat readonly SSBOs as readonly!
Instead of assuming SSBOs are always written to, this change adds
plumbing for the backend to know when an SSBO is declared readonly and
marks the buffer readonly accordingly.
With this change, BufferVk can optimize uploads and copies to and from
the buffer with the knowledge that it can be safely mapped on the CPU
for read while it's being used by the GPU.
Bug: b/276002151
Change-Id: I75342148c07949a83436054a738395bbd88caec5
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4392720
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
dd86dd15
|
2022-03-25T14:55:05
|
|
Cache outer array offset in linked uniforms.
Our current tracking would only track one array dimension. For
nested arrays the flattened parent index would be incorrect.
Update this tracking so we can use it in the Vulkan descriptor
set caching. Store this value as a separate integer member to
avoid conflicting with other back-ends.
Bug: angleproject:6776
Change-Id: Ie1a5dc3d64ccac23dffcc73684d619336cb0f0da
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3550824
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Reviewed-by: Charlie Lao <cclao@google.com>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
|
|
0af8b596
|
2019-09-03T16:24:45
|
|
D3D11: Translate uniform blocks to StructuredBuffer when necessary
fxc exhibits slow compile performance with dynamic cbuffer indexing.
So when a uniform block contains only one large array member, which is
an array of structures, translate this uniform block to
a StructuredBuffer instead.
Bug: angleproject:3682
TEST=angle_end2end_tests.UniformBufferTest.*
Change-Id: Ife80dba8aae65b761737e095895e00a570230f88
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1782046
Commit-Queue: Xinghua Cao <xinghua.cao@intel.com>
Reviewed-by: Kenneth Russell <kbr@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
90a58622
|
2019-09-04T15:39:58
|
|
Refactor ShaderVariable to Remove Specializations
The following structs are being refactored and moved into the parent
struct ShaderVariable:
VariableWithLocation
Uniform
Attribute
OutputVariable
InterfaceBlockField
Varying
Bug: angleproject:3899
Test: CQ
Change-Id: I389eb3ab4ed44a360e09fca75ecc78d64a277f83
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1785877
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com>
Commit-Queue: Tim Van Patten <timvp@google.com>
|
|
1d5aaa6c
|
2019-08-06T11:20:13
|
|
Vulkan: support dynamic indices in array of arrays
Expands existing struct-sampler rewrite to flatten arrays of arrays.
This allows us to support dynamically-uniform array indexing, which is
core in ES 3.2.
Samplers inside (possibly nested) structs are broken apart as before,
and then if the type resulting from merging the array sizes of the field
and its containing structs is an array of array, the array is flattened.
Also adds an offset parameter to functions taking in arrays to account
for this translation.
As a result of outer array sizes leaking into function signatures,
functions taking arrays of different sizes are duplicated according to
how the function is invoked.
Bug: angleproject:3604
Change-Id: Ic9373fd12a38f19bd811eac92e281055a63c1901
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1744177
Commit-Queue: James Dong <dongja@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
9d737966
|
2019-08-14T12:25:12
|
|
Standardize copyright notices to project style
For all "ANGLE Project" copyrights, standardize to the format specified
by the style guide. Changes:
- "Copyright (c)" and "Copyright(c)" changed to just "Copyright".
- Removed the second half of date ranges ("Y1Y1-Y2Y2"->"Y1Y1").
- Fixed a small number of files that had no copyright date using the
initial commit year from the version control history.
- Fixed one instance of copyright being "The ANGLE Project" rather than
"The ANGLE Project Authors"
These changes are applied both to the copyright of source file, and
where applicable to copyright statements that are generated by
templates.
BUG=angleproject:3811
Change-Id: I973dd65e4ef9deeba232d5be74c768256a0eb2e5
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1754397
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
1ebe6014
|
2019-07-29T16:02:15
|
|
Vulkan: Only check sampler when setUniform1i(v)
1. only do isSampler checking when update int uniforms
2. inline some simple methods of LinkUniform
This fix reduce CPU time spent on `isSampler` call from 70ms to 30ms in
T-Rex bench on specific platform.
Bug: angleproject:3743
Change-Id: I98ef3c892df27e08d54ed40946d924b5a50c796c
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1725114
Commit-Queue: Tobin Ehlis <tobine@google.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Tim Van Patten <timvp@google.com>
|
|
|
29fba5e0
|
2019-07-04T17:08:41
|
|
Vulkan: Prepare for variable-stage pipelines
Compute (single-stage pipeline) is upcoming, but this change prepares
GlslangWrapper to handle any number of stages (mostly). Additionally,
this change binds each resource to each stage based on whether it's
active, so that we don't hit the per-stage limit of resources by binding
every resource to every stage.
Bug: angleproject:3633
Bug: angleproject:3562
Change-Id: Ifebf691482846e0371c6e314f514226a4cfee258
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1689330
Reviewed-by: Tim Van Patten <timvp@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
04ea03e4
|
2019-01-01T15:14:25
|
|
Make default block member info a constant.
Instead of generating a struct each time we can use a constexpr
constructor to use a single representation.
Bug: angleproject:3024
Change-Id: I14dec65a4f6ac9ab2f7e7af444862e4ceab88d8c
Reviewed-on: https://chromium-review.googlesource.com/c/1392395
Reviewed-by: Jiajia Qin <jiajia.qin@intel.com>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
|
|
|
b980c563
|
2018-11-27T11:34:27
|
|
Reformat all cpp and h files.
This applies git cl format --full to all ANGLE sources.
Bug: angleproject:2986
Change-Id: Ib504e618c1589332a37e97696cdc3515d739308f
Reviewed-on: https://chromium-review.googlesource.com/c/1351367
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
|
|
|
50cf2be0
|
2018-06-15T09:46:57
|
|
Reformat some style in touched files.
This was triggered by running the code generation script.
Bug: angleproject:2665
Change-Id: Id639c78eb618182ee1859678590cf0f559b572c2
Reviewed-on: https://chromium-review.googlesource.com/1101564
Reviewed-by: Olli Etuaho <oetuaho@nvidia.com>
Reviewed-by: Luc Ferron <lucferron@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
|
|
|
7ce4a151
|
2018-06-12T10:19:49
|
|
Add support for uint8_t and uint16_t bitsets.
These pack very well in some structs. Support is required so the
templates work as expected.
Also packs the Shader map into 8 bits. This includes a workaround for
an unusual warning generated by MSVC.
Bug: angleproject:2462
Change-Id: I804d1b9370b3951343718385210dec7d37700d73
Reviewed-on: https://chromium-review.googlesource.com/1091135
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Frank Henigman <fjhenigman@chromium.org>
|
|
7a8fe156
|
2018-04-28T12:59:58
|
|
ES31: Add link validation on MAX_COMBINED_SHADER_OUTPUT_RESOURCES
This patch adds the link validation on the maximum combined shader
output resources required in OpenGL ES 3.1 SPEC.
OpenGL ES 3.1 SPEC has restrictions on the sum of the number of all
active images, shader storage blocks and fragment shader outputs. A
link error will be generated if this sum exceeds the implementation-
dependent value of MAX_COMBINED_SHADER_OUTPUT_RESOURCES.
In order not to affect the existing image tests, this patch also
sets a temporary value for maxCombinedShaderOutputResources on D3D11
back-ends. We will set more accurate values for all the UAV related
resource limits in the next patch.
BUG=angleproject:2345
TEST=dEQP-GLES31.functional.state_query.integer.max_combined_shader_output_resources_*
Change-Id: Ib83a19ef0ae0b9af3422b5c970c7c07d96b2359d
Reviewed-on: https://chromium-review.googlesource.com/1039155
Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
|
|
|
3dd8d291
|
2018-03-30T09:39:09
|
|
Use ShaderBitSet for active use bits on uniforms
BUG=angleproject:2169
Change-Id: I192c2e3c453540c8a6d7b0d066218ea3c9fbaab2
Reviewed-on: https://chromium-review.googlesource.com/989411
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
|
|
|
385b3e03
|
2018-03-21T09:43:28
|
|
Use packed enums on shader types in ANGLE renderer
This patch uses a packed internal enum ShaderType everywhere we
need a shader type instead of the GLenum value of the shader type.
This patch also uses program::getAttachedShader(type) everywhere
we need to get gl::Shader from a program in ANGLE.
BUG=angleproject:2169
Change-Id: I28a7fa1cfe35622c57a486932911110688eaadec
Reviewed-on: https://chromium-review.googlesource.com/972844
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
|
|
107c7247
|
2018-03-20T15:45:35
|
|
ShaderVariable: separate fields for staticUse and active
Thus far the compiler has used the "staticUse" flag to mark variables
that should have rather been marked "active", meaning that the code
may actually execute in a way that accesses the variable. There's a
clear definition for this use of the term "active" in the GLES 3.0.5
spec, section 2.12.6, and in GLES 3.1 section 7.3.1.
Having separate fields for recording static use and "activeness" of a
variable is the first step to fixing this.
According to the spec, usually only active resources should be
considered when checking use against max limits. Also, only active
uniforms get assigned a location. libANGLE code now correctly checks
the active flag rather than the static use flag in these cases.
The static use field still mirrors the active field for now, since
some code in Chromium also needs to be fixed to use the active field
correctly before the two can diverge.
After Chromium is fixed, we can fix ANGLE so that static use
information is recorded earlier during compilation and will accurately
reflect whether variables are statically used. Currently the compiler
only records variables once some static use may already have been
pruned from the AST.
BUG=angleproject:2262
TEST=angle_unittests, angle_end2end_tests
Change-Id: I025bb71361246ae00c911a1f8b66ec045f665f29
Reviewed-on: https://chromium-review.googlesource.com/970962
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
|
|
7cec3353
|
2018-03-13T13:29:34
|
|
Vulkan: Get/SetUniform for float / int and vec*
Bug:angleproject:2392
Change-Id: I2110ecde653a85a28b515dc9d8473a1b37a73eb6
Reviewed-on: https://chromium-review.googlesource.com/962718
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Luc Ferron <lucferron@chromium.org>
|
|
|
0d88ec9f
|
2018-02-27T16:25:31
|
|
ES31: Add link validations on geometry shader uniforms
This patch adds the link validations on the uniforms defined in a
geometry shader.
1. Validate if there is any link mismatch between a geometry shader
uniform and a uniform defined in another shader in the current
graphics pipeline.
2. Validate if the number of images, samplers or atomic counters in
a geometry shader exceeds the related resource limit.
3. Validate if there is name contradiction between a geometry shader
uniform and a vertex shader attribute.
BUG=angleproject:1941
TEST=dEQP-GLES31.functional.shaders.linkage.es31.geometry.uniform.*
dEQP-GLES31.functional.geometry_shading.basic.*
dEQP-GLES31.functional.geometry_shading.conversion.*
dEQP-GLES31.functional.geometry_shading.emit.*
dEQP-GLES31.functional.geometry_shading.varying.*
dEQP-GLES31.functional.geometry_shading.instanced.geometry_*
dEQP-GLES31.functional.geometry_shading.instanced.invocation_output_*
dEQP-GLES31.functional.geometry_shading.instanced.draw_*
Change-Id: I365aee624a3a79658c3e4c7487a586cf9532b529
Reviewed-on: https://chromium-review.googlesource.com/939264
Commit-Queue: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
|
|
|
465835d6
|
2017-09-26T13:34:10
|
|
Support arrays of arrays in the API
The ShaderVariable class that is used as an interface between the
compiler and the rest of the code gets arrays of arrays support.
Array of array variables are passed from the compiler just like any
other variables. However, when stored in Program state each innermost
array constitutes a separate variable. This is done to make the
implementation match the GLES specification for program interface
query APIs.
This will be tested more fully once support for parsing arrays of
arrays lands in the compiler.
TEST=angle_end2end_tests, angle_unittests
BUG=angleproject:2125
Change-Id: I0f7159000f039be92a87a52b3b68cd9a215a21cb
Reviewed-on: https://chromium-review.googlesource.com/684742
Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
|
acf2f3ad
|
2017-11-21T19:22:44
|
|
Apply Chromium style fixes.
This addresses several minor code quality issues that are validated
in Chromium, but not yet applied to ANGLE:
* constructors and destructors must be defined out-of-line
* auto is not allowed for simple pointer types
* use override everywhere instead of virtual
* virtual functions must also be defined out-of-line
Slightly reduces binary size for me (~2k on Win, 150k on Linux).
Bug: angleproject:1569
Change-Id: I073ca3365188caf5f29fb28d9eb207903c1843e6
Reviewed-on: https://chromium-review.googlesource.com/779959
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
3a9090fa
|
2017-09-27T14:37:04
|
|
ES31: Add BUFFER_VARIABLE and SHADER_STORAGE_BLOCK program interfaces
This patch collects the shader storage block members information.
It implements getShaderStorageBlockMemberInfo and getShaderStorageBlockSize
for OpenGL backend. Meanwhile, it implements BUFFER_VARIABLE and SHADER_STORAGE_BLOCK
interfaces for program query.
BUG=angleproject:1920
TEST=angle_end2end_tests:ProgramInterfaceTest*
dEQP-GLES31.functional.layout_binding.ssbo*
dEQP-GLES31.functional.compute.basic.empty
dEQP-GLES31.functional.compute.basic.ssbo_rw*
dEQP-GLES31.functional.compute.basic.ssbo_local_barrier*
dEQP-GLES31.functional.compute.basic.copy_image_to_ssbo_small
dEQP-GLES31.functional.compute.basic.copy_ssbo_multiple_groups
dEQP-GLES31.functional.compute.basic.copy_ssbo_multiple_invocations
dEQP-GLES31.functional.compute.basic.copy_ssbo_single_invocation
dEQP-GLES31.functional.compute.basic.copy_ssbo_to_image_small
dEQP-GLES31.functional.compute.basic.shared_var*
dEQP-GLES31.functional.compute.basic.ubo_to_ssbo*
dEQP-GLES31.functional.compute.basic.write_multiple_arr*
dEQP-GLES31.functional.compute.shared_var.basic_type.*
dEQP-GLES31.functional.compute.shared_var.work_group_size.*
dEQP-GLES31.functional.atomic_counter.*
Change-Id: Ie8b81fde5a2e919aab77adb3d137c9ff2f193409
Reviewed-on: https://chromium-review.googlesource.com/712235
Reviewed-by: Olli Etuaho <oetuaho@nvidia.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
|
|
58f67be0
|
2017-10-27T08:59:27
|
|
ES31 program query: support AtomicCounterBuffer and UniformBlock
Calculates atomic counter buffer's shader reference according to its
child counters.
Merges GL_UNIFORM_BLOCK_* queries to GL_*.
Refreshes deqp_gles31_test_expectations.
BUG=angleproject:1920
TEST=angle_end2end_tests:ProgramInterfaceTest*
dEQP-GLES31.functional.state_query.program.active_atomic_counter_buffers_get_programiv
dEQP-GLES31.functional.layout_binding.ubo.*
Change-Id: Ia23ddfef5f5dd7e15628f4c259273e1c01c14d80
Reviewed-on: https://chromium-review.googlesource.com/715436
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
|
|
|
4ef25033
|
2017-11-01T09:36:51
|
|
Refactor StaticallyUsed
Gather vertexStaticUse, fragmentStaticUse, and computeStaticUse
into a new mixin class StaticallyUsed, from which various
program resources can inherit to track their shader references.
BUG=angleproject:1920
Change-Id: Ibb3c0fe035bb8789aad65dbdfefaf7cb17b64c4e
Reviewed-on: https://chromium-review.googlesource.com/748317
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
|
|
|
baf5d945
|
2017-08-28T20:45:48
|
|
ES31: Add UNIFORM support for ProgramInterface
Add program resource properties for uniform.
BUG=angleproject:1920
TEST=angle_end2end_tests:ProgramInterfaceTest*
Change-Id: Ia5cf6219db43b8b1f73efbb3565d21c86e9d3ec0
Reviewed-on: https://chromium-review.googlesource.com/638050
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
|
729b2c6e
|
2017-08-14T09:36:11
|
|
ES31: Enable shader storage buffer support for OpenGL backend
BUG=angleproject:1951
TEST=angle_end2end_tests:ShaderStorageBuffer
Change-Id: I1afc3cd005ad2e595c6ce937fc53e17423f8ec8b
Reviewed-on: https://chromium-review.googlesource.com/618132
Commit-Queue: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
|
|
|
f00f7ffe
|
2017-08-31T14:39:15
|
|
Add a Uniform type info table.
Currently most uniform type info is determined by switching on the
uniform type. Some values are computed from other values, which can
result in three or more switch statements plus some multiplies or
other math. This patch attempts to improve the speed by pre computing
necessary values into constant static tables.
Improves performance by about 7% in a uniform stress test.
BUG=angleproject:1390
Change-Id: I29bef259a17f6d6536171ade4950e2d712bfd39c
Reviewed-on: https://chromium-review.googlesource.com/643791
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
|
|
|
be5e2ec3
|
2017-08-31T13:28:28
|
|
Remove uniform memory copy from GL front-end.
This moves the uniform query to the back-end. In D3D, this requires
a bit more redesign, especially for matrix uniforms.
Gives about a 10% speed improvement in the GL/NULL uniforms stress
test on Windows (UniformsBenchmark.Run/gl_null_400_vec4).
BUG=angleproject:1390
Change-Id: Idac22a77118e9e94d2f28c585e31ff0bc785ba94
Reviewed-on: https://chromium-review.googlesource.com/623929
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
|
|
|
855d964b
|
2017-05-17T14:05:06
|
|
Prefix user-defined names in GLSL output
Now user-defined names are prefixed by _u in GLSL output in case name
hashing is not on. Internal names such as names of temporary variables
created in AST transformations are written out as such.
This makes handling of internal function names and internal variable
names consistent. It also removes the possibility of name conflicts
between user-defined names and internal names in case name hashing is
not on. In the same vein, it makes it safe to use GLSL reserved words
that are not reserved in ESSL as variable names in case name hashing
is not on.
This also makes the GLSL output more consistent with how names are
handled in HLSL output. Name hashing code is shared between
VariableInfo and OutputGLSLBase to ensure names are handled
consistently in both. The name that's used in the shader source for a
given interface variable is written out to ShaderVariable::mappedName.
An exception needs to be made for identifiers close to the length
limit, since adding any prefix would take them over the limit. But
they can be just written out as such, since we don't have any builtins
or ANGLE internal variables that have as long names and could create a
conflict.
BUG=angleproject:2139
BUG=angleproject:2038
TEST=angle_unittests, angle_end2end_tests, WebGL conformance tests
Change-Id: Id6ed052c4fab2d091227dc9a3668083053b67a38
Reviewed-on: https://chromium-review.googlesource.com/507647
Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
|
44183cce
|
2017-08-01T12:48:34
|
|
Micro-optimizations to draw call entry point.
Thanks to Markus from NVIDIA. This inlines some methods and optimizes
the check if a uniform is a bool type.
BUG=angleproject:2119
Change-Id: I6f2c2d22c577458b39de600d3c56ec8e1a456a7a
Reviewed-on: https://chromium-review.googlesource.com/591699
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Kenneth Russell <kbr@chromium.org>
|
|
|
eaef1e5e
|
2017-06-13T10:44:11
|
|
Link atomic counters to buffers
Gather counters from each shader and group them according the
layout qualifier 'binding' into each buffer.
BUG=angleproject:1729
TEST=angle_end2end_tests:AtomicCounterBufferTest
Change-Id: I8d0cd0d2bf65be37c035b0e1540481c8bee0bae4
|
|
|
af713a24
|
2017-04-19T09:10:56
|
|
ES31: Implement binding layout for uniform blocks
The binding point of uniform blocks can be specified in shaders with
this CL. See spec ESSL 3.10, section 4.4.4, page 58 for more info.
dEQP-GLES31.functional.ubo.* still can't completely pass as
the missing of arrays-of-arrays feature. Neither can
dEQP-GLES31.functional.layout_binding.ubo.* due to the incomplete
implementation of program interface APIs.
TEST=angle_end2end_tests:UniformBufferTest
BUG=angleproject:1442
Change-Id: If95d468fc109834a132b9b817730d3fdc3a615da
Reviewed-on: https://chromium-review.googlesource.com/483848
Commit-Queue: Jie A Chen <jie.a.chen@intel.com>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Olli Etuaho <oetuaho@nvidia.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
|
|
|
6ca2b65c
|
2017-02-19T18:05:10
|
|
Implement location layout qualifier for uniforms
This is a complete implementation of the uniform location layout
qualifier. Uniform location set in the shader is plumbed to shader
linking, which does several link-time checks for conflicts and
recursively applies the location to struct members.
Validate that location is consistent as specified in the table in
section 9.2.1 of the ESSL 3.10.4 spec. The location set in the shader
overrides the one set via the CHROMIUM_bind_uniform_location API.
Location conflicts must be checked even if the uniforms are not
statically used. Because of this unused uniforms are now recorded
during uniform linking. After linking checks are done, unused uniforms
are pruned from the program state.
Location is validated against the maximum number of uniform locations
at compile time as specified in section 4.4.3 of the ESSL 3.10.4 spec.
All dEQP uniform location tests don't yet pass due to unrelated bugs.
BUG=angleproject:1442
TEST=angle_end2end_tests, dEQP-GLES31.functional.uniform_location.*
Change-Id: I1f968e971f521fbc804b01e1a7c2b4d14f24d20f
Reviewed-on: https://chromium-review.googlesource.com/447942
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
|
|
|
ceb1048f
|
2017-02-13T12:31:03
|
|
Add classification of image type enums
Implement classifying image enums in utilities and plumb the image
type check to Uniform objects as well. This functionality will be used
to add API support for images.
BUG=angleproject:1442
Change-Id: Idd2ee5ebacd38290aeeace1177165c740bc42c7e
Reviewed-on: https://chromium-review.googlesource.com/441585
Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
|
|
|
ac4e9c3f
|
2017-01-13T14:07:12
|
|
Micro-optimize Uniform updates.
This saves a few re-computations of the same stuff.
BUG=angleproject:1671
Change-Id: I28f955cd880366a86c0bb22285a119e97661e2cb
Reviewed-on: https://chromium-review.googlesource.com/427326
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
|
|
15ac534a
|
2016-11-03T17:06:39
|
|
Program: clamp the number of uniforms to be copied
Reland with a temporary test suppression.
BUG=661413
Change-Id: I552b64de754b326dcd499b84d9f337b9d015dc8e
Reviewed-on: https://chromium-review.googlesource.com/411473
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
|
|
|
399d1a17
|
2016-11-15T14:55:06
|
|
Revert "Program: clamp the number of uniforms to be copied"
This reverts commit 9863a3ef180edb17307665e0cc65a16603222103.
Change-Id: I840a735b49bc4f2319c8af5f620d7f52bb7eecf1
Reviewed-on: https://chromium-review.googlesource.com/411470
Reviewed-by: Geoff Lang <geofflang@chromium.org>
|
|
|
9863a3ef
|
2016-11-03T17:06:39
|
|
Program: clamp the number of uniforms to be copied
BUG=661413
Change-Id: I1a146dae0d01edeb272a58610355261b0e23dec1
Reviewed-on: https://chromium-review.googlesource.com/406745
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
|
|
4c4c8e72
|
2016-08-04T12:25:34
|
|
Add compute program compilation and linking support
Compute shaders can be now compiled and linked to create programs.
Some tests are added to verify successful and unsuccessful compute
shader linking.
The patch also replaces std::array<int, 3> with a custom struct
WorkGroupSize.
BUG=angleproject:1442
TEST=angle_end2end_tests
TEST=angle_unittests
Change-Id: I4ab0ac05755d0167a6d2a798f8d7f1516cf54d84
Reviewed-on: https://chromium-review.googlesource.com/366740
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Olli Etuaho <oetuaho@nvidia.com>
Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
|
|
|
4a3c2341
|
2015-10-08T12:58:45
|
|
Program: Clean up UBO info gathering.
The data size & block member info was getting messy, so clean up
how we query this from the Impl layer.
Also remove the register information from gl::UniformBlock, moving
it into the D3D-only world.
BUG=angleproject:1172
Change-Id: I40af658ebbd6b7c1a4251906a387ebcbb621cf77
Reviewed-on: https://chromium-review.googlesource.com/304150
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Tryjob-Request: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
62d31cb6
|
2015-09-11T13:25:51
|
|
Re^6-land "Move Uniform and UBO info to the gl::Program layer."
This data was previously stored entirely in the Impl level. Move
as much as possible to the GL level, using a read-only view in the
Impl level. Some information in D3D-specific, and should be stored
separately in the Impl.
This patch has a lot of refactoring that splits the D3D and GL info,
and moves as much validation as possible to the GL layer, where it
is shared between the back-ends.
Re-land with fix for dEQP unused uniforms. The fix involves storing
a local copy of all uniform data in the GL layer. This will also
let us validate sampler indexes during draw calls at the GL layer.
Re-re-land with a fix for multiply defined symbols on Clang.
Re-re-re-land with a fix for boolean uniforms and Uniform{1234}f.
Re^4-land with a fix for boolean uniform arrays and UBO uniforms.
Re^5-land with a fix for a test warning on Linux.
Re^6-land with a fix for transposed matrix uniform arrays.
BUG=angleproject:1123
TEST=end2end_tests, bots, dEQP GLES3.ubo and GLES2.uniform_api
Change-Id: Ie6fcde1c16eb05d67191b629338b88302a2563f5
Reviewed-on: https://chromium-review.googlesource.com/298971
Tryjob-Request: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
fb53603c
|
2015-09-11T13:19:49
|
|
Revert "Re^5-land "Move Uniform and UBO info to the gl::Program layer.""
Failing dEQP-GLES3.functional.uniform_api.random.22 and 23:
There's a bug with arrays of tranpsosed matrix uniforms.
BUG=angleproject:1123
This reverts commit 78d356929bd0441d81e2dd8a63130cd6788e2fde.
Change-Id: If39b5908af39671dfe98965e6a1ba77fd18ea8fc
Reviewed-on: https://chromium-review.googlesource.com/299320
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
78d35692
|
2015-09-11T08:32:51
|
|
Re^5-land "Move Uniform and UBO info to the gl::Program layer."
This data was previously stored entirely in the Impl level. Move
as much as possible to the GL level, using a read-only view in the
Impl level. Some information in D3D-specific, and should be stored
separately in the Impl.
This patch has a lot of refactoring that splits the D3D and GL info,
and moves as much validation as possible to the GL layer, where it
is shared between the back-ends.
Re-land with fix for dEQP unused uniforms. The fix involves storing
a local copy of all uniform data in the GL layer. This will also
let us validate sampler indexes during draw calls at the GL layer.
Re-re-land with a fix for multiply defined symbols on Clang.
Re-re-re-land with a fix for boolean uniforms and Uniform{1234}f.
Re^4-land with a fix for boolean uniform arrays and UBO uniforms.
Re^5-land with a fix for a test warning on Linux.
BUG=angleproject:1123
TEST=end2end_tests, bots, dEQP GLES3.ubo and GLES2.uniform_api
Change-Id: I03afcd446d9e74573c4d4c712ed7407b91d8001c
Reviewed-on: https://chromium-review.googlesource.com/299180
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
a2eb02c9
|
2015-09-11T12:31:41
|
|
Revert "Re^4-land "Move Uniform and UBO info to the gl::Program layer.""
Test has a warning on Linux:
In file included from ../../third_party/angle/src/tests/test_utils/ANGLETest.h:13:
../../testing/gtest/include/gtest/gtest.h:1392:16: error: comparison of integers of different signs: 'const int' and 'const unsigned int' [-Werror,-Wsign-compare]
if (expected == actual) {
~~~~~~~~ ^ ~~~~~~
../../testing/gtest/include/gtest/gtest.h:1422:12: note: in instantiation of function template specialization 'testing::internal::CmpHelperEQ<int, unsigned int>' requested here
return CmpHelperEQ(expected_expression, actual_expression, expected,
^
../../third_party/angle/src/tests/gl_tests/UniformBufferTest.cpp:357:5: note: in instantiation of function template specialization 'testing::internal::EqHelper<false>::Compare<int, unsigned int>' requested here
EXPECT_EQ(GL_FLOAT, type);
^
BUG=angleproject:1123
This reverts commit 2ae1ee6161c24aab065190b1528f6195e80e34d0.
Change-Id: Ic3dabea54068377d1f2c5f722ba52966cf1a0491
Reviewed-on: https://chromium-review.googlesource.com/299170
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
2ae1ee61
|
2015-09-10T10:04:24
|
|
Re^4-land "Move Uniform and UBO info to the gl::Program layer."
This data was previously stored entirely in the Impl level. Move
as much as possible to the GL level, using a read-only view in the
Impl level. Some information in D3D-specific, and should be stored
separately in the Impl.
This patch has a lot of refactoring that splits the D3D and GL info,
and moves as much validation as possible to the GL layer, where it
is shared between the back-ends.
Re-land with fix for dEQP unused uniforms. The fix involves storing
a local copy of all uniform data in the GL layer. This will also
let us validate sampler indexes during draw calls at the GL layer.
Re-re-land with a fix for multiply defined symbols on Clang.
Re-re-re-land with a fix for boolean uniforms and Uniform{1234}f.
Re^4-land with a fix for boolean uniform arrays and UBO uniforms.
BUG=angleproject:1123
TEST=end2end_tests, bots, dEQP GLES3.ubo and GLES2.uniform_api
Change-Id: I4c9f5ed31b81380507bef7981f97086d642801ae
Reviewed-on: https://chromium-review.googlesource.com/298451
Tryjob-Request: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
61b8dd97
|
2015-09-09T19:04:04
|
|
Revert "Re-re-re-land "Move Uniform and UBO info to the gl::Program layer.""
Seems to be failing the dEQP-GLES2.functional.uniform_api tests relating to boolean arrays.
BUG=angleproject:1123
This reverts commit 892a6a4b17b35e89898be8b4605c1ee595d3ae13.
Change-Id: Ifc4ce3ca806ef88a02ac6f693334ac37ce098a88
Reviewed-on: https://chromium-review.googlesource.com/298520
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
892a6a4b
|
2015-09-09T10:17:15
|
|
Re-re-re-land "Move Uniform and UBO info to the gl::Program layer."
This data was previously stored entirely in the Impl level. Move
as much as possible to the GL level, using a read-only view in the
Impl level. Some information in D3D-specific, and should be stored
separately in the Impl.
This patch has a lot of refactoring that splits the D3D and GL info,
and moves as much validation as possible to the GL layer, where it
is shared between the back-ends.
Re-land with fix for dEQP unused uniforms. The fix involves storing
a local copy of all uniform data in the GL layer. This will also
let us validate sampler indexes during draw calls at the GL layer.
Re-re-land with a fix for multiply defined symbols on Clang.
Re-re-re-land with a fix for boolean uniforms and Uniform{1234}f.
BUG=angleproject:1123
TEST=end2end_tests,Canary WebGL (D3D11/GL), dEQP-GLES2+3.functional.uniform_api
Change-Id: Ia40820a5ce2f34ec2d27648b1dc940a8955e9999
Reviewed-on: https://chromium-review.googlesource.com/298440
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
b654f659
|
2015-09-08T20:40:00
|
|
Revert "Re-re-land "Move Uniform and UBO info to the gl::Program layer.""
Failes the gles2_conform_test:
GLES2ConformTest.GL2Tests_glGetUniform_input_run
Possibly also WebGL failures, will investigate.
BUG=angleproject:1123
This reverts commit 10750cb936288d8dd09d49fadd592904c06c56f9.
Change-Id: I1ae59325e1831589019bc5a27ffc2091d3994a65
Reviewed-on: https://chromium-review.googlesource.com/298200
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
10750cb9
|
2015-09-04T14:23:52
|
|
Re-re-land "Move Uniform and UBO info to the gl::Program layer."
This data was previously stored entirely in the Impl level. Move
as much as possible to the GL level, using a read-only view in the
Impl level. Some information in D3D-specific, and should be stored
separately in the Impl.
This patch has a lot of refactoring that splits the D3D and GL info,
and moves as much validation as possible to the GL layer, where it
is shared between the back-ends.
Re-land with fix for dEQP unused uniforms. The fix involves storing
a local copy of all uniform data in the GL layer. This will also
let us validate sampler indexes during draw calls at the GL layer.
Re-re-land with a fix for multiply defined symbols on Clang.
BUG=angleproject:1123
TEST=end2end_tests,Canary WebGL (D3D11/GL), dEQP-GLES2+3.functional.uniform_api
Change-Id: I7b55e4964fbe64e0106c37928c894146937a2476
Reviewed-on: https://chromium-review.googlesource.com/298110
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
2119dd05
|
2015-09-08T19:30:37
|
|
Revert "Re-land "Move Uniform and UBO info to the gl::Program layer.""
Problems with multiply defined symbols in the Linux builder.
BUG=angleproject:1123
This reverts commit ff1abe63c3d8af28e9755c8d0c95b2aeca27a0d9.
Change-Id: Ifcb2ad885d0841c128ffd69afb6594e37eba17fc
Reviewed-on: https://chromium-review.googlesource.com/298100
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
ff1abe63
|
2015-09-04T14:23:52
|
|
Re-land "Move Uniform and UBO info to the gl::Program layer."
This data was previously stored entirely in the Impl level. Move
as much as possible to the GL level, using a read-only view in the
Impl level. Some information in D3D-specific, and should be stored
separately in the Impl.
This patch has a lot of refactoring that splits the D3D and GL info,
and moves as much validation as possible to the GL layer, where it
is shared between the back-ends.
Re-land with fix for dEQP unused uniforms. The fix involves storing
a local copy of all uniform data in the GL layer. This will also
let us validate sampler indexes during draw calls at the GL layer.
BUG=angleproject:1123
TEST=end2end_tests,Canary WebGL (D3D11/GL), dEQP-GLES2+3.functional.uniform_api
Change-Id: I9074c057c2c67d4d3221ec11c5556a26e07c7ceb
Reviewed-on: https://chromium-review.googlesource.com/297070
Tryjob-Request: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
48705cad
|
2015-09-02T20:40:51
|
|
Revert "Move Uniform and UBO info to the gl::Program layer."
Seems to be failing dEQP-GLES2.functional.uniform_api.value.unused_uniforms.* on Linux (possibly Win as well)
BUG=angleproject:1123
This reverts commit 54f882c9167b1aff5b3700187a2048bd886e8b17.
Change-Id: I7dbbf40aae8dd9ebd35895df0dd338a3b6b9cc96
Reviewed-on: https://chromium-review.googlesource.com/297051
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
54f882c9
|
2015-09-02T14:33:48
|
|
Move Uniform and UBO info to the gl::Program layer.
This data was previously stored entirely in the Impl level. Move
as much as possible to the GL level, using a read-only view in the
Impl level. Some information in D3D-specific, and should be stored
separately in the Impl.
This patch has a lot of refactoring that splits the D3D and GL info,
and moves as much validation as possible to the GL layer, where it
is shared between the back-ends.
BUG=angleproject:1123
TEST=end2end_tests,Canary WebGL (D3D11/GL), dEQP-GLES2+3.functional.uniform_api
Change-Id: I8b7e1380a61590a46ccee646a47ffe9bda287f6b
Reviewed-on: https://chromium-review.googlesource.com/295124
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Tryjob-Request: Jamie Madill <jmadill@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>
|
|
|
55def583
|
2015-05-04T11:24:57
|
|
translator: Fix variable collection for gl_DepthRange.
*re-land with Linux fixes, and fix for locations*
This built-in uniform wasn't being collected in VariableInfo.cpp.
Also remove the existing workaround for D3D gl_DepthRange
collection.
BUG=angleproject:991
BUG=478570
Change-Id: Iba84651bfc58f82fd4ce039421874f561f83c348
Reviewed-on: https://chromium-review.googlesource.com/268840
Tested-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
|
|
|
2ec386bb
|
2014-12-03T14:44:38
|
|
Rename IsSampler to IsSamplerType.
BUG=angle:733
Change-Id: I62aece16c11aefdbf13c0b5faf83040fdb8555e6
Reviewed-on: https://chromium-review.googlesource.com/232960
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Geoff Lang <geofflang@chromium.org>
|
|
|
e69a3f28
|
2014-12-03T10:58:53
|
|
Add missing cstring include to Uniform.cpp.
This file was missing on GCC builds.
BUG=angle:773
Change-Id: I6222b5ee563d64967d878c422abd464c8c92e646
Reviewed-on: https://chromium-review.googlesource.com/231855
Tested-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Brandon Jones <bajones@chromium.org>
|
|
|
2b5420c0
|
2014-11-19T14:20:15
|
|
Merge libGLESv2 and libEGL classes into libANGLE.
BUG=angle:733
Change-Id: Ic491c971411fe82c56cd97c5c8325ac14ec218df
Reviewed-on: https://chromium-review.googlesource.com/230830
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Tested-by: Geoff Lang <geofflang@chromium.org>
|