forked from lijiext/lammps
156 lines
3.9 KiB
C++
156 lines
3.9 KiB
C++
// -------------------------------------------------------------
|
|
// cuDPP -- CUDA Data Parallel Primitives library
|
|
// -------------------------------------------------------------
|
|
// $Revision: 3572$
|
|
// $Date: 2007-11-19 13:58:06 +0000 (Mon, 19 Nov 2007) $
|
|
// -------------------------------------------------------------
|
|
// This source code is distributed under the terms of license.txt
|
|
// in the root directory of this source distribution.
|
|
// -------------------------------------------------------------
|
|
#include "cudpp.h"
|
|
#include "cudpp_plan.h"
|
|
#include "cudpp_plan_manager.h"
|
|
#include "cudpp_maximal_launch.h"
|
|
|
|
typedef void* KernelPointer;
|
|
|
|
extern "C" size_t getNumCTAs(KernelPointer kernel)
|
|
{
|
|
return CUDPPPlanManager::numCTAs(kernel);
|
|
}
|
|
extern "C" void compNumCTAs(KernelPointer kernel, size_t bytesDynamicSharedMem, size_t threadsPerBlock)
|
|
{
|
|
CUDPPPlanManager::computeNumCTAs(kernel, bytesDynamicSharedMem, threadsPerBlock);
|
|
}
|
|
|
|
//! @internal Instantiate the plan manager singleton object
|
|
void CUDPPPlanManager::Instantiate()
|
|
{
|
|
if (NULL == m_instance)
|
|
m_instance = new CUDPPPlanManager;
|
|
}
|
|
|
|
//! @internal Destroy the plan manager singleton object
|
|
void CUDPPPlanManager::Destroy()
|
|
{
|
|
if (NULL != m_instance)
|
|
{
|
|
delete m_instance;
|
|
m_instance = NULL;
|
|
}
|
|
}
|
|
|
|
/** @brief Plan Manager destructor
|
|
* Destroys all plans as well as the plan manager.
|
|
*/
|
|
CUDPPPlanManager::~CUDPPPlanManager()
|
|
{
|
|
std::map<CUDPPHandle,CUDPPPlan*>::iterator it;
|
|
|
|
for (it = m_instance->plans.begin(); it != m_instance->plans.end(); it++)
|
|
{
|
|
CUDPPPlan* plan = it->second;
|
|
delete plan;
|
|
plan = NULL;
|
|
}
|
|
m_instance->plans.clear();
|
|
|
|
m_instance->numCTAsTable.clear();
|
|
}
|
|
|
|
/** @brief Add a plan to the plan manager
|
|
*
|
|
* @returns a valid CUDPPHandle if the plan was successfully added, or
|
|
* CUDPP_INVALID_HANDLE otherwise
|
|
* @param[in] plan The plan to add
|
|
*/
|
|
CUDPPHandle CUDPPPlanManager::AddPlan(CUDPPPlan* plan)
|
|
{
|
|
Instantiate();
|
|
|
|
std::pair<std::map<CUDPPHandle, CUDPPPlan*>::iterator, bool> ret;
|
|
|
|
CUDPPHandle handle = (CUDPPHandle)m_instance->plans.size();
|
|
ret = m_instance->plans.insert(std::pair<CUDPPHandle,CUDPPPlan*>(handle, plan));
|
|
if (ret.second == true)
|
|
return handle;
|
|
else
|
|
return CUDPP_INVALID_HANDLE;
|
|
}
|
|
|
|
/** @brief Remove a plan from the plan manager
|
|
*
|
|
* @returns true if the plan was successfully removed, false otherwise
|
|
* @param[in] handle The handle to the plan to remove
|
|
*/
|
|
bool CUDPPPlanManager::RemovePlan(CUDPPHandle handle)
|
|
{
|
|
if (m_instance == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::map<CUDPPHandle,CUDPPPlan*>::iterator it;
|
|
it = m_instance->plans.find(handle);
|
|
|
|
if (it != m_instance->plans.end())
|
|
{
|
|
CUDPPPlan* plan = it->second;
|
|
delete plan;
|
|
plan = NULL;
|
|
m_instance->plans.erase(it);
|
|
|
|
if (0 == m_instance->plans.size())
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/** @brief Get a plan from the plan manager by handle
|
|
*
|
|
* @returns A pointer to the plan if found, or NULL otherwise
|
|
* @param handle The handle to the requested plan
|
|
*/
|
|
CUDPPPlan* CUDPPPlanManager::GetPlan(CUDPPHandle handle)
|
|
{
|
|
if (m_instance == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
std::map<CUDPPHandle, CUDPPPlan*>::iterator it;
|
|
it = m_instance->plans.find(handle);
|
|
if (it != m_instance->plans.end())
|
|
{
|
|
return it->second;
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
size_t CUDPPPlanManager::numCTAs(KernelPointer kernel)
|
|
{
|
|
if (m_instance == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return m_instance->numCTAsTable[kernel];
|
|
}
|
|
|
|
void CUDPPPlanManager::computeNumCTAs(KernelPointer kernel, size_t bytesDynamicSharedMem, size_t threadsPerBlock)
|
|
{
|
|
Instantiate();
|
|
|
|
m_instance->numCTAsTable[kernel] = maxBlocks(kernel, bytesDynamicSharedMem, threadsPerBlock);
|
|
}
|