pokus s pridanim podpory GPUPerfAPI. pre OpenGL funguje. pre OpenCl vracia GPA_STATUS_ERROR_HARDWARE_NOT_SUPPORTED
This commit is contained in:
Dušan Poizl
parent
dcc4f271c7
commit
06cbece97b
asynchronousmodel.cppcellula.cbpglwidget.cpp
gpuperf
kernels
machine.cpp@ -26,7 +26,7 @@ int AsynchronousModel::getCellSize()
|
||||
void AsynchronousModel::loadSource()
|
||||
{
|
||||
stringstream s;
|
||||
s << "-I./kernels/ -D NEIGHBOR=" << neighbor << " -D QUEUE_LEN=" << queue_len << " -g";
|
||||
s << "-I./kernels/ -D NEIGHBOR=" << neighbor << " -D QUEUE_LEN=" << queue_len;
|
||||
string source = "__constant int neighbors[] = {-1,1, 1,1, -1,-1, 1,-1, 0,1, -1,0, 1,0, 0,-1, 0,0 };\n";
|
||||
source += "#include \"asynchr.cl\"";
|
||||
build(source, s.str());
|
||||
|
||||
10
cellula.cbp
10
cellula.cbp
@ -35,9 +35,11 @@
|
||||
</Build>
|
||||
<Compiler>
|
||||
<Add option="-Wall" />
|
||||
<Add option="-D_LINUX" />
|
||||
<Add directory="/usr/include/qt4" />
|
||||
<Add directory="/usr/include/qt4/QtGui" />
|
||||
<Add directory="/usr/include/qt4/QtCore" />
|
||||
<Add directory="/home/nou/c++/cellula/gpuperf/include" />
|
||||
</Compiler>
|
||||
<Linker>
|
||||
<Add library="QtCore" />
|
||||
@ -93,6 +95,14 @@
|
||||
<Option compiler="gcc" use="1" buildCommand="moc glwidget.h -o moc_glwidget.cpp" />
|
||||
<Option target="qt4" />
|
||||
</Unit>
|
||||
<Unit filename="gpuperf/include/gpaload.cpp">
|
||||
<Option target="Debug" />
|
||||
<Option target="Release" />
|
||||
</Unit>
|
||||
<Unit filename="gpuperf/include/gpaload.h">
|
||||
<Option target="Debug" />
|
||||
<Option target="Release" />
|
||||
</Unit>
|
||||
<Unit filename="kernel.cl">
|
||||
<Option target="Debug" />
|
||||
<Option target="Release" />
|
||||
|
||||
57
glwidget.cpp
57
glwidget.cpp
@ -8,6 +8,7 @@
|
||||
#include "cellspace.h"
|
||||
#include "model.h"
|
||||
#include "machine.h"
|
||||
#include "gpuperf/include/gpaload.h"
|
||||
|
||||
/**
|
||||
@param format format ktory sa ma pouzit pri vytvarani OpenGL okna. pozri Qt dokumentaciu ku QGLWidget
|
||||
@ -40,6 +41,7 @@ void GLwidget::initializeGL()
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
gpa_uint32 num_counters,num_passes;
|
||||
if(!initialized)
|
||||
{
|
||||
std::cout << "Inicializujem OpenGL" << std::endl;
|
||||
@ -47,6 +49,19 @@ void GLwidget::initializeGL()
|
||||
std::cout << "\tRenderer:\t" << glGetString(GL_RENDERER) << std::endl;
|
||||
std::cout << "\tVersion:\t" << glGetString(GL_VERSION) << std::endl;
|
||||
//std::cout << "\tGLSL version:\t" << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
|
||||
//std::cout << getGPAError(GPA_OpenContext(glXGetCurrentContext())) << endl;
|
||||
//std::cout << getGPAError(GPA_GetNumCounters(&num_counters));
|
||||
//GPA_EnableAllCounters();
|
||||
//cout << " " << num_counters << endl;
|
||||
//char *name;
|
||||
/*for(unsigned int i=0;i<num_counters;i++)
|
||||
{
|
||||
GPA_GetCounterName(i, (const char**)&name);
|
||||
cout << name << endl;
|
||||
}*/
|
||||
//GPA_EnableCounter(1);
|
||||
//GPA_GetPassCount(&num_passes);
|
||||
//cout << "Pocet prechodov: " << num_passes << endl;
|
||||
initialized = true;
|
||||
}
|
||||
if(space)
|
||||
@ -62,6 +77,12 @@ Vykreslovanie OpenGL sceny
|
||||
*/
|
||||
void GLwidget::paintGL()
|
||||
{
|
||||
/*gpa_uint32 sessionID;
|
||||
GPA_BeginSession(&sessionID);
|
||||
|
||||
GPA_BeginPass();
|
||||
GPA_BeginSample(0);*/
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
glBindTexture(GL_TEXTURE_2D, tex);
|
||||
@ -77,6 +98,42 @@ void GLwidget::paintGL()
|
||||
glTexCoord2d((float)pos_x/tex_w, (float)(pos_y+h*zoom)/tex_h);glVertex3f(-1.0f, 1.0f, 0.0f);
|
||||
glEnd();
|
||||
|
||||
/*GPA_EndSample();
|
||||
GPA_EndPass();
|
||||
GPA_EndSession();*/
|
||||
glFinish();
|
||||
|
||||
/*GPA_Status sessionStatus;
|
||||
bool readyResult;
|
||||
sessionStatus = GPA_IsSessionReady( &readyResult, sessionID);
|
||||
cout << "Status " << getGPAError(sessionStatus) << " " << readyResult << endl;
|
||||
|
||||
GPA_Type type;
|
||||
GPA_GetCounterDataType(0, &type);
|
||||
if ( type == GPA_TYPE_UINT32 )
|
||||
{
|
||||
gpa_uint32 value=0;
|
||||
cout<<getGPAError(GPA_GetSampleUInt32(sessionID, 0, 1, &value))<< endl;;
|
||||
cout << value << endl;
|
||||
}
|
||||
else if ( type == GPA_TYPE_UINT64 )
|
||||
{
|
||||
gpa_uint64 value=0;
|
||||
cout<<getGPAError(GPA_GetSampleUInt64(sessionID, 0, 1, &value))<< endl;;
|
||||
cout << value << endl;
|
||||
}
|
||||
else if ( type == GPA_TYPE_FLOAT32 )
|
||||
{
|
||||
gpa_float32 value=0;
|
||||
cout<<getGPAError(GPA_GetSampleFloat32(sessionID, 0, 1, &value))<< endl;;
|
||||
cout << value << endl;
|
||||
}
|
||||
else if ( type == GPA_TYPE_FLOAT64 )
|
||||
{
|
||||
gpa_float64 value=0;
|
||||
cout<<getGPAError(GPA_GetSampleFloat64(sessionID, 0, 1, &value))<< endl;;
|
||||
cout << value << endl;
|
||||
}*/
|
||||
}
|
||||
|
||||
void GLwidget::resizeGL(int w,int h)
|
||||
|
||||
BIN
gpuperf/GPUPerfAPI-UserGuide.pdf
Executable file
BIN
gpuperf/GPUPerfAPI-UserGuide.pdf
Executable file
Binary file not shown.
1
gpuperf/License.txt
Executable file
1
gpuperf/License.txt
Executable file
File diff suppressed because one or more lines are too long
70
gpuperf/include/GPAFunctions.h
Executable file
70
gpuperf/include/GPAFunctions.h
Executable file
@ -0,0 +1,70 @@
|
||||
|
||||
|
||||
#ifndef GPA_FUNCTION_PREFIX
|
||||
#define GPA_FUNCTION_PREFIX( f ) GPALIB_DECL f ## PtrType f;
|
||||
#endif
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_Initialize )
|
||||
GPA_FUNCTION_PREFIX( GPA_Destroy )
|
||||
|
||||
// Context
|
||||
GPA_FUNCTION_PREFIX( GPA_OpenContext )
|
||||
GPA_FUNCTION_PREFIX( GPA_CloseContext )
|
||||
GPA_FUNCTION_PREFIX( GPA_SelectContext )
|
||||
|
||||
// Counter Interrogation
|
||||
GPA_FUNCTION_PREFIX( GPA_GetNumCounters )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterName )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterDescription )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterDataType )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterUsageType )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetDataTypeAsStr )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetUsageTypeAsStr )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetStatusAsStr )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_EnableCounter )
|
||||
GPA_FUNCTION_PREFIX( GPA_DisableCounter )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetEnabledCount )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetEnabledIndex )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_IsCounterEnabled )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_EnableCounterStr )
|
||||
GPA_FUNCTION_PREFIX( GPA_DisableCounterStr )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_EnableAllCounters )
|
||||
GPA_FUNCTION_PREFIX( GPA_DisableAllCounters )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterIndex )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_GetPassCount )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_BeginSession )
|
||||
GPA_FUNCTION_PREFIX( GPA_EndSession )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_BeginPass )
|
||||
GPA_FUNCTION_PREFIX( GPA_EndPass )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_BeginSample )
|
||||
GPA_FUNCTION_PREFIX( GPA_EndSample )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleCount )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_IsSampleReady )
|
||||
GPA_FUNCTION_PREFIX( GPA_IsSessionReady )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleUInt64 )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleUInt32 )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleFloat64 )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleFloat32 )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterType )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetTypeAsStr )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_InternalProfileStart )
|
||||
GPA_FUNCTION_PREFIX( GPA_InternalProfileStop )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_InternalGetDeviceID )
|
||||
GPA_FUNCTION_PREFIX( GPA_InternalGetDeviceDesc )
|
||||
|
||||
#undef GPA_FUNCTION_PREFIX
|
||||
|
||||
|
||||
361
gpuperf/include/GPUPerfAPI.h
Executable file
361
gpuperf/include/GPUPerfAPI.h
Executable file
@ -0,0 +1,361 @@
|
||||
//=============================================================================
|
||||
//
|
||||
// Author: GPU Developer Tools
|
||||
// AMD, Inc.
|
||||
//
|
||||
// This file is the only header that must be included by an application that
|
||||
// wishes to use GPUPerfAPI. It defines all the available entrypoints.
|
||||
//=============================================================================
|
||||
// Copyright (c) 2010 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//=============================================================================
|
||||
|
||||
#ifndef _GPUPERFAPI_H_
|
||||
#define _GPUPERFAPI_H_
|
||||
|
||||
#ifndef GPALIB_DECL
|
||||
#ifdef _WIN32
|
||||
#ifdef __cplusplus
|
||||
#define GPALIB_DECL extern "C" __declspec( dllimport )
|
||||
#else
|
||||
#define GPALIB_DECL __declspec( dllimport )
|
||||
#endif
|
||||
#else //_LINUX
|
||||
#define GPALIB_DECL extern
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <assert.h>
|
||||
#include "GPUPerfAPITypes.h"
|
||||
|
||||
// Init / destroy GPA
|
||||
/*
|
||||
/// \brief Initializes the driver so that counters are exposed.
|
||||
///
|
||||
/// This function must be called before the rendering context or device is created.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_Initialize( );
|
||||
|
||||
/// \brief Undo any initialization to ensure proper behavior in applications that are not being profiled.
|
||||
///
|
||||
/// This function must be called after the rendering context or device is released / destroyed.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_Destroy( );
|
||||
|
||||
// Context Startup / Finish
|
||||
|
||||
/// \brief Opens the counters in the specified context for reading.
|
||||
///
|
||||
/// This function must be called before any other GPA functions.
|
||||
/// \param context The context to open counters for. Typically a device pointer. Refer to GPA API specific documentation for further details.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_OpenContext( void* context );
|
||||
|
||||
/// \brief Closes the counters in the currently active context.
|
||||
///
|
||||
/// GPA functions should not be called again until the counters are reopened with GPA_OpenContext.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_CloseContext();
|
||||
|
||||
/// \brief Select another context to be the currently active context.
|
||||
///
|
||||
/// The selected context must have previously been opened with a call to GPA_OpenContext.
|
||||
/// If the call is successful, all GPA functions will act on the currently selected context.
|
||||
/// \param context The context to select. The same value that was passed to GPA_OpenContext.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_SelectContext( void* context );
|
||||
|
||||
|
||||
// Counter Interrogation
|
||||
|
||||
/// \brief Get the number of counters available.
|
||||
///
|
||||
/// \param count The value which will hold the count upon successful execution.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetNumCounters( gpa_uint32* count );
|
||||
|
||||
/// \brief Get the name of a specific counter.
|
||||
///
|
||||
/// \param index The index of the counter name to query. Must lie between 0 and (GPA_GetNumCounters result - 1).
|
||||
/// \param name The value which will hold the name upon successful execution.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetCounterName( gpa_uint32 index, const char** name );
|
||||
|
||||
/// \brief Get description of the specified counter.
|
||||
///
|
||||
/// \param index The index of the counter to query. Must lie between 0 and (GPA_GetNumCounters result - 1).
|
||||
/// \param description The value which will hold the description upon successful execution.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetCounterDescription( gpa_uint32 index, const char** description );
|
||||
|
||||
/// \brief Get the counter data type of the specified counter.
|
||||
///
|
||||
/// \param index The index of the counter. Must lie between 0 and (GPA_GetNumCounters result - 1).
|
||||
/// \param counterDataType The value which will hold the description upon successful execution.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetCounterDataType( gpa_uint32 index, GPA_Type* counterDataType );
|
||||
|
||||
/// \brief Get the counter usage type of the specified counter.
|
||||
///
|
||||
/// \param index The index of the counter. Must lie between 0 and (GPA_GetNumCounters result - 1).
|
||||
/// \param counterUsageType The value which will hold the description upon successful execution.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetCounterUsageType( gpa_uint32 index, GPA_Usage_Type* counterUsageType );
|
||||
|
||||
/// \brief Get a string with the name of the specified counter data type.
|
||||
///
|
||||
/// Typically used to display counter types along with their name.
|
||||
/// E.g. counterDataType of GPA_TYPE_UINT64 would return "gpa_uint64".
|
||||
/// \param counterDataType The type to get the string for.
|
||||
/// \param typeStr The value that will be set to contain a reference to the name of the counter data type.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetDataTypeAsStr( GPA_Type counterDataType, const char** typeStr );
|
||||
|
||||
/// \brief Get a string with the name of the specified counter usage type.
|
||||
///
|
||||
/// Convertes the counter usage type to a string representation.
|
||||
/// E.g. counterUsageType of GPA_USAGE_TYPE_PERCENTAGE would return "percentage".
|
||||
/// \param counterUsageType The type to get the string for.
|
||||
/// \param typeStr The value that will be set to contain a reference to the name of the counter usage type.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetUsageTypeAsStr( GPA_Usage_Type counterUsageType, const char** usageTypeStr );
|
||||
|
||||
/// \brief Enable a specified counter.
|
||||
///
|
||||
/// Subsequent sampling sessions will provide values for any enabled counters.
|
||||
/// Initially all counters are disabled, and must explicitly be enabled by calling this function.
|
||||
/// \param index The index of the counter to enable. Must lie between 0 and (GPA_GetNumCounters result - 1).
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_EnableCounter( gpa_uint32 index );
|
||||
|
||||
|
||||
/// \brief Disable a specified counter.
|
||||
///
|
||||
/// Subsequent sampling sessions will not provide values for any disabled counters.
|
||||
/// Initially all counters are disabled, and must explicitly be enabled.
|
||||
/// \param index The index of the counter to enable. Must lie between 0 and (GPA_GetNumCounters result - 1).
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_DisableCounter( gpa_uint32 index );
|
||||
|
||||
|
||||
/// \brief Get the number of enabled counters.
|
||||
///
|
||||
/// \param count The value that will be set to the number of counters that are currently enabled.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetEnabledCount( gpa_uint32* count );
|
||||
|
||||
|
||||
/// \brief Get the counter index for an enabled counter.
|
||||
///
|
||||
/// For example, if GPA_GetEnabledIndex returns 3, and I wanted the counter index of the first enabled counter,
|
||||
/// I would call this function with enabledNumber equal to 0.
|
||||
/// \param enabledNumber The number of the enabled counter to get the counter index for. Must lie between 0 and (GPA_GetEnabledIndex result - 1).
|
||||
/// \param enabledCounterIndex The value that will contain the index of the counter.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetEnabledIndex( gpa_uint32 enabledNumber, gpa_uint32* enabledCounterIndex );
|
||||
|
||||
|
||||
/// \brief Check that a counter is enabled.
|
||||
///
|
||||
/// \param counterIndex The index of the counter. Must lie between 0 and (GPA_GetNumCounters result - 1).
|
||||
/// \return GPA_STATUS_OK is returned if the counter is enabled, GPA_STATUS_ERROR_NOT_FOUND otherwise.
|
||||
GPALIB_DECL GPA_Status GPA_IsCounterEnabled( gpa_uint32 counterIndex );
|
||||
|
||||
|
||||
/// \brief Enable a specified counter using the counter name (case insensitive).
|
||||
///
|
||||
/// Subsequent sampling sessions will provide values for any enabled counters.
|
||||
/// Initially all counters are disabled, and must explicitly be enabled by calling this function.
|
||||
/// \param counter The name of the counter to enable.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_EnableCounterStr( const char* counter );
|
||||
|
||||
|
||||
/// \brief Disable a specified counter using the counter name (case insensitive).
|
||||
///
|
||||
/// Subsequent sampling sessions will not provide values for any disabled counters.
|
||||
/// Initially all counters are disabled, and must explicitly be enabled.
|
||||
/// \param counter The name of the counter to disable.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_DisableCounterStr( const char* counter );
|
||||
|
||||
|
||||
/// \brief Enable all counters.
|
||||
///
|
||||
/// Subsequent sampling sessions will provide values for all counters.
|
||||
/// Initially all counters are disabled, and must explicitly be enabled by calling a function which enables them.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_EnableAllCounters();
|
||||
|
||||
|
||||
/// \brief Disable all counters.
|
||||
///
|
||||
/// Subsequent sampling sessions will not provide values for any disabled counters.
|
||||
/// Initially all counters are disabled, and must explicitly be enabled.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_DisableAllCounters();
|
||||
|
||||
|
||||
/// \brief Get index of a counter given its name (case insensitive).
|
||||
///
|
||||
/// \param counter The name of the counter to get the index for.
|
||||
/// \param index The index of the requested counter.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetCounterIndex( const char* counter, gpa_uint32* index );
|
||||
|
||||
|
||||
/// \brief Get the number of passes required for the currently enabled set of counters.
|
||||
///
|
||||
/// This represents the number of times the same sequence must be repeated to capture the counter data.
|
||||
/// On each pass a different (compatible) set of counters will be measured.
|
||||
/// \param numPasses The value of the number of passes.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetPassCount( gpa_uint32* numPasses );
|
||||
|
||||
|
||||
/// \brief Begin sampling with the currently enabled set of counters.
|
||||
///
|
||||
/// This must be called to begin the counter sampling process.
|
||||
/// A unique sessionID will be returned which is later used to retrieve the counter values.
|
||||
/// Session Identifiers are integers and always start from 1 on a newly opened context, upwards in sequence.
|
||||
/// The set of enabled counters cannot be changed inside a BeginSession/EndSession sequence.
|
||||
/// \param sessionID The value that will be set to the session identifier.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_BeginSession( gpa_uint32* sessionID );
|
||||
|
||||
|
||||
/// \brief End sampling with the currently enabled set of counters.
|
||||
///
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_EndSession();
|
||||
|
||||
|
||||
/// \brief Begin sampling pass.
|
||||
///
|
||||
/// Between BeginPass and EndPass calls it is expected that a sequence of repeatable operations exist.
|
||||
/// If this is not the case only counters which execute in a single pass should be activated.
|
||||
/// The number of required passes can be determined by enabling a set of counters and then calling GPA_GetPassCount.
|
||||
/// The operations inside the BeginPass/EndPass calls should be looped over GPA_GetPassCount result number of times.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_BeginPass();
|
||||
|
||||
|
||||
/// \brief End sampling pass.
|
||||
///
|
||||
/// Between BeginPass and EndPass calls it is expected that a sequence of repeatable operations exist.
|
||||
/// If this is not the case only counters which execute in a single pass should be activated.
|
||||
/// The number of required passes can be determined by enabling a set of counters and then calling GPA_GetPassCount.
|
||||
/// The operations inside the BeginPass/EndPass calls should be looped over GPA_GetPassCount result number of times.
|
||||
/// This is necessary to capture all counter values, since sometimes counter combinations cannot be captured simultaneously.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_EndPass();
|
||||
|
||||
|
||||
/// \brief Begin a sample using the enabled counters.
|
||||
///
|
||||
/// Multiple samples can be performed inside a BeginSession/EndSession sequence.
|
||||
/// Each sample computes the values of the counters between BeginSample and EndSample.
|
||||
/// To identify each sample the user must provide a unique sampleID as a paramter to this function.
|
||||
/// The number need only be unique within the same BeginSession/EndSession sequence.
|
||||
/// BeginSample must be followed by a call to EndSample before BeginSample is called again.
|
||||
/// \param sampleID Any integer, unique within the BeginSession/EndSession sequence, used to retrieve the sample results.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_BeginSample( gpa_uint32 sampleID );
|
||||
|
||||
|
||||
/// \brief End sampling using the enabled counters.
|
||||
///
|
||||
/// BeginSample must be followed by a call to EndSample before BeginSample is called again.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_EndSample();
|
||||
|
||||
/// \brief Get the number of samples a specified session contains.
|
||||
///
|
||||
/// This is useful if samples are conditionally created and a count is not kept.
|
||||
/// \param sessionID The session to get the number of samples for.
|
||||
/// \param samples The value that will be set to the number of samples contained within the session.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetSampleCount( gpa_uint32 sessionID, gpa_uint32 *samples );
|
||||
|
||||
|
||||
/// \brief Determine if an individual sample result is available.
|
||||
///
|
||||
/// After a sampling session results may be available immediately or take a certain amount of time to become available.
|
||||
/// This function allows you to determine when a sample can be read.
|
||||
/// The function does not block, permitting periodic polling.
|
||||
/// To block until a sample is ready use a GetSample* function instead of this.
|
||||
/// It can be more efficient to determine if a whole session's worth of data is available using GPA_IsSessionReady.
|
||||
/// \param readyResult The value that will contain the result of the sample being ready. True if ready.
|
||||
/// \param sessionID The session containing the sample to determine availability.
|
||||
/// \param sampleID The sample identifier of the sample to query availability for.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_IsSampleReady( bool* readyResult, gpa_uint32 sessionID, gpa_uint32 sampleID );
|
||||
|
||||
|
||||
/// \brief Determine if all samples within a session are available.
|
||||
///
|
||||
/// After a sampling session results may be available immediately or take a certain amount of time to become available.
|
||||
/// This function allows you to determine when the results of a session can be read.
|
||||
/// The function does not block, permitting periodic polling.
|
||||
/// To block until a sample is ready use a GetSample* function instead of this.
|
||||
/// \param readyResult The value that will contain the result of the session being ready. True if ready.
|
||||
/// \param sessionID The session to determine availability for.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_IsSessionReady( bool* readyResult, gpa_uint32 sessionID );
|
||||
|
||||
|
||||
/// \brief Get a sample of type 64-bit unsigned integer.
|
||||
///
|
||||
/// This function will block until the value is available.
|
||||
/// Use GPA_IsSampleReady if you do not wish to block.
|
||||
/// \param sessionID The session identifier with the sample you wish to retreive the result of.
|
||||
/// \param sampleID The identifier of the sample to get the result for.
|
||||
/// \param counterID The counter index to get the result for.
|
||||
/// \param result The value which will contain the counter result upon successful execution.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetSampleUInt64( gpa_uint32 sessionID, gpa_uint32 sampleID, gpa_uint32 counterID, gpa_uint64* result );
|
||||
|
||||
|
||||
/// \brief Get a sample of type 32-bit unsigned integer.
|
||||
///
|
||||
/// This function will block until the value is available.
|
||||
/// Use GPA_IsSampleReady if you do not wish to block.
|
||||
/// \param sessionID The session identifier with the sample you wish to retreive the result of.
|
||||
/// \param sampleID The identifier of the sample to get the result for.
|
||||
/// \param counterIndex The counter index to get the result for.
|
||||
/// \param result The value which will contain the counter result upon successful execution.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetSampleUInt32( gpa_uint32 sessionID, gpa_uint32 sampleID, gpa_uint32 counterIndex, gpa_uint32* result );
|
||||
|
||||
|
||||
/// \brief Get a sample of type 64-bit float.
|
||||
///
|
||||
/// This function will block until the value is available.
|
||||
/// Use GPA_IsSampleReady if you do not wish to block.
|
||||
/// \param sessionID The session identifier with the sample you wish to retreive the result of.
|
||||
/// \param sampleID The identifier of the sample to get the result for.
|
||||
/// \param counterIndex The counter index to get the result for.
|
||||
/// \param result The value which will contain the counter result upon successful execution.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetSampleFloat64( gpa_uint32 sessionID, gpa_uint32 sampleID, gpa_uint32 counterIndex, gpa_float64* result );
|
||||
|
||||
|
||||
/// \brief Get a sample of type 32-bit float.
|
||||
///
|
||||
/// This function will block until the value is available.
|
||||
/// Use GPA_IsSampleReady if you do not wish to block.
|
||||
/// \param sessionID The session identifier with the sample you wish to retreive the result of.
|
||||
/// \param sampleID The identifier of the sample to get the result for.
|
||||
/// \param counterIndex The counter index to get the result for.
|
||||
/// \param result The value which will contain the counter result upon successful execution.
|
||||
/// \return The GPA result status of the operation. GPA_STATUS_OK is returned if the operation is successful.
|
||||
GPALIB_DECL GPA_Status GPA_GetSampleFloat32( gpa_uint32 sessionID, gpa_uint32 sampleID, gpa_uint32 counterIndex, gpa_float32* result );
|
||||
|
||||
|
||||
/// \brief Get a string translation of a GPA status value.
|
||||
///
|
||||
/// Provides a simple method to convert a status enum value into a string which can be used to display log messages.
|
||||
/// \param status The status to convert into a string.
|
||||
/// \return A string which describes the supplied status.
|
||||
GPALIB_DECL const char* GPA_GetStatusAsStr( GPA_Status status );
|
||||
*/
|
||||
#endif // _GPUPERFAPI_H_
|
||||
72
gpuperf/include/GPUPerfAPIFunctionTypes.h
Normal file
72
gpuperf/include/GPUPerfAPIFunctionTypes.h
Normal file
@ -0,0 +1,72 @@
|
||||
//=============================================================================
|
||||
//
|
||||
// Author: GPU Developer Tools
|
||||
// AMD, Inc.
|
||||
//
|
||||
// This file defines function types to make it easier to dynamically load
|
||||
// different GPUPerfAPI DLLs into an application that supports multiple APIs.
|
||||
// Applications which statically link to GPUPerfAPI do not need to include
|
||||
// this file.
|
||||
//=============================================================================
|
||||
// Copyright (c) 2010 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//=============================================================================
|
||||
|
||||
#ifndef _GPUPERFAPI_FUNCTION_TYPES_H_
|
||||
#define _GPUPERFAPI_FUNCTION_TYPES_H_
|
||||
|
||||
#include "GPUPerfAPITypes.h"
|
||||
|
||||
// Startup / exit
|
||||
typedef GPA_Status( *GPA_InitializePtrType )();
|
||||
typedef GPA_Status( *GPA_DestroyPtrType )();
|
||||
|
||||
// Context
|
||||
typedef GPA_Status( *GPA_OpenContextPtrType )( void* context );
|
||||
typedef GPA_Status( *GPA_CloseContextPtrType )();
|
||||
typedef GPA_Status( *GPA_SelectContextPtrType )( void* context );
|
||||
|
||||
// Counter Interrogation
|
||||
typedef GPA_Status( *GPA_GetNumCountersPtrType )( gpa_uint32* count );
|
||||
typedef GPA_Status( *GPA_GetCounterNamePtrType )( gpa_uint32 index, const char** name );
|
||||
typedef GPA_Status( *GPA_GetCounterDescriptionPtrType )( gpa_uint32 index, const char** description );
|
||||
typedef GPA_Status( *GPA_GetCounterDataTypePtrType )( gpa_uint32 index, GPA_Type* counterDataType );
|
||||
typedef GPA_Status( *GPA_GetCounterUsageTypePtrType ) ( gpa_uint32 index, GPA_Usage_Type* counterUsageType );
|
||||
typedef GPA_Status( *GPA_GetDataTypeAsStrPtrType )( GPA_Type counterDataType, const char** typeStr );
|
||||
typedef GPA_Status( *GPA_GetUsageTypeAsStrPtrType )( GPA_Usage_Type counterUsageType, const char** typeStr );
|
||||
typedef const char*( *GPA_GetStatusAsStrPtrType ) ( GPA_Status status );
|
||||
|
||||
typedef GPA_Status( *GPA_EnableCounterPtrType )( gpa_uint32 index );
|
||||
typedef GPA_Status( *GPA_DisableCounterPtrType )( gpa_uint32 index );
|
||||
typedef GPA_Status( *GPA_GetEnabledCountPtrType )( gpa_uint32* count );
|
||||
typedef GPA_Status( *GPA_GetEnabledIndexPtrType )( gpa_uint32 enabledNumber, gpa_uint32* enabledCounterIndex );
|
||||
|
||||
typedef GPA_Status( *GPA_IsCounterEnabledPtrType)( gpa_uint32 counterIndex );
|
||||
|
||||
typedef GPA_Status( *GPA_EnableCounterStrPtrType )( const char* counter );
|
||||
typedef GPA_Status( *GPA_DisableCounterStrPtrType )( const char* counter );
|
||||
|
||||
typedef GPA_Status( *GPA_EnableAllCountersPtrType )();
|
||||
typedef GPA_Status( *GPA_DisableAllCountersPtrType )();
|
||||
typedef GPA_Status( *GPA_GetCounterIndexPtrType )( const char* counter, gpa_uint32* index );
|
||||
|
||||
typedef GPA_Status( *GPA_GetPassCountPtrType )( gpa_uint32* numPasses );
|
||||
|
||||
typedef GPA_Status( *GPA_BeginSessionPtrType )( gpa_uint32* sessionID );
|
||||
typedef GPA_Status( *GPA_EndSessionPtrType )();
|
||||
|
||||
typedef GPA_Status( *GPA_BeginPassPtrType )();
|
||||
typedef GPA_Status( *GPA_EndPassPtrType )();
|
||||
|
||||
typedef GPA_Status( *GPA_BeginSamplePtrType )( gpa_uint32 sampleID );
|
||||
typedef GPA_Status( *GPA_EndSamplePtrType )();
|
||||
|
||||
typedef GPA_Status( *GPA_GetSampleCountPtrType ) ( gpa_uint32 sessionID, gpa_uint32 *samples );
|
||||
|
||||
typedef GPA_Status( *GPA_IsSampleReadyPtrType )( bool* readyResult, gpa_uint32 sessionID, gpa_uint32 sampleID );
|
||||
typedef GPA_Status( *GPA_IsSessionReadyPtrType )( bool* readyResult, gpa_uint32 sessionID );
|
||||
typedef GPA_Status( *GPA_GetSampleUInt64PtrType )( gpa_uint32 sessionID, gpa_uint32 sampleID, gpa_uint32 counterID, gpa_uint64* result );
|
||||
typedef GPA_Status( *GPA_GetSampleUInt32PtrType )( gpa_uint32 sessionID, gpa_uint32 sampleID, gpa_uint32 counterIndex, gpa_uint32* result );
|
||||
typedef GPA_Status( *GPA_GetSampleFloat32PtrType )( gpa_uint32 sessionID, gpa_uint32 sampleID, gpa_uint32 counterIndex, gpa_float32* result );
|
||||
typedef GPA_Status( *GPA_GetSampleFloat64PtrType )( gpa_uint32 sessionID, gpa_uint32 sampleID, gpa_uint32 counterIndex, gpa_float64* result );
|
||||
|
||||
#endif // _GPUPERFAPI_FUNCTION_TYPES_H_
|
||||
145
gpuperf/include/GPUPerfAPITypes.h
Normal file
145
gpuperf/include/GPUPerfAPITypes.h
Normal file
@ -0,0 +1,145 @@
|
||||
//=============================================================================
|
||||
//
|
||||
// Author: GPU Developer Tools
|
||||
// AMD, Inc.
|
||||
//
|
||||
// Defines the data types and enumerations used by GPUPerfAPI.
|
||||
// This file does not need to be directly included by an application
|
||||
// that uses GPUPerfAPI.
|
||||
//=============================================================================
|
||||
// Copyright (c) 2010 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//=============================================================================
|
||||
#ifndef _GPUPERFAPI_TYPES_H_
|
||||
#define _GPUPERFAPI_TYPES_H_
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
// Type definitions
|
||||
#ifdef _WIN32
|
||||
typedef char gpa_int8;
|
||||
typedef short gpa_int16;
|
||||
typedef int gpa_int32;
|
||||
typedef __int64 gpa_int64;
|
||||
typedef float gpa_float32;
|
||||
typedef double gpa_float64;
|
||||
typedef unsigned char gpa_uint8;
|
||||
typedef unsigned short gpa_uint16;
|
||||
typedef unsigned int gpa_uint32;
|
||||
typedef unsigned __int64 gpa_uint64;
|
||||
#ifndef __cplusplus
|
||||
typedef gpa_uint8 bool;
|
||||
#endif
|
||||
#endif // _WIN32
|
||||
|
||||
#ifdef _LINUX
|
||||
|
||||
#ifdef GPALIB_DECL
|
||||
#else
|
||||
# ifdef __cplusplus
|
||||
# define GPALIB_DECL extern "C"
|
||||
# else
|
||||
# define GPALIB_DECL
|
||||
# endif // _cplusplus
|
||||
#endif
|
||||
|
||||
typedef char gpa_int8;
|
||||
typedef short gpa_int16;
|
||||
typedef int gpa_int32;
|
||||
typedef long int gpa_int64;
|
||||
typedef unsigned int UINT;
|
||||
typedef float gpa_float32;
|
||||
typedef double gpa_float64;
|
||||
typedef unsigned char gpa_uint8;
|
||||
typedef unsigned short gpa_uint16;
|
||||
typedef unsigned int gpa_uint32;
|
||||
typedef unsigned long int gpa_uint64;
|
||||
#ifndef __cplusplus
|
||||
typedef gpa_uint8 bool;
|
||||
#endif
|
||||
|
||||
// Linux
|
||||
#define TRACE_FUNCTION(x)
|
||||
#define UNREFERENCED_PARAMETER(x)
|
||||
#define UNREFERECED_VAR(x)
|
||||
|
||||
#define _strcmpi(a, b) strcasecmp(a, b)
|
||||
|
||||
// for now, just use non secure version for Linux
|
||||
#define strcpy_s(dst, ndst, src) strcpy(dst, src)
|
||||
#define strtok_s(a, b, c) strtok(a, b)
|
||||
|
||||
#endif // _LINUX
|
||||
|
||||
// Limit definitions
|
||||
#define GPA_INT8_MAX SCHAR_MAX
|
||||
#define GPA_INT16_MAX SHRT_MAX
|
||||
#define GPA_INT32_MAX INT_MAX
|
||||
#define GPA_INT64_MAX LLONG_MAX
|
||||
|
||||
#define GPA_UINT8_MAX UCHAR_MAX
|
||||
#define GPA_UINT16_MAX USHRT_MAX
|
||||
#define GPA_UINT32_MAX UINT_MAX
|
||||
#define GPA_UINT64_MAX ULLONG_MAX
|
||||
|
||||
|
||||
/// Status enumerations
|
||||
typedef enum
|
||||
{
|
||||
GPA_STATUS_OK = 0,
|
||||
GPA_STATUS_ERROR_NULL_POINTER,
|
||||
GPA_STATUS_ERROR_COUNTERS_NOT_OPEN,
|
||||
GPA_STATUS_ERROR_COUNTERS_ALREADY_OPEN,
|
||||
GPA_STATUS_ERROR_INDEX_OUT_OF_RANGE,
|
||||
GPA_STATUS_ERROR_NOT_FOUND,
|
||||
GPA_STATUS_ERROR_ALREADY_ENABLED,
|
||||
GPA_STATUS_ERROR_NO_COUNTERS_ENABLED,
|
||||
GPA_STATUS_ERROR_NOT_ENABLED,
|
||||
GPA_STATUS_ERROR_SAMPLING_NOT_STARTED,
|
||||
GPA_STATUS_ERROR_SAMPLING_ALREADY_STARTED,
|
||||
GPA_STATUS_ERROR_SAMPLING_NOT_ENDED,
|
||||
GPA_STATUS_ERROR_NOT_ENOUGH_PASSES,
|
||||
GPA_STATUS_ERROR_PASS_NOT_ENDED,
|
||||
GPA_STATUS_ERROR_PASS_NOT_STARTED,
|
||||
GPA_STATUS_ERROR_PASS_ALREADY_STARTED,
|
||||
GPA_STATUS_ERROR_SAMPLE_NOT_STARTED,
|
||||
GPA_STATUS_ERROR_SAMPLE_ALREADY_STARTED,
|
||||
GPA_STATUS_ERROR_SAMPLE_NOT_ENDED,
|
||||
GPA_STATUS_ERROR_CANNOT_CHANGE_COUNTERS_WHEN_SAMPLING,
|
||||
GPA_STATUS_ERROR_SESSION_NOT_FOUND,
|
||||
GPA_STATUS_ERROR_SAMPLE_NOT_FOUND,
|
||||
GPA_STATUS_ERROR_SAMPLE_NOT_FOUND_IN_ALL_PASSES,
|
||||
GPA_STATUS_ERROR_COUNTER_NOT_OF_SPECIFIED_TYPE,
|
||||
GPA_STATUS_ERROR_READING_COUNTER_RESULT,
|
||||
GPA_STATUS_ERROR_VARIABLE_NUMBER_OF_SAMPLES_IN_PASSES,
|
||||
GPA_STATUS_ERROR_FAILED,
|
||||
GPA_STATUS_ERROR_HARDWARE_NOT_SUPPORTED,
|
||||
} GPA_Status;
|
||||
|
||||
|
||||
/// Value type definitions
|
||||
typedef enum
|
||||
{
|
||||
GPA_TYPE_FLOAT32, ///< Result will be a 32-bit float
|
||||
GPA_TYPE_FLOAT64, ///< Result will be a 64-bit float
|
||||
GPA_TYPE_UINT32, ///< Result will be a 32-bit unsigned int
|
||||
GPA_TYPE_UINT64, ///< Result will be a 64-bit unsigned int
|
||||
GPA_TYPE_INT32, ///< Result will be a 32-bit int
|
||||
GPA_TYPE_INT64, ///< Result will be a 64-bit int
|
||||
GPA_TYPE__LAST ///< Marker indicating last element
|
||||
} GPA_Type;
|
||||
|
||||
/// Result usage type definitions
|
||||
typedef enum
|
||||
{
|
||||
GPA_USAGE_TYPE_RATIO, ///< Result is a ratio of two different values or types
|
||||
GPA_USAGE_TYPE_PERCENTAGE, ///< Result is a percentage, typically within [0,100] range, but may be higher for certain counters
|
||||
GPA_USAGE_TYPE_CYCLES, ///< Result is in clock cycles
|
||||
GPA_USAGE_TYPE_MILLISECONDS, ///< Result is in milliseconds
|
||||
GPA_USAGE_TYPE_BYTES, ///< Result is in bytes
|
||||
GPA_USAGE_TYPE_ITEMS, ///< Result is a count of items or objects (ie, vertices, triangles, threads, pixels, texels, etc)
|
||||
GPA_USAGE_TYPE_KILOBYTES, ///< Result is in kilobytes
|
||||
GPA_USAGE_TYPE__LAST ///< Marker indicating last element
|
||||
} GPA_Usage_Type;
|
||||
|
||||
#endif // _GPUPERFAPI_TYPES_H_
|
||||
|
||||
136
gpuperf/include/gpaload.cpp
Normal file
136
gpuperf/include/gpaload.cpp
Normal file
@ -0,0 +1,136 @@
|
||||
#include "gpaload.h"
|
||||
|
||||
#undef GPA_FUNCTION_PREFIX
|
||||
#define GPA_FUNCTION_PREFIX( f ) f ## PtrType f;
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_Initialize )
|
||||
GPA_FUNCTION_PREFIX( GPA_Destroy )
|
||||
|
||||
// Context
|
||||
GPA_FUNCTION_PREFIX( GPA_OpenContext )
|
||||
GPA_FUNCTION_PREFIX( GPA_CloseContext )
|
||||
GPA_FUNCTION_PREFIX( GPA_SelectContext )
|
||||
|
||||
// Counter Interrogation
|
||||
GPA_FUNCTION_PREFIX( GPA_GetNumCounters )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterName )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterDescription )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterDataType )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterUsageType )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetDataTypeAsStr )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetUsageTypeAsStr )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetStatusAsStr )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_EnableCounter )
|
||||
GPA_FUNCTION_PREFIX( GPA_DisableCounter )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetEnabledCount )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetEnabledIndex )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_IsCounterEnabled )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_EnableCounterStr )
|
||||
GPA_FUNCTION_PREFIX( GPA_DisableCounterStr )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_EnableAllCounters )
|
||||
GPA_FUNCTION_PREFIX( GPA_DisableAllCounters )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterIndex )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_GetPassCount )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_BeginSession )
|
||||
GPA_FUNCTION_PREFIX( GPA_EndSession )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_BeginPass )
|
||||
GPA_FUNCTION_PREFIX( GPA_EndPass )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_BeginSample )
|
||||
GPA_FUNCTION_PREFIX( GPA_EndSample )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleCount )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_IsSampleReady)
|
||||
GPA_FUNCTION_PREFIX( GPA_IsSessionReady)
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleUInt64)
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleUInt32)
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleFloat32)
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleFloat64)
|
||||
|
||||
int loadGPAFunc()
|
||||
{
|
||||
void *h = dlopen("libGPUPerfAPIGL.so", RTLD_NOW);
|
||||
if(h==0)return -1;
|
||||
GPA_Initialize = (GPA_InitializePtrType)dlsym(h, "GPA_Initialize");
|
||||
GPA_Destroy = (GPA_DestroyPtrType)dlsym(h, "GPA_Destroy");
|
||||
GPA_OpenContext = (GPA_OpenContextPtrType)dlsym(h, "GPA_OpenContext");
|
||||
GPA_CloseContext = (GPA_CloseContextPtrType)dlsym(h, "GPA_CloseContext");
|
||||
GPA_SelectContext = (GPA_SelectContextPtrType)dlsym(h, "GPA_SelectContext");
|
||||
GPA_GetNumCounters = (GPA_GetNumCountersPtrType)dlsym(h, "GPA_GetNumCounters");
|
||||
GPA_GetCounterName = (GPA_GetCounterNamePtrType)dlsym(h, "GPA_GetCounterName");
|
||||
GPA_GetCounterDescription = (GPA_GetCounterDescriptionPtrType)dlsym(h, "GPA_GetCounterDescription");
|
||||
GPA_GetCounterDataType = (GPA_GetCounterDataTypePtrType)dlsym(h, "GPA_GetCounterDataType");
|
||||
GPA_GetCounterUsageType = (GPA_GetCounterUsageTypePtrType)dlsym(h, "GPA_GetCounterUsageType");
|
||||
GPA_GetDataTypeAsStr = (GPA_GetDataTypeAsStrPtrType)dlsym(h, "GPA_GetDataTypeAsStr");
|
||||
GPA_GetUsageTypeAsStr = (GPA_GetUsageTypeAsStrPtrType)dlsym(h, "GPA_GetUsageTypeAsStr");
|
||||
GPA_GetStatusAsStr = (GPA_GetStatusAsStrPtrType)dlsym(h, "GPA_GetStatusAsStr");
|
||||
GPA_EnableCounter = (GPA_EnableCounterPtrType)dlsym(h, "GPA_EnableCounter");
|
||||
GPA_DisableCounter = (GPA_DisableCounterPtrType)dlsym(h, "GPA_DisableCounter");
|
||||
GPA_GetEnabledCount = (GPA_GetEnabledCountPtrType)dlsym(h, "GPA_GetEnabledCount");
|
||||
GPA_GetEnabledIndex = (GPA_GetEnabledIndexPtrType)dlsym(h, "GPA_GetEnabledIndex");
|
||||
GPA_IsCounterEnabled = (GPA_IsCounterEnabledPtrType)dlsym(h, "GPA_IsCounterEnabled");
|
||||
GPA_EnableCounterStr = (GPA_EnableCounterStrPtrType)dlsym(h, "GPA_EnableCounterStr");
|
||||
GPA_DisableCounterStr = (GPA_DisableCounterStrPtrType)dlsym(h, "GPA_DisableCounterStr");
|
||||
GPA_EnableAllCounters = (GPA_EnableAllCountersPtrType)dlsym(h, "GPA_EnableAllCounters");
|
||||
GPA_DisableAllCounters = (GPA_DisableAllCountersPtrType)dlsym(h, "GPA_DisableAllCounters");
|
||||
GPA_GetCounterIndex = (GPA_GetCounterIndexPtrType)dlsym(h, "GPA_GetCounterIndex");
|
||||
GPA_GetPassCount = (GPA_GetPassCountPtrType)dlsym(h, "GPA_GetPassCount");
|
||||
GPA_BeginSession = (GPA_BeginSessionPtrType)dlsym(h, "GPA_BeginSession");
|
||||
GPA_EndSession = (GPA_EndSessionPtrType)dlsym(h, "GPA_EndSession");
|
||||
GPA_BeginPass = (GPA_BeginPassPtrType)dlsym(h, "GPA_BeginPass");
|
||||
GPA_EndPass = (GPA_EndPassPtrType)dlsym(h, "GPA_EndPass");
|
||||
GPA_BeginSample = (GPA_BeginSamplePtrType)dlsym(h, "GPA_BeginSample");
|
||||
GPA_EndSample = (GPA_EndSamplePtrType)dlsym(h, "GPA_EndSample");
|
||||
GPA_GetSampleCount = (GPA_GetSampleCountPtrType)dlsym(h, "GPA_GetSampleCount");
|
||||
GPA_IsSampleReady = (GPA_IsSampleReadyPtrType)dlsym(h, "GPA_IsSampleReady");
|
||||
GPA_IsSessionReady = (GPA_IsSessionReadyPtrType)dlsym(h, "GPA_IsSessionReady");
|
||||
GPA_GetSampleUInt64 = (GPA_GetSampleUInt64PtrType)dlsym(h, "GPA_GetSampleUInt64");
|
||||
GPA_GetSampleUInt32 = (GPA_GetSampleUInt32PtrType)dlsym(h, "GPA_GetSampleUInt32");
|
||||
GPA_GetSampleFloat32 = (GPA_GetSampleFloat32PtrType)dlsym(h, "GPA_GetSampleFloat32");
|
||||
GPA_GetSampleFloat64 = (GPA_GetSampleFloat64PtrType)dlsym(h, "GPA_GetSampleFloat64");
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char* getGPAError(GPA_Status status)
|
||||
{
|
||||
switch(status)
|
||||
{
|
||||
case GPA_STATUS_OK: return "GPA_STATUS_OK";
|
||||
case GPA_STATUS_ERROR_NULL_POINTER: return "GPA_STATUS_ERROR_NULL_POINTER";
|
||||
case GPA_STATUS_ERROR_COUNTERS_NOT_OPEN: return "GPA_STATUS_ERROR_COUNTERS_NOT_OPEN";
|
||||
case GPA_STATUS_ERROR_COUNTERS_ALREADY_OPEN: return "GPA_STATUS_ERROR_COUNTERS_ALREADY_OPEN";
|
||||
case GPA_STATUS_ERROR_INDEX_OUT_OF_RANGE: return "GPA_STATUS_ERROR_INDEX_OUT_OF_RANGE";
|
||||
case GPA_STATUS_ERROR_NOT_FOUND: return "GPA_STATUS_ERROR_NOT_FOUND";
|
||||
case GPA_STATUS_ERROR_ALREADY_ENABLED: return "GPA_STATUS_ERROR_ALREADY_ENABLED";
|
||||
case GPA_STATUS_ERROR_NO_COUNTERS_ENABLED: return "GPA_STATUS_ERROR_NO_COUNTERS_ENABLED";
|
||||
case GPA_STATUS_ERROR_NOT_ENABLED: return "GPA_STATUS_ERROR_NOT_ENABLED";
|
||||
case GPA_STATUS_ERROR_SAMPLING_NOT_STARTED: return "GPA_STATUS_ERROR_SAMPLING_NOT_STARTED";
|
||||
case GPA_STATUS_ERROR_SAMPLING_ALREADY_STARTED: return "GPA_STATUS_ERROR_SAMPLING_ALREADY_STARTED";
|
||||
case GPA_STATUS_ERROR_SAMPLING_NOT_ENDED: return "GPA_STATUS_ERROR_SAMPLING_NOT_ENDED";
|
||||
case GPA_STATUS_ERROR_NOT_ENOUGH_PASSES: return "GPA_STATUS_ERROR_NOT_ENOUGH_PASSES";
|
||||
case GPA_STATUS_ERROR_PASS_NOT_ENDED: return "GPA_STATUS_ERROR_PASS_NOT_ENDED";
|
||||
case GPA_STATUS_ERROR_PASS_NOT_STARTED: return "GPA_STATUS_ERROR_PASS_NOT_STARTED";
|
||||
case GPA_STATUS_ERROR_PASS_ALREADY_STARTED: return "GPA_STATUS_ERROR_PASS_ALREADY_STARTED";
|
||||
case GPA_STATUS_ERROR_SAMPLE_NOT_STARTED: return "GPA_STATUS_ERROR_SAMPLE_NOT_STARTED";
|
||||
case GPA_STATUS_ERROR_SAMPLE_ALREADY_STARTED: return "GPA_STATUS_ERROR_SAMPLE_ALREADY_STARTED";
|
||||
case GPA_STATUS_ERROR_SAMPLE_NOT_ENDED: return "GPA_STATUS_ERROR_SAMPLE_NOT_ENDED";
|
||||
case GPA_STATUS_ERROR_CANNOT_CHANGE_COUNTERS_WHEN_SAMPLING: return "GPA_STATUS_ERROR_CANNOT_CHANGE_COUNTERS_WHEN_SAMPLING";
|
||||
case GPA_STATUS_ERROR_SESSION_NOT_FOUND: return "GPA_STATUS_ERROR_SESSION_NOT_FOUND";
|
||||
case GPA_STATUS_ERROR_SAMPLE_NOT_FOUND: return "GPA_STATUS_ERROR_SAMPLE_NOT_FOUND";
|
||||
case GPA_STATUS_ERROR_SAMPLE_NOT_FOUND_IN_ALL_PASSES: return "GPA_STATUS_ERROR_SAMPLE_NOT_FOUND_IN_ALL_PASSES";
|
||||
case GPA_STATUS_ERROR_COUNTER_NOT_OF_SPECIFIED_TYPE: return "GPA_STATUS_ERROR_COUNTER_NOT_OF_SPECIFIED_TYPE";
|
||||
case GPA_STATUS_ERROR_READING_COUNTER_RESULT: return "GPA_STATUS_ERROR_READING_COUNTER_RESULT";
|
||||
case GPA_STATUS_ERROR_VARIABLE_NUMBER_OF_SAMPLES_IN_PASSES: return "GPA_STATUS_ERROR_VARIABLE_NUMBER_OF_SAMPLES_IN_PASSES";
|
||||
case GPA_STATUS_ERROR_FAILED: return "GPA_STATUS_ERROR_FAILED";
|
||||
case GPA_STATUS_ERROR_HARDWARE_NOT_SUPPORTED: return "GPA_STATUS_ERROR_HARDWARE_NOT_SUPPORTED";
|
||||
default: return "GPA_UNKNOW_ERROR";
|
||||
}
|
||||
}
|
||||
66
gpuperf/include/gpaload.h
Normal file
66
gpuperf/include/gpaload.h
Normal file
@ -0,0 +1,66 @@
|
||||
#ifndef _GPALOAD_H_NOU_
|
||||
#define _GPALOAD_H_NOU_
|
||||
|
||||
#include <GPUPerfAPI.h>
|
||||
#include <GPUPerfAPIFunctionTypes.h>
|
||||
#include <dlfcn.h>
|
||||
|
||||
#define GPA_FUNCTION_PREFIX( f ) extern f ## PtrType f;
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_Initialize )
|
||||
GPA_FUNCTION_PREFIX( GPA_Destroy )
|
||||
|
||||
// Context
|
||||
GPA_FUNCTION_PREFIX( GPA_OpenContext )
|
||||
GPA_FUNCTION_PREFIX( GPA_CloseContext )
|
||||
GPA_FUNCTION_PREFIX( GPA_SelectContext )
|
||||
|
||||
// Counter Interrogation
|
||||
GPA_FUNCTION_PREFIX( GPA_GetNumCounters )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterName )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterDescription )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterDataType )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterUsageType )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetDataTypeAsStr )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetUsageTypeAsStr )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetStatusAsStr )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_EnableCounter )
|
||||
GPA_FUNCTION_PREFIX( GPA_DisableCounter )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetEnabledCount )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetEnabledIndex )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_IsCounterEnabled )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_EnableCounterStr )
|
||||
GPA_FUNCTION_PREFIX( GPA_DisableCounterStr )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_EnableAllCounters )
|
||||
GPA_FUNCTION_PREFIX( GPA_DisableAllCounters )
|
||||
GPA_FUNCTION_PREFIX( GPA_GetCounterIndex )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_GetPassCount )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_BeginSession )
|
||||
GPA_FUNCTION_PREFIX( GPA_EndSession )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_BeginPass )
|
||||
GPA_FUNCTION_PREFIX( GPA_EndPass )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_BeginSample )
|
||||
GPA_FUNCTION_PREFIX( GPA_EndSample )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleCount )
|
||||
|
||||
GPA_FUNCTION_PREFIX( GPA_IsSampleReady)
|
||||
GPA_FUNCTION_PREFIX( GPA_IsSessionReady)
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleUInt64)
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleUInt32)
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleFloat32)
|
||||
GPA_FUNCTION_PREFIX( GPA_GetSampleFloat64)
|
||||
|
||||
|
||||
int loadGPAFunc();
|
||||
const char* getGPAError(GPA_Status status);
|
||||
|
||||
#endif // _GPALOAD_H_NOU_
|
||||
BIN
gpuperf/lib/Linx64/libGPUPerfAPICL.so
Executable file
BIN
gpuperf/lib/Linx64/libGPUPerfAPICL.so
Executable file
Binary file not shown.
BIN
gpuperf/lib/Linx64/libGPUPerfAPIGL.so
Executable file
BIN
gpuperf/lib/Linx64/libGPUPerfAPIGL.so
Executable file
Binary file not shown.
BIN
gpuperf/lib/Linx86/libGPUPerfAPICL32.so
Executable file
BIN
gpuperf/lib/Linx86/libGPUPerfAPICL32.so
Executable file
Binary file not shown.
BIN
gpuperf/lib/Linx86/libGPUPerfAPIGL32.so
Executable file
BIN
gpuperf/lib/Linx86/libGPUPerfAPIGL32.so
Executable file
Binary file not shown.
@ -13,8 +13,8 @@ __constant uint colors[] = {0,0,0,0, 255,255,255,0, 255,0,0,0, 0,255,0,0, 0,0,25
|
||||
_event transfer_func(_state current_state, _time current_time, _event *event_vector)
|
||||
{
|
||||
_event new_event;
|
||||
if(current_state >= 1.0f && (DEVS_truecount() == 3 || DEVS_truecount() == 2)){ new_event.time = 100; new_event.state = 1; return new_event; }
|
||||
if(current_state == 0.0f && (DEVS_truecount() == 3)){ new_event.time = 100; new_event.state = 1; return new_event; }
|
||||
if(true){ new_event.time = 100; new_event.state = 0; return new_event; }
|
||||
if(current_state >= 1.0f && (DEVS_truecount() == 3 || DEVS_truecount() == 2)){ new_event.time = 100.0f; new_event.state = 1.0f; return new_event; }
|
||||
if(current_state == 0.0f && (DEVS_truecount() == 3)){ new_event.time = 100.0f; new_event.state = 1.0f; return new_event; }
|
||||
if(true){ new_event.time = 100.0f; new_event.state = 0.0f; return new_event; }
|
||||
}
|
||||
|
||||
|
||||
@ -1,6 +1,8 @@
|
||||
#include "machine.h"
|
||||
#include "cellspace.h"
|
||||
#include <CL/cl_gl.h>
|
||||
#include "gpuperf/include/gpaload.h"
|
||||
|
||||
/**
|
||||
Konstruktor ktory vytvory context s danymi zariadeniami
|
||||
@param platform_index cislo platformy ktora sa ma pouzit
|
||||
@ -41,6 +43,12 @@ pokracovanie konstruktora so spolocnym kodom.
|
||||
void Machine::init(cl_context_properties *cl_properties, cl_device_v &devices)
|
||||
{
|
||||
cl_int err_code;
|
||||
GPA_Status gpa_stat;
|
||||
if(!loadGPAFunc())
|
||||
{
|
||||
gpa_stat = GPA_Initialize();
|
||||
if(gpa_stat != GPA_STATUS_OK)cout << "chyb pri inicializacii GPA" << endl;
|
||||
}
|
||||
if(devices.empty())context = clCreateContextFromType(cl_properties, CL_DEVICE_TYPE_ALL, NULL, NULL, &err_code);
|
||||
else context = clCreateContext(cl_properties, devices.size(), &devices[0], NULL, NULL, &err_code);
|
||||
|
||||
@ -56,6 +64,7 @@ void Machine::init(cl_context_properties *cl_properties, cl_device_v &devices)
|
||||
for(cl_device_v::iterator i = device.begin(); i != device.end();i++)
|
||||
{
|
||||
queues.push_back(clCreateCommandQueue(context, *i, NULL, &err_code));
|
||||
cout << "OpenContext " << " " << getGPAError(GPA_OpenContext(queues.back())) << endl;
|
||||
if(err_code)
|
||||
{
|
||||
cerr << "Nepodarilo sa vytvorit OpenCL prikazove fronty "; clGetError(err_code);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user