archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
2055ef107a7cb4e5aeeffb5ccc8a2908a59cd7d0
blender-archive/intern/cycles/util/util_math_float4.h
Michael Jones (Apple) a0f269f682 Cycles: Kernel address space changes for MSL 
This is the first of a sequence of changes to support compiling Cycles kernels as MSL (Metal Shading Language) in preparation for a Metal GPU device implementation.

MSL requires that all pointer types be declared with explicit address space attributes (device, thread, etc...). There is already precedent for this with Cycles' address space macros (ccl_global, ccl_private, etc...), therefore the first step of MSL-enablement is to apply these consistently. Line-for-line this represents the largest change required to enable MSL. Applying this change first will simplify future patches as well as offering the emergent benefit of enhanced descriptiveness.

The vast majority of deltas in this patch fall into one of two cases:

- Ensuring ccl_private is specified for thread-local pointer types
- Ensuring ccl_global is specified for device-wide pointer types

Additionally, the ccl_addr_space qualifier can be removed. Prior to Cycles X, ccl_addr_space was used as a context-dependent address space qualifier, but now it is either redundant (e.g. in struct typedefs), or can be replaced by ccl_global in the case of pointer types. Associated function variants (e.g. lcg_step_float_addrspace) are also redundant.

In cases where address space qualifiers are chained with "const", this patch places the address space qualifier first. The rationale for this is that the choice of address space is likely to have the greater impact on runtime performance and overall architecture.

The final part of this patch is the addition of a metal/compat.h header. This is partially complete and will be extended in future patches, paving the way for the full Metal implementation.

Ref T92212

Reviewed By: brecht

Maniphest Tasks: T92212

Differential Revision: https://developer.blender.org/D12864
2021-10-14 16:14:43 +01:00

537 lines
14 KiB
C++
Raw Blame History

