mirror of
https://github.com/bulletphysics/bullet3
synced 2024-12-14 13:50:04 +00:00
c0c4c8ba3f
remove btMultiSapBroadphase.* make collisionFilterGroup/collisionFilterMark int (instead of short int)
337 lines
7.5 KiB
C++
337 lines
7.5 KiB
C++
/*
|
|
Bullet Continuous Collision Detection and Physics Library
|
|
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
|
|
|
|
This software is provided 'as-is', without any express or implied warranty.
|
|
In no event will the authors be held liable for any damages arising from the use of this software.
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it freely,
|
|
subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
|
|
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
*/
|
|
|
|
#include <stdio.h> //printf debugging
|
|
#include <algorithm>
|
|
|
|
|
|
// choose threading providers:
|
|
#if BT_USE_TBB
|
|
#define USE_TBB 1 // use Intel Threading Building Blocks for thread management
|
|
#endif
|
|
|
|
#if BT_USE_PPL
|
|
#define USE_PPL 1 // use Microsoft Parallel Patterns Library (installed with Visual Studio 2010 and later)
|
|
#endif // BT_USE_PPL
|
|
|
|
#if BT_USE_OPENMP
|
|
#define USE_OPENMP 1 // use OpenMP (also need to change compiler options for OpenMP support)
|
|
#endif
|
|
|
|
|
|
#if USE_OPENMP
|
|
|
|
#include <omp.h>
|
|
|
|
#endif // #if USE_OPENMP
|
|
|
|
|
|
#if USE_PPL
|
|
|
|
#include <ppl.h> // if you get a compile error here, check whether your version of Visual Studio includes PPL
|
|
// Visual Studio 2010 and later should come with it
|
|
#include <concrtrm.h> // for GetProcessorCount()
|
|
#endif // #if USE_PPL
|
|
|
|
|
|
#if USE_TBB
|
|
|
|
#define __TBB_NO_IMPLICIT_LINKAGE 1
|
|
#include <tbb/tbb.h>
|
|
#include <tbb/task_scheduler_init.h>
|
|
#include <tbb/parallel_for.h>
|
|
#include <tbb/blocked_range.h>
|
|
|
|
#endif // #if USE_TBB
|
|
|
|
|
|
|
|
class TaskManager
|
|
{
|
|
public:
|
|
enum Api
|
|
{
|
|
apiNone,
|
|
apiOpenMP,
|
|
apiTbb,
|
|
apiPpl,
|
|
apiCount
|
|
};
|
|
static const char* getApiName( Api api )
|
|
{
|
|
switch ( api )
|
|
{
|
|
case apiNone: return "None";
|
|
case apiOpenMP: return "OpenMP";
|
|
case apiTbb: return "Intel TBB";
|
|
case apiPpl: return "MS PPL";
|
|
default: return "unknown";
|
|
}
|
|
}
|
|
|
|
TaskManager()
|
|
{
|
|
m_api = apiNone;
|
|
m_numThreads = 0;
|
|
#if USE_TBB
|
|
m_tbbSchedulerInit = NULL;
|
|
#endif // #if USE_TBB
|
|
}
|
|
|
|
Api getApi() const
|
|
{
|
|
return m_api;
|
|
}
|
|
|
|
bool isSupported( Api api ) const
|
|
{
|
|
#if USE_OPENMP
|
|
if ( api == apiOpenMP )
|
|
{
|
|
return true;
|
|
}
|
|
#endif
|
|
#if USE_TBB
|
|
if ( api == apiTbb )
|
|
{
|
|
return true;
|
|
}
|
|
#endif
|
|
#if USE_PPL
|
|
if ( api == apiPpl )
|
|
{
|
|
return true;
|
|
}
|
|
#endif
|
|
// apiNone is always "supported"
|
|
return api == apiNone;
|
|
}
|
|
|
|
void setApi( Api api )
|
|
{
|
|
if (isSupported(api))
|
|
{
|
|
m_api = api;
|
|
}
|
|
else
|
|
{
|
|
// no compile time support for selected API, fallback to "none"
|
|
m_api = apiNone;
|
|
}
|
|
}
|
|
|
|
static int getMaxNumThreads()
|
|
{
|
|
#if USE_OPENMP
|
|
return omp_get_max_threads();
|
|
#elif USE_PPL
|
|
return concurrency::GetProcessorCount();
|
|
#elif USE_TBB
|
|
return tbb::task_scheduler_init::default_num_threads();
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
int getNumThreads() const
|
|
{
|
|
return m_numThreads;
|
|
}
|
|
|
|
int setNumThreads( int numThreads )
|
|
{
|
|
m_numThreads = ( std::max )( 1, numThreads );
|
|
|
|
#if USE_OPENMP
|
|
omp_set_num_threads( m_numThreads );
|
|
#endif
|
|
|
|
#if USE_PPL
|
|
{
|
|
using namespace concurrency;
|
|
if ( CurrentScheduler::Id() != -1 )
|
|
{
|
|
CurrentScheduler::Detach();
|
|
}
|
|
SchedulerPolicy policy;
|
|
policy.SetConcurrencyLimits( m_numThreads, m_numThreads );
|
|
CurrentScheduler::Create( policy );
|
|
}
|
|
#endif
|
|
|
|
#if USE_TBB
|
|
if ( m_tbbSchedulerInit )
|
|
{
|
|
delete m_tbbSchedulerInit;
|
|
m_tbbSchedulerInit = NULL;
|
|
}
|
|
m_tbbSchedulerInit = new tbb::task_scheduler_init( m_numThreads );
|
|
#endif
|
|
return m_numThreads;
|
|
}
|
|
|
|
void init()
|
|
{
|
|
if (m_numThreads == 0)
|
|
{
|
|
#if USE_PPL
|
|
setApi( apiPpl );
|
|
#endif
|
|
#if USE_TBB
|
|
setApi( apiTbb );
|
|
#endif
|
|
#if USE_OPENMP
|
|
setApi( apiOpenMP );
|
|
#endif
|
|
setNumThreads(getMaxNumThreads());
|
|
}
|
|
else
|
|
{
|
|
setNumThreads(m_numThreads);
|
|
}
|
|
}
|
|
|
|
void shutdown()
|
|
{
|
|
#if USE_TBB
|
|
if ( m_tbbSchedulerInit )
|
|
{
|
|
delete m_tbbSchedulerInit;
|
|
m_tbbSchedulerInit = NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private:
|
|
Api m_api;
|
|
int m_numThreads;
|
|
#if USE_TBB
|
|
tbb::task_scheduler_init* m_tbbSchedulerInit;
|
|
#endif // #if USE_TBB
|
|
};
|
|
|
|
extern TaskManager gTaskMgr;
|
|
|
|
|
|
inline static void initTaskScheduler()
|
|
{
|
|
gTaskMgr.init();
|
|
}
|
|
|
|
inline static void cleanupTaskScheduler()
|
|
{
|
|
gTaskMgr.shutdown();
|
|
}
|
|
|
|
|
|
#if USE_TBB
|
|
///
|
|
/// TbbBodyAdapter -- Converts a body object that implements the
|
|
/// "forLoop(int iBegin, int iEnd) const" function
|
|
/// into a TBB compatible object that takes a tbb::blocked_range<int> type.
|
|
///
|
|
template <class TBody>
|
|
struct TbbBodyAdapter
|
|
{
|
|
const TBody* mBody;
|
|
|
|
void operator()( const tbb::blocked_range<int>& range ) const
|
|
{
|
|
mBody->forLoop( range.begin(), range.end() );
|
|
}
|
|
};
|
|
#endif // #if USE_TBB
|
|
|
|
#if USE_PPL
|
|
///
|
|
/// PplBodyAdapter -- Converts a body object that implements the
|
|
/// "forLoop(int iBegin, int iEnd) const" function
|
|
/// into a PPL compatible object that implements "void operator()( int ) const"
|
|
///
|
|
template <class TBody>
|
|
struct PplBodyAdapter
|
|
{
|
|
const TBody* mBody;
|
|
int mGrainSize;
|
|
int mIndexEnd;
|
|
|
|
void operator()( int i ) const
|
|
{
|
|
mBody->forLoop( i, (std::min)(i + mGrainSize, mIndexEnd) );
|
|
}
|
|
};
|
|
#endif // #if USE_PPL
|
|
|
|
|
|
///
|
|
/// parallelFor -- interface for submitting work expressed as a for loop to the worker threads
|
|
///
|
|
template <class TBody>
|
|
void parallelFor( int iBegin, int iEnd, int grainSize, const TBody& body )
|
|
{
|
|
#if USE_OPENMP
|
|
if ( gTaskMgr.getApi() == TaskManager::apiOpenMP )
|
|
{
|
|
#pragma omp parallel for schedule(static, 1)
|
|
for ( int i = iBegin; i < iEnd; i += grainSize )
|
|
{
|
|
body.forLoop( i, (std::min)( i + grainSize, iEnd ) );
|
|
}
|
|
return;
|
|
}
|
|
#endif // #if USE_OPENMP
|
|
|
|
#if USE_PPL
|
|
if ( gTaskMgr.getApi() == TaskManager::apiPpl )
|
|
{
|
|
// PPL dispatch
|
|
PplBodyAdapter<TBody> pplBody;
|
|
pplBody.mBody = &body;
|
|
pplBody.mGrainSize = grainSize;
|
|
pplBody.mIndexEnd = iEnd;
|
|
// note: MSVC 2010 doesn't support partitioner args, so avoid them
|
|
concurrency::parallel_for( iBegin,
|
|
iEnd,
|
|
grainSize,
|
|
pplBody
|
|
);
|
|
return;
|
|
}
|
|
#endif //#if USE_PPL
|
|
|
|
#if USE_TBB
|
|
if ( gTaskMgr.getApi() == TaskManager::apiTbb )
|
|
{
|
|
// TBB dispatch
|
|
TbbBodyAdapter<TBody> tbbBody;
|
|
tbbBody.mBody = &body;
|
|
tbb::parallel_for( tbb::blocked_range<int>( iBegin, iEnd, grainSize ),
|
|
tbbBody,
|
|
tbb::simple_partitioner()
|
|
);
|
|
return;
|
|
}
|
|
#endif // #if USE_TBB
|
|
|
|
{
|
|
// run on main thread
|
|
body.forLoop( iBegin, iEnd );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|