这样的继承对性能的影响是什么?

我正在使用DirectXMath(或XNAMath)库(在Windows SDK的DirectXMath.h头文件中定义)，因为它看起来非常高效，并提供了物理和渲染所需的一切。然而，我发现它是相当冗长的(使用XMStoreFloatX和XMLoadFloatX到处是累人的)。

我试图使其更容易操作，并提出了隐藏赋值操作符/转换操作符中的store/load的想法。由于这两个都需要成为成员函数，所以我提出了以下代码作为示例:

struct Vector2F : public DirectX::XMFLOAT2 {
    inline Vector2F() : DirectX::XMFLOAT2() {};
    inline Vector2F(float x, float y) : DirectX::XMFLOAT2(x, y) {};
    inline Vector2F(float const * pArray) : DirectX::XMFLOAT2(pArray) {};
    inline Vector2F(DirectX::XMVECTOR vector) {
        DirectX::XMStoreFloat2(this, vector);
    }
    inline Vector2F& __vectorcall operator= (DirectX::XMVECTOR vector) {
        DirectX::XMStoreFloat2(this, vector);
        return *this;
    }
    inline __vectorcall operator DirectX::XMVECTOR() {
        return DirectX::XMLoadFloat2(this);
    }
};

可以看到，它复制了XMFLOAT2的公共接口，并为XMVECTOR添加了一个构造函数、一个赋值操作符和一个转换，这是DirectXMath用于计算的SIMD类型。我打算对DirectXMath提供的每个存储结构都这样做。

对于数学库来说，

性能是一个非常重要的因素，因此我的问题是:这种继承的性能含义是什么?与库的正常使用相比，是否会生成任何额外的代码(当然假设完全优化)?

直观地说，生成的代码应该与我使用verbose变体而不使用这些方便操作符时完全相同，因为我本质上只是重命名结构体和函数。但也许有些方面我不知道?

注:我有点担心赋值操作符的返回类型，因为它增加了额外的代码。省略引用返回来优化它是不是一个好主意?

如果你发现DirectXMath对你的口味来说有点太啰嗦了，看看directxtool Kit中的SimpleMath。特别是Vector2类:

