Sample.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2004, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/
/*

    Some over-engineered sample classes.

*/

#ifndef NIDAS_CORE_SAMPLET_H
#define NIDAS_CORE_SAMPLET_H

#include "SampleLengthException.h"
#include <nidas/util/ThreadSupport.h>
#include <nidas/util/MutexCount.h>
#include <nidas/util/time_constants.h>
#include <nidas/linux/types.h>

#include <climits>
#include <iostream>
#include <cstring>

#include <cmath>

#include "sample_type_traits.h"

namespace nidas { namespace core {

extern const float floatNAN;

extern const double doubleNAN;

typedef long long dsm_time_t;

typedef unsigned int dsm_sample_id_t;

#define GET_SAMPLE_TYPE(tid) ((tid) >> 26)
#define SET_SAMPLE_TYPE(tid,val) (((tid) & 0x03ffffff) | ((unsigned int)(val) << 26))

#define GET_FULL_ID(tid) ((tid) & 0x03ffffff)
#define SET_FULL_ID(tid,val) (((tid) & 0xfc000000) | ((val) & 0x03ffffff))

#define GET_DSM_ID(tid) (((tid) & 0x03ff0000) >> 16)
#define SET_DSM_ID(tid,val) (((tid) & 0xfc00ffff) | (((unsigned int)(val) & 0x3ff) << 16))

#define GET_SPS_ID(tid) ((tid) & 0xffff)
#define GET_SHORT_ID(tid) ((tid) & 0xffff)

#define SET_SPS_ID(tid,val) (((tid) & 0xffff0000) | ((val) & 0xffff)) 
#define SET_SHORT_ID(tid,val) (((tid) & 0xffff0000) | ((val) & 0xffff)) 

#define MUTEX_PROTECT_REF_COUNTS

// #define USE_ATOMIC_REF_COUNT

class SampleHeader {
public:

    SampleHeader(sampleType t=CHAR_ST) :
    _tt(0),_length(0),_tid((unsigned int)t << 26) {}

    dsm_time_t getTimeTag() const { return _tt; }

    void setTimeTag(dsm_time_t val) { _tt = val; }

    unsigned int getDataByteLength() const { return _length; }

    void setDataByteLength(unsigned int val) { _length = val; }

    dsm_sample_id_t getId() const { return GET_FULL_ID(_tid); }
    void setId(dsm_sample_id_t val) { _tid = SET_FULL_ID(_tid,val); }

    dsm_sample_id_t getRawId() const { return _tid; }
    void setRawId(dsm_sample_id_t val) { _tid = val; }

    unsigned int getDSMId() const { return GET_DSM_ID(_tid); }
    void setDSMId(unsigned int val) { _tid = SET_DSM_ID(_tid,val); }

    unsigned int getSpSId() const { return GET_SPS_ID(_tid); }
    void setSpSId(unsigned int val) { _tid = SET_SPS_ID(_tid,val); }

    unsigned char getType() const { return GET_SAMPLE_TYPE(_tid); }

    static unsigned int getSizeOf()
    {
        return sizeof(dsm_time_t) + sizeof(dsm_sample_length_t) +
        sizeof(dsm_sample_id_t); }

    static unsigned int getMaxDataLength() { return maxValue(dsm_sample_length_t()); }

protected:

    dsm_time_t _tt;

    dsm_sample_length_t _length;

    dsm_sample_id_t _tid;
};

class Sample {
public:

    Sample(sampleType t = CHAR_ST) :
        _header(t),_refCount(1),_refLock()
    {
        ++_nsamps;
    }

    virtual ~Sample() { --_nsamps; }

    void setTimeTag(dsm_time_t val) { _header.setTimeTag(val); }

    dsm_time_t getTimeTag() const { return _header.getTimeTag(); }

    void setId(dsm_sample_id_t val) { _header.setId(val); }

    dsm_sample_id_t getId() const { return _header.getId(); }

    void setRawId(dsm_sample_id_t val) { _header.setRawId(val); }

    dsm_sample_id_t getRawId() const { return _header.getRawId(); }

    void setSpSId(unsigned int val) { _header.setSpSId(val); }

    unsigned int getSpSId() const { return _header.getSpSId(); }

    void setDSMId(unsigned int val) { _header.setDSMId(val); }

    unsigned int getDSMId() const { return _header.getDSMId(); }

    unsigned int getDataByteLength() const { return _header.getDataByteLength(); }

    virtual void setDataLength(unsigned int val) = 0;
 
    virtual unsigned int getDataLength() const = 0;

    virtual sampleType getType() const = 0;

    unsigned int getHeaderLength() const { return SampleHeader::getSizeOf(); }

    const void* getHeaderPtr() const { return &_header; }

    virtual void* getVoidDataPtr() = 0;

    virtual const void* getConstVoidDataPtr() const = 0;

    virtual double getDataValue(unsigned int i) const = 0;

    virtual void setDataValue(unsigned int i,double val) = 0;

    virtual void setDataValue(unsigned int i,float val) = 0;

    virtual unsigned int getAllocLength() const = 0;

    virtual unsigned int getAllocByteLength() const = 0;

    virtual void allocateData(unsigned int val) = 0;

    virtual void reallocateData(unsigned int val) = 0;

