foreman
@@ -0,0 +1,270 @@
|
||||
//
|
||||
// Copyright (c) 2008 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
|
||||
#ifndef OBJECT_HPP_
|
||||
#define OBJECT_HPP_
|
||||
|
||||
#include "top.hpp"
|
||||
#include "os/alloc.hpp"
|
||||
#include "thread/monitor.hpp"
|
||||
#include "utils/util.hpp"
|
||||
|
||||
#define CL_TYPES_DO(F) \
|
||||
/* OpenCL type Runtime type */ \
|
||||
F(cl_context, Context) \
|
||||
F(cl_event, Event) \
|
||||
F(cl_command_queue, CommandQueue) \
|
||||
F(cl_kernel, Kernel) \
|
||||
F(cl_program, Program) \
|
||||
F(cl_device_id, Device) \
|
||||
F(cl_mem, Memory) \
|
||||
F(cl_sampler, Sampler) \
|
||||
F(cl_counter_amd, Counter) \
|
||||
F(cl_perfcounter_amd, PerfCounter) \
|
||||
F(cl_video_session_amd, VideoSession) \
|
||||
F(cl_threadtrace_amd, ThreadTrace)
|
||||
|
||||
// Forward declare ::cl_* types and amd::Class types
|
||||
//
|
||||
|
||||
#define DECLARE_CL_TYPES(CL,AMD) \
|
||||
namespace amd { class AMD; } \
|
||||
typedef struct _##CL { } * CL;
|
||||
|
||||
CL_TYPES_DO(DECLARE_CL_TYPES);
|
||||
|
||||
#undef DECLARE_CL_TYPES
|
||||
|
||||
struct KHRicdVendorDispatchRec;
|
||||
|
||||
namespace amd {
|
||||
|
||||
// Define the cl_*_type tokens for type checking.
|
||||
//
|
||||
|
||||
#define DEFINE_CL_TOKENS(CL,ignored) T##CL,
|
||||
|
||||
enum cl_token
|
||||
{
|
||||
Tinvalid = 0,
|
||||
CL_TYPES_DO(DEFINE_CL_TOKENS)
|
||||
numTokens
|
||||
};
|
||||
|
||||
#undef DEFINE_CL_TOKENS
|
||||
|
||||
const size_t RuntimeObjectAlignment =
|
||||
NextPowerOfTwo<numTokens>::value;
|
||||
|
||||
//! \cond ignore
|
||||
template <typename T>
|
||||
struct as_internal
|
||||
{ typedef void type; };
|
||||
|
||||
template <typename T>
|
||||
struct as_external
|
||||
{ typedef void type; };
|
||||
|
||||
template <typename T>
|
||||
struct class_token
|
||||
{ static const cl_token value = Tinvalid; };
|
||||
|
||||
#define DEFINE_CL_TRAITS(CL,AMD) \
|
||||
\
|
||||
template <> \
|
||||
struct class_token<AMD> \
|
||||
{ static const cl_token value = T##CL; }; \
|
||||
\
|
||||
template <> \
|
||||
struct as_internal<_##CL> \
|
||||
{ typedef AMD type; }; \
|
||||
template <> \
|
||||
struct as_internal<const _##CL> \
|
||||
{ typedef AMD const type; }; \
|
||||
\
|
||||
template <> \
|
||||
struct as_external<AMD> \
|
||||
{ typedef _##CL type; }; \
|
||||
template <> \
|
||||
struct as_external<const AMD> \
|
||||
{ typedef _##CL const type; };
|
||||
|
||||
CL_TYPES_DO(DEFINE_CL_TRAITS);
|
||||
|
||||
#undef DEFINE_CL_TRAITS
|
||||
//! \endcond
|
||||
|
||||
struct ICDDispatchedObject
|
||||
{
|
||||
static struct KHRicdVendorDispatchRec icdVendorDispatch_[];
|
||||
const struct KHRicdVendorDispatchRec* const dispatch_;
|
||||
|
||||
protected:
|
||||
ICDDispatchedObject() : dispatch_(icdVendorDispatch_) { }
|
||||
|
||||
public:
|
||||
static bool isValidHandle(const void* handle)
|
||||
{
|
||||
return handle != NULL;
|
||||
}
|
||||
|
||||
const void* handle() const
|
||||
{
|
||||
return static_cast<const ICDDispatchedObject*>(this);
|
||||
}
|
||||
void* handle()
|
||||
{
|
||||
return static_cast<ICDDispatchedObject*>(this);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static const T* fromHandle(const void *handle)
|
||||
{
|
||||
return static_cast<const T*>(
|
||||
reinterpret_cast<const ICDDispatchedObject*>(handle));
|
||||
}
|
||||
template<typename T>
|
||||
static T* fromHandle(void *handle)
|
||||
{
|
||||
return static_cast<T*>(
|
||||
reinterpret_cast<ICDDispatchedObject*>(handle));
|
||||
}
|
||||
};
|
||||
|
||||
#define OCL_MAX_KEYS 8
|
||||
|
||||
/*! The object metadata container.
|
||||
*/
|
||||
class ObjectMetadata
|
||||
{
|
||||
|
||||
public:
|
||||
typedef size_t Key;
|
||||
typedef void* Value;
|
||||
|
||||
private:
|
||||
typedef void (CL_CALLBACK * Destructor)(Value);
|
||||
|
||||
static Atomic<Key> nextKey_;
|
||||
static Destructor destructors_[OCL_MAX_KEYS];
|
||||
|
||||
Atomic<Value*> values_;
|
||||
|
||||
public:
|
||||
static bool check(Key key);
|
||||
|
||||
static Key createKey(Destructor destructor = NULL);
|
||||
|
||||
ObjectMetadata() : values_(NULL) { }
|
||||
~ObjectMetadata();
|
||||
|
||||
Value getValueForKey(Key key) const;
|
||||
|
||||
bool setValueForKey(Key key, Value value);
|
||||
};
|
||||
|
||||
/*! \brief For all OpenCL/Runtime objects.
|
||||
*/
|
||||
class RuntimeObject : public ReferenceCountedObject, public ICDDispatchedObject
|
||||
{
|
||||
private:
|
||||
ObjectMetadata metadata_;
|
||||
|
||||
public:
|
||||
|
||||
enum ObjectType {
|
||||
ObjectTypeContext = 0,
|
||||
ObjectTypeDevice = 1,
|
||||
ObjectTypeMemory = 2,
|
||||
ObjectTypeKernel = 3,
|
||||
ObjectTypeCounter = 4,
|
||||
ObjectTypePerfCounter = 5,
|
||||
ObjectTypeEvent = 6,
|
||||
ObjectTypeProgram = 7,
|
||||
ObjectTypeQueue = 8,
|
||||
ObjectTypeSampler = 9,
|
||||
ObjectTypeThreadTrace = 10,
|
||||
ObjectTypeVideoSession= 11
|
||||
};
|
||||
|
||||
ObjectMetadata& metadata() { return metadata_; }
|
||||
virtual ObjectType objectType() const =0 ;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class SharedReference : public EmbeddedObject
|
||||
{
|
||||
private:
|
||||
T& reference_;
|
||||
|
||||
private:
|
||||
// do not copy shared references.
|
||||
SharedReference<T>& operator = (const SharedReference<T>& sref);
|
||||
|
||||
public:
|
||||
explicit SharedReference(T& reference)
|
||||
: reference_(reference)
|
||||
{
|
||||
reference_.retain();
|
||||
}
|
||||
|
||||
~SharedReference()
|
||||
{
|
||||
reference_.release();
|
||||
}
|
||||
|
||||
T& operator ()() const { return reference_; }
|
||||
};
|
||||
|
||||
/*! \brief A 1,2 or 3D coordinate.
|
||||
*!
|
||||
*! Note, dimensionality is only defined for sizes, and is given by the number
|
||||
*! of non-zero elements. (i.e. a 1D line is not the same as a 2D plane with width 1)
|
||||
*/
|
||||
|
||||
struct Coord3D
|
||||
{
|
||||
size_t c[3];
|
||||
|
||||
Coord3D(size_t d0, size_t d1 = 0, size_t d2 = 0)
|
||||
{
|
||||
c[0]=d0; c[1]=d1; c[2]=d2;
|
||||
}
|
||||
const size_t& operator[] (size_t idx) const
|
||||
{
|
||||
assert(idx < 3);
|
||||
return c[idx];
|
||||
}
|
||||
bool operator== (const Coord3D& rhs) const
|
||||
{
|
||||
return c[0] == rhs.c[0] && c[1] == rhs.c[1] && c[2] == rhs.c[2];
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace amd
|
||||
|
||||
template <typename CL>
|
||||
typename amd::as_internal<CL>::type*
|
||||
as_amd(CL* cl_obj)
|
||||
{
|
||||
return cl_obj == NULL ? NULL : amd::RuntimeObject::fromHandle<
|
||||
typename amd::as_internal<CL>::type>(static_cast<void*>(cl_obj));
|
||||
}
|
||||
|
||||
template <typename AMD>
|
||||
typename amd::as_external<AMD>::type*
|
||||
as_cl(AMD* amd_obj)
|
||||
{
|
||||
return amd_obj == NULL ? NULL : static_cast<
|
||||
typename amd::as_external<AMD>::type*>(amd_obj->handle());
|
||||
}
|
||||
|
||||
template <typename CL>
|
||||
bool
|
||||
is_valid(CL* handle)
|
||||
{
|
||||
return amd::as_internal<CL>::type::isValidHandle(handle);
|
||||
}
|
||||
|
||||
#endif /*OBJECT_HPP_*/
|
||||
Reference in New Issue
Block a user