struct Vector2 : public XMFLOAT2
{
    Vector2() : XMFLOAT2(0.f, 0.f) {}
    explicit Vector2(float x) : XMFLOAT2( x, x ) {}
    Vector2(float _x, float _y) : XMFLOAT2(_x, _y) {}
    explicit Vector2(_In_reads_(2) const float *pArray) : XMFLOAT2(pArray) {}
    Vector2(FXMVECTOR V) { XMStoreFloat2( this, V ); }
    Vector2(const XMFLOAT2& V) { this->x = V.x; this->y = V.y; }
    explicit Vector2(const XMVECTORF32& F) { this->x = F.f[0]; this->y = F.f[1]; }
    operator XMVECTOR() const { return XMLoadFloat2( this ); }
    // Comparison operators
    bool operator == ( const Vector2& V ) const;
    bool operator != ( const Vector2& V ) const;
    // Assignment operators
    Vector2& operator= (const Vector2& V) { x = V.x; y = V.y; return *this; }
    Vector2& operator= (const XMFLOAT2& V) { x = V.x; y = V.y; return *this; }
    Vector2& operator= (const XMVECTORF32& F) { x = F.f[0]; y = F.f[1]; return *this; }
    Vector2& operator+= (const Vector2& V);
    Vector2& operator-= (const Vector2& V);
    Vector2& operator*= (const Vector2& V);
    Vector2& operator*= (float S);
    Vector2& operator/= (float S);
    // Unary operators
    Vector2 operator+ () const { return *this; }
    Vector2 operator- () const { return Vector2(-x, -y); }
    // Vector operations
    bool InBounds( const Vector2& Bounds ) const;
    float Length() const;
    float LengthSquared() const;
    float Dot( const Vector2& V ) const;
    void Cross( const Vector2& V, Vector2& result ) const;
    Vector2 Cross( const Vector2& V ) const;
    void Normalize();
    void Normalize( Vector2& result ) const;
    void Clamp( const Vector2& vmin, const Vector2& vmax );
    void Clamp( const Vector2& vmin, const Vector2& vmax, Vector2& result ) const;
    // Static functions
    static float Distance( const Vector2& v1, const Vector2& v2 );
    static float DistanceSquared( const Vector2& v1, const Vector2& v2 );
    static void Min( const Vector2& v1, const Vector2& v2, Vector2& result );
    static Vector2 Min( const Vector2& v1, const Vector2& v2 );
    static void Max( const Vector2& v1, const Vector2& v2, Vector2& result );
    static Vector2 Max( const Vector2& v1, const Vector2& v2 );
    static void Lerp( const Vector2& v1, const Vector2& v2, float t, Vector2& result );
    static Vector2 Lerp( const Vector2& v1, const Vector2& v2, float t );
    static void SmoothStep( const Vector2& v1, const Vector2& v2, float t, Vector2& result );
    static Vector2 SmoothStep( const Vector2& v1, const Vector2& v2, float t );
    static void Barycentric( const Vector2& v1, const Vector2& v2, const Vector2& v3, float f, float g, Vector2& result );
    static Vector2 Barycentric( const Vector2& v1, const Vector2& v2, const Vector2& v3, float f, float g );
    static void CatmullRom( const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4, float t, Vector2& result );
    static Vector2 CatmullRom( const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4, float t );
    static void Hermite( const Vector2& v1, const Vector2& t1, const Vector2& v2, const Vector2& t2, float t, Vector2& result );
    static Vector2 Hermite( const Vector2& v1, const Vector2& t1, const Vector2& v2, const Vector2& t2, float t );
    static void Reflect( const Vector2& ivec, const Vector2& nvec, Vector2& result );
    static Vector2 Reflect( const Vector2& ivec, const Vector2& nvec );
    static void Refract( const Vector2& ivec, const Vector2& nvec, float refractionIndex, Vector2& result );
    static Vector2 Refract( const Vector2& ivec, const Vector2& nvec, float refractionIndex );
    static void Transform( const Vector2& v, const Quaternion& quat, Vector2& result );
    static Vector2 Transform( const Vector2& v, const Quaternion& quat );
    static void Transform( const Vector2& v, const Matrix& m, Vector2& result );
    static Vector2 Transform( const Vector2& v, const Matrix& m );
    static void Transform( _In_reads_(count) const Vector2* varray, size_t count, const Matrix& m, _Out_writes_(count) Vector2* resultArray );
    static void Transform( const Vector2& v, const Matrix& m, Vector4& result );
    static void Transform( _In_reads_(count) const Vector2* varray, size_t count, const Matrix& m, _Out_writes_(count) Vector4* resultArray );
    static void TransformNormal( const Vector2& v, const Matrix& m, Vector2& result );
    static Vector2 TransformNormal( const Vector2& v, const Matrix& m );
    static void TransformNormal( _In_reads_(count) const Vector2* varray, size_t count, const Matrix& m, _Out_writes_(count) Vector2* resultArray );
    // Constants
    static const Vector2 Zero;
    static const Vector2 One;
    static const Vector2 UnitX;
    static const Vector2 UnitY;
};
// Binary operators
Vector2 operator+ (const Vector2& V1, const Vector2& V2);
Vector2 operator- (const Vector2& V1, const Vector2& V2);
Vector2 operator* (const Vector2& V1, const Vector2& V2);
Vector2 operator* (const Vector2& V, float S);
Vector2 operator/ (const Vector2& V1, const Vector2& V2);
Vector2 operator* (float S, const Vector2& V);

DirectXMath如此冗长的主要原因首先是为了让程序员非常清楚什么时候"溢出到内存"，因为这往往会对SIMD代码的性能产生负面影响。当我从XNAMath转移到DirectXMath时，我考虑过添加一些类似于我在"SimpleMath"中使用的隐式转换的东西，但我想确保任何这样的"c++魔法"都是可选的，并且对于性能敏感的开发人员来说永远不会感到惊讶。SimpleMath的作用也有点像辅助轮，它可以更容易地移植不支持对齐的现有代码，并随着时间的推移将其转变为对simd更友好的代码。

SimpleMath(和您的包装器)的真正性能问题是每个函数实现都必须执行显式的Load &存储在其他情况下相当少量的SIMD。理想情况下，在优化代码中，它们会被合并，但在调试代码中，它们总是存在。为了从SIMD中获得任何真正的性能优势，您希望在每个Load &amp之间长时间运行寄存器内SIMD操作;商店对。

另一个含义是传递像Vector2或Vector2F这样的包装器的参数永远不会特别有效。XMVECTOR是__m128的类型定义而不是结构体，FXMVECTOR、GXMVECTOR、HXMVECTOR和CXMVECTOR的存在的全部原因是试图优化所有可能的调用约定场景，并在最好的情况下获得注册内传递行为(如果事情没有内联)。看到MSDN。对于Vector2，你所能做的最好的事情就是始终如一地传递const&，以减少临时副本和堆栈副本。

相关内容

最新更新

热门标签：