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 <initializer_list>
 
#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)
    {}
 
    void
    setValues(std::initializer_list<DataT> values)
    {
        unsigned int len = values.size();
        allocateData(len);
        setDataLength(len);
        unsigned int i = 0;
        for (auto v : values)
        {
            setDataValue(i++, (DataT)v);
        }
    }
 
    SampleT(std::initializer_list<DataT> values) :
        Sample(sample_type_traits<DataT>::sample_type_enum),
        _data(0),_allocLen(0)
    {
        setValues(values);
    }
 
    ~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&);
};
 
 
class SampleChar : public SampleT<char>
{
public:
    SampleChar(const char* buffer)
    {
        unsigned int len = strlen(buffer) + 1;
        allocateData(len);
        setDataLength(len);
        strcpy(getDataPtr(), buffer);
    }
};
 
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;
}
 
SampleT<char>* getSample(const char* data);
 
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