access_by
Enum to control how the memory layout
will be accessed.
#include
<sdlt/access_by.h>
Syntax
enum access_by
{
access_by_struct,
access_by_stride
};Description
The
access_by_struct
causes data access via structure member
access. Nested structures will drill down through the structure members in a
nested manner. For example an Axis Aligned Bounding Box (AABB) containing two
Point3d objects (with x,y,z data members) will logically expand to something
like:
AABB local;
local = accessor.mData[i];access_by_stride
will cause data access through pointers to
built in types with a stride to account for the size of the primitive. For an
Axis Aligned Bounding Box (AABB) containing two Point3d objects (with x,y,z
data members) will logically expand to something like:
AABB local;
local.topLeft.x = *(accessor.mData + offsetof(AABB,topLeft) + offset(Point3d,x) + (sizeof(AABB)*i));
local.topLeft.y = *(accessor.mData + offsetof(AABB,topLeft) + offset(Point3d,y) + (sizeof(AABB)*i));
local.topLeft.z = *(accessor.mData + offsetof(AABB,topLeft) + offset(Point3d,z) + (sizeof(AABB)*i));
local.topRight.x = *(accessor.mData + offsetof(AABB,topRight) + offset(Point3d,x) + (sizeof(AABB)*i));
local.topRight.y = *(accessor.mData + offsetof(AABB,topRight) + offset(Point3d,y) + (sizeof(AABB)*i));
local.topRight.z = *(accessor.mData + offsetof(AABB,topRight) + offset(Point3d,z) + (sizeof(AABB)*i)); When vectorizing,
access_by_struct
can sometimes generate better code as the
compiler could perform wide loads and use shuffle/insert instructions to move
data into SIMD registers. However, depending on the complexity of the
primitive, it can also fail to vectorize, especially when the primitive
contains nested structures.
On the other hand
access_by_stride
has always vectorized successfully, because
the data access is simplified to an array pointer with a stride. The compiler
is able to handle any complexity of primitive, because it never sees the
complexity and instead just sees the simple array pointer with strided access.
access_by_struct
is probably the best choice as it offers
a chance of better code generation especially when used outside of a SIMD loop.
However if you run into issues when vectorizing, try
access_by_stride
to see if that alleviates the problem.
We leave this choice up to the developer and require they explicitly make a
choice, so this is not hidden behavior.