/*
* Copyright 2011-2017 Blender Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __UTIL_MATH_FLOAT4_H__
#define __UTIL_MATH_FLOAT4_H__
#ifndef __UTIL_MATH_H__
# error "Do not include this file directly, include util_types.h instead."
#endif
CCL_NAMESPACE_BEGIN
/*******************************************************************************
* Declaration.
*/
ccl_device_inline float4 operator-(const float4 &a);
ccl_device_inline float4 operator*(const float4 &a, const float4 &b);
ccl_device_inline float4 operator*(const float4 &a, float f);
ccl_device_inline float4 operator*(float f, const float4 &a);
ccl_device_inline float4 operator/(const float4 &a, float f);
ccl_device_inline float4 operator/(const float4 &a, const float4 &b);
ccl_device_inline float4 operator+(const float4 &a, const float f);
ccl_device_inline float4 operator+(const float4 &a, const float4 &b);
ccl_device_inline float4 operator-(const float4 &a, const float f);
ccl_device_inline float4 operator-(const float4 &a, const float4 &b);
ccl_device_inline float4 operator+=(float4 &a, const float4 &b);
ccl_device_inline float4 operator*=(float4 &a, const float4 &b);
ccl_device_inline float4 operator*=(float4 &a, float f);
ccl_device_inline float4 operator/=(float4 &a, float f);
ccl_device_inline int4 operator<(const float4 &a, const float4 &b);
ccl_device_inline int4 operator>=(const float4 &a, const float4 &b);
ccl_device_inline int4 operator<=(const float4 &a, const float4 &b);
ccl_device_inline bool operator==(const float4 &a, const float4 &b);
ccl_device_inline float distance(const float4 &a, const float4 &b);
ccl_device_inline float dot(const float4 &a, const float4 &b);
ccl_device_inline float len_squared(const float4 &a);
ccl_device_inline float4 rcp(const float4 &a);
ccl_device_inline float4 sqrt(const float4 &a);
ccl_device_inline float4 sqr(const float4 &a);
ccl_device_inline float4 cross(const float4 &a, const float4 &b);
ccl_device_inline bool is_zero(const float4 &a);
ccl_device_inline float average(const float4 &a);
ccl_device_inline float len(const float4 &a);
ccl_device_inline float4 normalize(const float4 &a);
ccl_device_inline float4 safe_normalize(const float4 &a);
ccl_device_inline float4 min(const float4 &a, const float4 &b);
ccl_device_inline float4 max(const float4 &a, const float4 &b);
ccl_device_inline float4 clamp(const float4 &a, const float4 &mn, const float4 &mx);
ccl_device_inline float4 fabs(const float4 &a);
ccl_device_inline float4 floor(const float4 &a);
ccl_device_inline float4 mix(const float4 &a, const float4 &b, float t);
ccl_device_inline float4 safe_divide_float4_float(const float4 a, const float b);
#ifdef __KERNEL_SSE__
template<size_t index_0, size_t index_1, size_t index_2, size_t index_3>
__forceinline const float4 shuffle(const float4 &b);
template<size_t index_0, size_t index_1, size_t index_2, size_t index_3>
__forceinline const float4 shuffle(const float4 &a, const float4 &b);
template<> __forceinline const float4 shuffle<0, 1, 0, 1>(const float4 &b);
template<> __forceinline const float4 shuffle<0, 1, 0, 1>(const float4 &a, const float4 &b);
template<> __forceinline const float4 shuffle<2, 3, 2, 3>(const float4 &a, const float4 &b);
# ifdef __KERNEL_SSE3__
template<> __forceinline const float4 shuffle<0, 0, 2, 2>(const float4 &b);
template<> __forceinline const float4 shuffle<1, 1, 3, 3>(const float4 &b);
# endif
#endif /* __KERNEL_SSE__ */
#ifndef __KERNEL_GPU__
ccl_device_inline float4 select(const int4 &mask, const float4 &a, const float4 &b);
ccl_device_inline float4 reduce_min(const float4 &a);
ccl_device_inline float4 reduce_max(const float4 &a);
ccl_device_inline float4 reduce_add(const float4 &a);
#endif /* !__KERNEL_GPU__ */
/*******************************************************************************
* Definition.
*/
ccl_device_inline float4 zero_float4()
{
#ifdef __KERNEL_SSE__
return float4(_mm_setzero_ps());
#else
return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
#endif
}
ccl_device_inline float4 one_float4()
{
return make_float4(1.0f, 1.0f, 1.0f, 1.0f);
}
ccl_device_inline float4 operator-(const float4 &a)
{
#ifdef __KERNEL_SSE__
__m128 mask = _mm_castsi128_ps(_mm_set1_epi32(0x80000000));
return float4(_mm_xor_ps(a.m128, mask));
#else
return make_float4(-a.x, -a.y, -a.z, -a.w);
#endif
}
ccl_device_inline float4 operator*(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return float4(_mm_mul_ps(a.m128, b.m128));
#else
return make_float4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
#endif
}
ccl_device_inline float4 operator*(const float4 &a, float f)
{
#if defined(__KERNEL_SSE__)
return a * make_float4(f);
#else
return make_float4(a.x * f, a.y * f, a.z * f, a.w * f);
#endif
}
ccl_device_inline float4 operator*(float f, const float4 &a)
{
return a * f;
}
ccl_device_inline float4 operator/(const float4 &a, float f)
{
return a * (1.0f / f);
}
ccl_device_inline float4 operator/(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return float4(_mm_div_ps(a.m128, b.m128));
#else
return make_float4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
#endif
}
ccl_device_inline float4 operator+(const float4 &a, const float f)
{
return a + make_float4(f, f, f, f);
}
ccl_device_inline float4 operator+(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return float4(_mm_add_ps(a.m128, b.m128));
#else
return make_float4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
#endif
}
ccl_device_inline float4 operator-(const float4 &a, const float f)
{
return a - make_float4(f, f, f, f);
}
ccl_device_inline float4 operator-(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return float4(_mm_sub_ps(a.m128, b.m128));
#else
return make_float4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
#endif
}
ccl_device_inline float4 operator+=(float4 &a, const float4 &b)
{
return a = a + b;
}
ccl_device_inline float4 operator-=(float4 &a, const float4 &b)
{
return a = a - b;
}
ccl_device_inline float4 operator*=(float4 &a, const float4 &b)
{
return a = a * b;
}
ccl_device_inline float4 operator*=(float4 &a, float f)
{
return a = a * f;
}
ccl_device_inline float4 operator/=(float4 &a, float f)
{
return a = a / f;
}
ccl_device_inline int4 operator<(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return int4(_mm_castps_si128(_mm_cmplt_ps(a.m128, b.m128)));
#else
return make_int4(a.x < b.x, a.y < b.y, a.z < b.z, a.w < b.w);
#endif
}
ccl_device_inline int4 operator>=(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return int4(_mm_castps_si128(_mm_cmpge_ps(a.m128, b.m128)));
#else
return make_int4(a.x >= b.x, a.y >= b.y, a.z >= b.z, a.w >= b.w);
#endif
}
ccl_device_inline int4 operator<=(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return int4(_mm_castps_si128(_mm_cmple_ps(a.m128, b.m128)));
#else
return make_int4(a.x <= b.x, a.y <= b.y, a.z <= b.z, a.w <= b.w);
#endif
}
ccl_device_inline bool operator==(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return (_mm_movemask_ps(_mm_cmpeq_ps(a.m128, b.m128)) & 15) == 15;
#else
return (a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w);
#endif
}
ccl_device_inline float distance(const float4 &a, const float4 &b)
{
return len(a - b);
}
ccl_device_inline float dot(const float4 &a, const float4 &b)
{
#if defined(__KERNEL_SSE41__) && defined(__KERNEL_SSE__)
# if defined(__KERNEL_NEON__)
__m128 t = vmulq_f32(a, b);
return vaddvq_f32(t);
# else
return _mm_cvtss_f32(_mm_dp_ps(a, b, 0xFF));
# endif
#else
return (a.x * b.x + a.y * b.y) + (a.z * b.z + a.w * b.w);
#endif
}
ccl_device_inline float len_squared(const float4 &a)
{
return dot(a, a);
}
ccl_device_inline float4 rcp(const float4 &a)
{
#ifdef __KERNEL_SSE__
/* Don't use _mm_rcp_ps due to poor precision. */
return float4(_mm_div_ps(_mm_set_ps1(1.0f), a.m128));
#else
return make_float4(1.0f / a.x, 1.0f / a.y, 1.0f / a.z, 1.0f / a.w);
#endif
}
ccl_device_inline float4 sqrt(const float4 &a)
{
#ifdef __KERNEL_SSE__
return float4(_mm_sqrt_ps(a.m128));
#else
return make_float4(sqrtf(a.x), sqrtf(a.y), sqrtf(a.z), sqrtf(a.w));
#endif
}
ccl_device_inline float4 sqr(const float4 &a)
{
return a * a;
}
ccl_device_inline float4 cross(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return (shuffle<1, 2, 0, 0>(a) * shuffle<2, 0, 1, 0>(b)) -
(shuffle<2, 0, 1, 0>(a) * shuffle<1, 2, 0, 0>(b));
#else
return make_float4(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x, 0.0f);
#endif
}
ccl_device_inline bool is_zero(const float4 &a)
{
#ifdef __KERNEL_SSE__
return a == make_float4(0.0f);
#else
return (a.x == 0.0f && a.y == 0.0f && a.z == 0.0f && a.w == 0.0f);
#endif
}
ccl_device_inline float4 reduce_add(const float4 &a)
{
#if defined(__KERNEL_SSE__)
# if defined(__KERNEL_NEON__)
return float4(vdupq_n_f32(vaddvq_f32(a)));
# elif defined(__KERNEL_SSE3__)
float4 h(_mm_hadd_ps(a.m128, a.m128));
return float4(_mm_hadd_ps(h.m128, h.m128));
# else
float4 h(shuffle<1, 0, 3, 2>(a) + a);
return shuffle<2, 3, 0, 1>(h) + h;
# endif
#else
float sum = (a.x + a.y) + (a.z + a.w);
return make_float4(sum, sum, sum, sum);
#endif
}
ccl_device_inline float average(const float4 &a)
{
return reduce_add(a).x * 0.25f;
}
ccl_device_inline float len(const float4 &a)
{
return sqrtf(dot(a, a));
}
ccl_device_inline float4 normalize(const float4 &a)
{
return a / len(a);
}
ccl_device_inline float4 safe_normalize(const float4 &a)
{
float t = len(a);
return (t != 0.0f) ? a / t : a;
}
ccl_device_inline float4 min(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return float4(_mm_min_ps(a.m128, b.m128));
#else
return make_float4(min(a.x, b.x), min(a.y, b.y), min(a.z, b.z), min(a.w, b.w));
#endif
}
ccl_device_inline float4 max(const float4 &a, const float4 &b)
{
#ifdef __KERNEL_SSE__
return float4(_mm_max_ps(a.m128, b.m128));
#else
return make_float4(max(a.x, b.x), max(a.y, b.y), max(a.z, b.z), max(a.w, b.w));
#endif
}
ccl_device_inline float4 clamp(const float4 &a, const float4 &mn, const float4 &mx)
{
return min(max(a, mn), mx);
}
ccl_device_inline float4 fabs(const float4 &a)
{
#if defined(__KERNEL_SSE__)
# if defined(__KERNEL_NEON__)
return float4(vabsq_f32(a));
# else
return float4(_mm_and_ps(a.m128, _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff))));
# endif
#else
return make_float4(fabsf(a.x), fabsf(a.y), fabsf(a.z), fabsf(a.w));
#endif
}
ccl_device_inline float4 floor(const float4 &a)
{
#ifdef __KERNEL_SSE__
return float4(_mm_floor_ps(a));
#else
return make_float4(floorf(a.x), floorf(a.y), floorf(a.z), floorf(a.w));
#endif
}
ccl_device_inline float4 mix(const float4 &a, const float4 &b, float t)
{
return a + t * (b - a);
}
#ifdef __KERNEL_SSE__
template<size_t index_0, size_t index_1, size_t index_2, size_t index_3>
__forceinline const float4 shuffle(const float4 &b)
{
# if defined(__KERNEL_NEON__)
return float4(shuffle_neon<__m128, index_0, index_1, index_2, index_3>(b.m128));
# else
return float4(_mm_castsi128_ps(
_mm_shuffle_epi32(_mm_castps_si128(b), _MM_SHUFFLE(index_3, index_2, index_1, index_0))));
# endif
}
template<size_t index_0, size_t index_1, size_t index_2, size_t index_3>
__forceinline const float4 shuffle(const float4 &a, const float4 &b)
{
# if defined(__KERNEL_NEON__)
return float4(shuffle_neon<__m128, index_0, index_1, index_2, index_3>(a.m128, b.m128));
# else
return float4(_mm_shuffle_ps(a.m128, b.m128, _MM_SHUFFLE(index_3, index_2, index_1, index_0)));
# endif
}
template<> __forceinline const float4 shuffle<0, 1, 0, 1>(const float4 &b)
{
return float4(_mm_castpd_ps(_mm_movedup_pd(_mm_castps_pd(b))));
}
template<> __forceinline const float4 shuffle<0, 1, 0, 1>(const float4 &a, const float4 &b)
{
return float4(_mm_movelh_ps(a.m128, b.m128));
}
template<> __forceinline const float4 shuffle<2, 3, 2, 3>(const float4 &a, const float4 &b)
{
return float4(_mm_movehl_ps(b.m128, a.m128));
}
# ifdef __KERNEL_SSE3__
template<> __forceinline const float4 shuffle<0, 0, 2, 2>(const float4 &b)
{
return float4(_mm_moveldup_ps(b));
}
template<> __forceinline const float4 shuffle<1, 1, 3, 3>(const float4 &b)
{
return float4(_mm_movehdup_ps(b));
}
# endif /* __KERNEL_SSE3__ */
#endif /* __KERNEL_SSE__ */
#ifndef __KERNEL_GPU__
ccl_device_inline float4 select(const int4 &mask, const float4 &a, const float4 &b)
{
# ifdef __KERNEL_SSE__
return float4(_mm_blendv_ps(b.m128, a.m128, _mm_castsi128_ps(mask.m128)));
# else
return make_float4(
(mask.x) ? a.x : b.x, (mask.y) ? a.y : b.y, (mask.z) ? a.z : b.z, (mask.w) ? a.w : b.w);
# endif
}
ccl_device_inline float4 mask(const int4 &mask, const float4 &a)
{
/* Replace elements of x with zero where mask isn't set. */
return select(mask, a, make_float4(0.0f));
}
ccl_device_inline float4 reduce_min(const float4 &a)
{
# if defined(__KERNEL_SSE__)
# if defined(__KERNEL_NEON__)
return float4(vdupq_n_f32(vminvq_f32(a)));
# else
float4 h = min(shuffle<1, 0, 3, 2>(a), a);
return min(shuffle<2, 3, 0, 1>(h), h);
# endif
# else
return make_float4(min(min(a.x, a.y), min(a.z, a.w)));
# endif
}
ccl_device_inline float4 reduce_max(const float4 &a)
{
# if defined(__KERNEL_SSE__)
# if defined(__KERNEL_NEON__)
return float4(vdupq_n_f32(vmaxvq_f32(a)));
# else
float4 h = max(shuffle<1, 0, 3, 2>(a), a);
return max(shuffle<2, 3, 0, 1>(h), h);
# endif
# else
return make_float4(max(max(a.x, a.y), max(a.z, a.w)));
# endif
}
ccl_device_inline float4 load_float4(ccl_private const float *v)
{
# ifdef __KERNEL_SSE__
return float4(_mm_loadu_ps(v));
# else
return make_float4(v[0], v[1], v[2], v[3]);
# endif
}
#endif /* !__KERNEL_GPU__ */
ccl_device_inline float4 safe_divide_float4_float(const float4 a, const float b)
{
return (b != 0.0f) ? a / b : zero_float4();
}
ccl_device_inline bool isfinite4_safe(float4 v)
{
return isfinite_safe(v.x) && isfinite_safe(v.y) && isfinite_safe(v.z) && isfinite_safe(v.w);
}
ccl_device_inline float4 ensure_finite4(float4 v)
{
if (!isfinite_safe(v.x))
v.x = 0.0f;
if (!isfinite_safe(v.y))
v.y = 0.0f;
if (!isfinite_safe(v.z))
v.z = 0.0f;
if (!isfinite_safe(v.w))
v.w = 0.0f;
return v;
}
CCL_NAMESPACE_END
#endif /* __UTIL_MATH_FLOAT4_H__ */
View Git Blame Copy Permalink