c++ - 这样的继承对性能有何影响？

我正在使用DirectXMath(或XNAMath)库(在Windows SDK的DirectXMath.h header 中定义)，因为它看起来确实很有效，并且提供了物理和渲染所需的一切。但是我发现它很冗长(到处都使用XMStoreFloatX和XMLoadFloatX很累)。

我试图使它更易于操作，并提出了将存储/装载隐藏在赋值运算符/转换运算符中的想法。由于这两个都必须成为成员函数，因此我以以下代码为例:

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的公共(public)接口(interface)，并添加了构造函数，赋值运算符和XMVECTOR的转换，这是DirectXMath用于计算的SIMD类型。我打算针对DirectXMath提供的每个存储结构执行此操作。

性能对于数学文库来说是一个非常重要的因素，因此我的问题是:这样的继承对性能有何影响？与库的正常使用情况相比，是否还会生成任何其他代码(当然，假设完全优化)？

直观地说，生成的代码应该与没有这些便捷运算符的情况下使用冗长的变体完全相同，因为我实质上只是重命名结构和函数。但是也许有些我不知道的方面？

附言我有点担心赋值运算符的返回类型，因为它添加了其他代码。忽略返回的引用来优化它是一个好主意吗？

最佳答案

如果您发现DirectXMath不太适合您的口味，请查看SimpleMath中的DirectX Tool Kit。特别是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(和您的包装器)真正的性能问题在于，每个函数实现都必须围绕显着的SIMD进行显式的加载和存储。理想情况下，在优化的代码中，所有代码都将合并，但是在调试代码中，它们始终存在。为了获得SIMD的任何实际性能优势，您希望在每个“加载与存储”对之间进行长时间的寄存器内SIMD操作。

另一个含义是，传递像Vector2或Vector2F这样的包装器的参数永远不会特别有效。 XMVECTOR是__m128而不是结构的typedef的全部原因，以及FXMVECTOR，GXMVECTOR，HXMVECTOR和CXMVECTOR的存在，是为了尝试优化所有可能的调用约定方案，并在最佳情况下获得寄存器内传递行为(如果事情没有内联)。参见MSDN。实际上，您可以使用Vector2最好的办法就是始终将const&传递给它，以最大程度地减少临时文件和堆栈副本。

关于c++ - 这样的继承对性能有何影响？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/39545855/