    void holdReference() const {
#ifdef USE_ATOMIC_REF_COUNT
        __sync_add_and_fetch(&_refCount,1);
#else
#ifdef MUTEX_PROTECT_REF_COUNTS
    _refLock.lock();
#endif
        _refCount++;
#ifdef MUTEX_PROTECT_REF_COUNTS
    _refLock.unlock();
#endif
#endif
    }

    virtual void freeReference() const = 0;

protected:

    SampleHeader _header;

    mutable int _refCount;

#ifdef MUTEX_PROTECT_REF_COUNTS
    mutable nidas::util::Mutex _refLock;
#endif

#ifndef PROTECT_NSAMPLES
    static int _nsamps;
#ifdef ENABLE_VALGRIND
public:
    class InitValgrind;
protected:
    friend class InitValgrind;
#endif
#else
    static nidas::util::MutexCount<int> _nsamps;
#endif
};

template <class DataT>
class SampleT : public Sample {
public:

    // Technically speaking, I think it is unsafe to call the subclass
    // method getType() when calling the base class constructor, because
    // the subclass has not been initialized yet.  It works here probably
    // because GCC binds directly to the subclass getSampleType() method,
    // probably because of some obscure C++ scoping rules.  If it didn't,
    // then the call would fail since the VTable has not been fully
    // initialized yet, or if it is it is initialized with the base class
    // bindings, for which getType() is pure virtual.

    // Therefore the getType() call has been replaced with getSampleType().
    // That seems safer as long as that call only depends upon on the
    // operand type and not on its value, since its value is an
    // uninitialized pointer member.
    //
    // An alternative to calling a function at all is to use type traits
    // templates, such as defined in sample_traits.h:
    //
    // Sample(sample_type_traits<DataT>::sample_type_enum)

    SampleT() :
        Sample(sample_type_traits<DataT>::sample_type_enum),
        _data(0),_allocLen(0)
    {}

    ~SampleT() { delete [] _data; }

    sampleType getType() const { return getSampleType(_data); }

    unsigned int getDataLength() const
    {
        return getDataByteLength() / sizeof(DataT);
    }

    void setDataLength(unsigned int val)
    {
    if (val > getAllocLength())
        throw SampleLengthException(
        "SampleT::setDataLength:",val,getAllocLength());
    _header.setDataByteLength(val * sizeof(DataT));
    }

    static unsigned int getMaxDataLength()
    {
    return SampleHeader::getMaxDataLength() / sizeof(DataT);
    }

    void* getVoidDataPtr() { return (void*) _data; }
    const void* getConstVoidDataPtr() const { return (const void*) _data; }

    DataT* getDataPtr() { return _data; }

    const DataT* getConstDataPtr() const { return _data; }

    double getDataValue(unsigned int i) const
    {
        return (double)_data[i];
    }

    void setDataValue(unsigned int i, double val)
    {
        _data[i] = (DataT)val;
    }

    void setDataValue(unsigned int i, float val)
    {
        _data[i] = (DataT)val;
    }

    unsigned int getAllocLength() const { return _allocLen / sizeof(DataT); }

    unsigned int getAllocByteLength() const { return _allocLen; }

    void allocateData(unsigned int val) {
    if (val  > getMaxDataLength())
        throw SampleLengthException(
        "SampleT::allocateData:",val,getMaxDataLength());
    if (_allocLen < val * sizeof(DataT)) {
      delete [] _data;
      _data = new DataT[val];
      _allocLen = val * sizeof(DataT);
      setDataLength(0);
    }
    }

    void reallocateData(unsigned int val) {
    if (val  > getMaxDataLength())
        throw SampleLengthException(
        "SampleT::reallocateData:",val,getMaxDataLength());
    if (_allocLen < val * sizeof(DataT)) {
      DataT* newdata = new DataT[val];
      std::memcpy(newdata,_data,_allocLen);
      delete [] _data;
      _data = newdata;
      _allocLen = val * sizeof(DataT);
    }
    }

    static int sizeofDataType() { return sizeof(DataT); }

    void freeReference() const;

protected:

    DataT* _data;

    unsigned int _allocLen;

    SampleT(const SampleT&);

    SampleT& operator=(const SampleT&);
};

Sample* getSample(sampleType type, unsigned int len);

}}  // namespace nidas namespace core

// Here we define methods which use both the SampleT and SamplePool class.
// We wait until now to include SamplePool.h since it needs to have
// the SampleT class defined. We must exit the dsm namespace before
// including SamplePool.h

#include "SamplePool.h"

namespace nidas { namespace core {

template <class T>
SampleT<T>* getSample(unsigned int len)
{
    SampleT<T>* samp =
    SamplePool<SampleT<T> >::getInstance()->getSample(len);
    return samp;
}

template <class DataT>
void SampleT<DataT>::freeReference() const
{
    // if refCount is 0, put it back in the Pool.
#ifdef USE_ATOMIC_REF_COUNT
    // GCC 4.X atomic operations
    int rc = __sync_sub_and_fetch(&_refCount,1);
    assert(rc >= 0);
    if (rc == 0)
    SamplePool<SampleT<DataT> >::getInstance()->putSample(this);
#else
#ifdef MUTEX_PROTECT_REF_COUNTS
    _refLock.lock();
#endif
    bool ref0 = --_refCount == 0;
    assert(_refCount >= 0);
#ifdef MUTEX_PROTECT_REF_COUNTS
    _refLock.unlock();
#endif
    if (ref0)
    SamplePool<SampleT<DataT> >::getInstance()->putSample(this);
#endif
}

}}  // namespace nidas namespace core

#endif