CUDA Lab Course Reference Manual 2011

/Users/sck/cuda/Praktikum_2011/include/lac/cublas_Array.h

Go to the documentation of this file.

#ifndef CUBLAS_ARRAY_H
#define CUBLAS_ARRAY_H

// #include <lac/FullMatrixAccessor.h>

#include <lac/cublas_wrapper.hh>

#include <lac/blas_wrapper.hh>

namespace bw_types {

// @sect3{Klasse: Array}
//
// Diese Klase kapselt CUBLAS' Speicherverwaltung und dient als
// Grundlage fuer komplexere Datentypen der linearen Algebra.
template <typename T, typename BW>
        class Array : protected BW::template Data<T> {

typedef typename BW::template Data<T> Base;

public:

    Array();

    Array(int n);

    // ~Array();

    void reinit(int n);

    T * val();

    const T * val() const;

    int n_elements() const { return __n; }

    Array<T, BW> & operator = (const Array<T, BW>& other);

protected:
    int __n;


        // Um unliebsame Ueberraschungen zu vermeiden, wird der copy-Konstruktor privat gemacht.
        // Dadurch wirft der Compiler einen Fehler aus, wenn er versucht, irgendwo einen
        // copy-Konstruktor automatisch zu erzeugen.
    Array(const Array<T, BW>& other) {}

};

} // namespace END


// @sect3{bw_types::Array Methoden}

// @sect4{Konstruktoren}
//
template <typename T, typename BW>
bw_types::Array<T, BW>::Array()
    :
    Base(),
    __n(0)
{}

// @param n : Groesse des Arrays.
template <typename T, typename BW>
bw_types::Array<T, BW>::Array(int n)
    :
    Base(),
    __n(0)
{
    this->reinit(n);
}


// @sect4{Funktion: reinit}
//
// Aendert die Groesse des Arrays auf die angegebene Anzahl @p n von Elementen.
// Falls erforderlich wird dazu der alte Speicher freigegeben und neuer belegt.
// @param n : Neue Groesse des Arrays.
template <typename T, typename BW>
inline void bw_types::Array<T, BW>::reinit(int n)
{
    if ( this->__n == n) return;

    AssertThrow(n > 0,
                ::ExcMessage("Reinitialization requires a positive number of elements.") );

    if (this->__n != n) { this->Base::resize(n);




    // Falls beim allokieren was schiefgeht, wird das schon
    // intern in Alloc behandelt. Also kann hier sorglos weitergemacht werden.

    __n = n;
}
}



// @sect4{Funktion: val}
//
// Schreibzugriff auf das Wertearray.
template <typename T, typename BW>
T * bw_types::Array<T, BW>::val()
{
#ifdef QT_NO_DEBUG
        AssertThrow(this->data() != 0,
                    ::ExcMessage("Object not initialized"));
#else
        Assert(this->data() != 0,
               ::ExcMessage("Object not initialized") );
#endif

    return this->data();
}

// Nur-Lesezugriff auf das Wertearray.
template <typename T, typename BW>
const T * bw_types::Array<T, BW>::val() const
{
#ifdef QT_NO_DEBUG
        AssertThrow(this->data() != 0,
                    ::ExcMessage("Object not initialized"));
#else
        Assert(this->data() != 0,
               ::ExcMessage("Object not initialized") );
#endif

    return this->data();
}


// @sect4{Operator: =}
//
// Kopiere ein array in ein anderes. Dabei werden keine Information ueber die
// Interpretation der Daten uebertragen,
// z.B. ob es eine Matrix oder ein Vektor ist.
// Da Quelle und Ziel auf der GPU liegen, sollte diese Operation vergleichsweise
// billig sein.
// @param other : zu kopierendes Array.
template <typename T, typename BW>
bw_types::Array<T, BW> &
bw_types::Array<T, BW>::operator = (const Array<T, BW>& other)
{

    Assert(other.__is_allocd,
          ::ExcMessage("You cannot copy from an uninitialized object!") );

    this->reinit(other.__n);

    // Elementweise Kopie des arrays.
    int inc_src  = 1;
    int inc_this = 1;

    BW::copy(this->__n, other.val(), inc_src, this->dev_ptr
             , inc_this);

    return *this;
}


#endif // CUBLAS_ARRAY_H

---