Question

I am using the Eigen 3.1.1 library and MS Visual C++ 2010. I would like to implement a simple concurrent buffer that controls access to an element of a generic type T.

As I am working with Eigen types the new operator of the concurrent buffer must be overloaded if the buffer is instantiated with a fixed-size vectorizable Eigen type. See also:
Structures Having Eigen Members.

#include <boost/thread.hpp>
#include <Eigen/Geometry>   // required for the eigen macro

// abstract base class for all buffers
template <class T>
class ConcurrentBuffer
{
public:
    // virtual destructor to allow subclassing
    virtual ~ConcurrentBuffer(){}

    //virtual void get(T& elem) = 0;
    //virtual void put(const T& elem) = 0;
};


template<class T>
class SingleElementStorage : public ConcurrentBuffer<T>
{
public:
    // For fixed-size vect. Eigen types:
    typedef T Elem_type;
    enum { NeedsToAlign = (sizeof(Elem_type)%16)==0 };
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)


    SingleElementStorage() {}
    ~SingleElementStorage() {}

    //void get(T& elem);
    //void put(const T& elem);

private:
    T elem_;
    boost::shared_mutex mutex_;
};

This code compiles fine with MSVC++. My question is if this is the best way to realize such a buffer. Actually this code also compiles if only EIGEN_MAKE_ALIGNED_OPERATOR_NEW is used and the typedef and the enum are removed.

So why should I not simply put EIGEN_MAKE_ALIGNED_OPERATOR_NEW in every struct/class of my project?

Another related question: Is it somehow possible to put the macro into the abstract base class “ConcurrentBuffer” so that all derived classes do not need to add eigen specific implementations?

Answer 1

I glanced at the macro definition and it seems, that you don´t need to do the NeedsToAlign part on your side. Eigen is doing it already for you. It is also stated in the Eigen documentation to just use the macro alone (so why would this not be a good solution?).

Regarding your second question: The operator new will be declared without virtual, so I suppose(!) it will not work.