CollectiveCommBase.h

#pragma once
 
#include <vector>
#include <stddef.h>
#include "CollectiveCommBaseInterface.h"
class CollectiveCommBase : public virtual CollectiveCommBaseInterface{
 
protected:
    union valType {
        int v_int;
        unsigned long v_unsLong;
        float v_float;
        double v_double;
        long double v_longDouble;
    };
 
public:
    virtual ~~CollectiveCommBase() {
    }
 
    void init(int numValues) {
        _values.reserve(numValues);
        _getter = _values.begin();
    }
 
    virtual void appendInt(int intValue) override {
        valType toPush;
        toPush.v_int = intValue;
        _values.push_back(toPush);
    }
 
    virtual void appendUnsLong(unsigned long unsLongValue) override {
        valType toPush;
        toPush.v_unsLong = unsLongValue;
        _values.push_back(toPush);
    }
 
    virtual void appendFloat(float floatValue) override {
        valType toPush;
        toPush.v_float = floatValue;
        _values.push_back(toPush);
    }
 
    virtual void appendDouble(double doubleValue) override {
        valType toPush;
        toPush.v_double = doubleValue;
        _values.push_back(toPush);
    }
 
    virtual void appendLongDouble(long double longDoubleValue) override {
        valType toPush;
        toPush.v_longDouble = longDoubleValue;
        _values.push_back(toPush);
    }
 
    virtual void broadcast(int /*root*/ = 0) override {
    }
 
    virtual void allreduceSum() override {
    }
 
    // doku in base class
    virtual void allreduceCustom(ReduceType type) override{
    }
 
    virtual void scanSum() override {
    }
 
    virtual int getInt() override {
        return (_getter++)->v_int;
    }
 
    virtual unsigned long getUnsLong() override {
        return (_getter++)->v_unsLong;
    }
 
    virtual float getFloat() override {
        return (_getter++)->v_float;
    }
 
    virtual double getDouble() override {
        return (_getter++)->v_double;
    }
 
    virtual long double getLongDouble() override {
        return (_getter++)->v_longDouble;
    }
 
    virtual void finalize() override {
        _values.clear();
    }
 
    virtual size_t getTotalSize() override {
        return _values.capacity() * sizeof(valType);
    }
 
protected:
    std::vector<valType> _values;
 
    std::vector<valType>::const_iterator _getter;
 
};