void operator()( const tbb::blocked_range<size_t>& r) const
{
for( std::size_t i = r.begin(), e = r.end(); i != e; ++i)
std::for_each( view_.row_begin(i), view_.row_end(i), f_);
}
void operator()( const tbb::blocked_range<int> &r ) const {
for (int i = r.begin(); i != r.end(); ++i) {
sums.local() += 1 ;
}
}
void operator()(const tbb::blocked_range<size_t>& r) {
pReduce_->operator()(r.begin(), r.end());
}
void operator()( const tbb::blocked_range<size_t>& r ) const
{
int begin = (int)r.begin(); //! capture lower range number for this chunk
int end = (int)r.end(); //! capture upper range number for this chunk
UpdateState(m_source, m_dest, begin, end);
}
void operator()( const tbb::blocked_range<int>& range ) const {
Universe::Rectangle area(0, range.begin(), u_.UniverseWidth-1, range.size());
u_.UpdateStress(area);
}
void
SoftBody::MeshProcessor::operator ()(const tbb::blocked_range<uint32_t> r) const
{
mBody.updateMesh(r.begin(), r.end());
}
void ParallelParticleSystemUpdate::operator() (const tbb::blocked_range<int>& r) const
{
float currentTime = eagle.getTimer()->getPassedTimeSeconds();
float frameTime = *m_particleEmitter->m_frameTime;
float frictionEffect = 1.0f - (1.0f - m_particleEmitter->m_frictionFactor) * (frameTime);
float aliveParticleAlphaDecrement = m_particleEmitter->m_alphaDecrement * (frameTime);
float deadParticleAlphaDecrement = (m_particleEmitter->m_alphaDecrement + m_particleEmitter->m_removalAlphaDecrement) * (frameTime);
for(int i = r.begin(); i != r.end(); ++i)
{
if(!m_particleList[i].enabled)
{
continue;
}
m_particleEmitter->aliveParticleCount++;
//float lv = sqrt(m_particleList[i].m_velocityX * m_particleList[i].m_velocityX + m_particleList[i].m_velocityY * m_particleList[i].m_velocityY);
/*float theta = atan2(m_particleList[i].m_velocityY, m_particleList[i].m_velocityX) + ((float)(math.random(0, 2) - 1)) * particleEmitter->m_noise;
m_particleList[i].m_velocityX = cos(theta) * lv;
m_particleList[i].m_velocityY = sin(theta) * lv;*/
m_particleList[i].velocityX += ((float)(math.random(0, 2) - 1)) * m_particleEmitter->m_noise;
m_particleList[i].velocityY += ((float)(math.random(0, 2) - 1)) * m_particleEmitter->m_noise;
m_particleList[i].x += m_particleList[i].velocityX * (frameTime);
m_particleList[i].y += m_particleList[i].velocityY * (frameTime);
m_particleList[i].velocityX *= frictionEffect;
m_particleList[i].velocityY *= frictionEffect;
//m_particleList[i].z += m_particleList[i].speedZ;
m_particleList[i].velocityX += m_particleList[i].accelerationX * (frameTime);
m_particleList[i].velocityY += m_particleList[i].accelerationY * (frameTime);
//colors[i].a = math.abs(colors[i].a);
if(m_particleList[i].quickFade)
{
m_particleList[i].color.a -= deadParticleAlphaDecrement;
}
else
{
m_particleList[i].color.a -= aliveParticleAlphaDecrement;
}
//if((m_particleList[i].quickFade && m_particleList[i].color.a < 10) || m_particleList[i].color.a < 10)
if(m_particleList[i].color.a < EAGLE_PARTICLE_SYSTEM_MINIMUM_PARTICLE_ALPHA)
{
m_particleList[i].enabled = 0;
m_particleList[i].color.a = 0;
m_particleEmitter->m_inactiveParticleListTopIndex++;
m_particleEmitter->m_inactiveParticleList[m_particleEmitter->m_inactiveParticleListTopIndex] = i;
continue;
}
else if(currentTime - m_particleList[i].creationTime > m_particleEmitter->m_lifespan)
{
m_particleList[i].quickFade = 1;
continue;
}
else
{
int deltaX = m_particleList[i].x - m_particleEmitter->m_position.x;
int deltaY = m_particleList[i].y - m_particleEmitter->m_position.y;
if((deltaX) * (deltaX) + (deltaY) * (deltaY) > m_particleEmitter->m_maximumDistance * m_particleEmitter->m_maximumDistance)
{
m_particleList[i].quickFade = 1;
continue;
}
}
}
}
void operator()(const tbb::blocked_range<size_t>& r) const {
for (size_t i=r.begin();i!=r.end();++i)
_tasks[i]();
}
void operator()(const tbb::blocked_range<size_t>& r) const
{
checkPoints(r.begin(), r.end());
}
void operator ()(const tbb::blocked_range<int>& range) const
{
body->operator()(Range(range.begin(), range.end()));
}
/** Increments counter once for each iteration in the iteration space. */
void operator()( tbb::blocked_range<size_t>& range ) const {
for( size_t i=range.begin(); i!=range.end(); ++i ) {
typename C::mutex_type::ScopedLock lock(counter.mutex);
counter.value = counter.value+1;
}
}
void DoLerpParallel(const tbb::blocked_range<size_t>& r, const std::tr1::function<void(void*, const void*, const void*, float, size_t)>& func, void* dest, const void* source1, const void* source2, float alpha)
{
size_t offset = r.begin()*STRIDE;
size_t size = r.size()*STRIDE;
func(reinterpret_cast<s8*>(dest) + offset, reinterpret_cast<const s8*>(source1) + offset, reinterpret_cast<const s8*>(source2) + offset, alpha, size);
}
void operator()(const tbb::blocked_range<size_t> &range) const {
for (size_t i = range.begin(); i != range.end(); ++i) {
(*f)(p[i]);
}
//for_each(range.begin(), range.end(), *f);
}
void operator()( const tbb::blocked_range<int>& range ) const {
for( int i=range.begin(); i!=range.end(); ++i )
Op::apply(my_table,i);
}
void DoShuffleParallel(const tbb::blocked_range<size_t>& r, const std::tr1::function<void(void*, const void*, size_t, const u8, const u8, const u8, const u8)>& func, void* dest, const void* source, const u8 red, const u8 green, const u8 blue, const u8 alpha)
{
size_t offset = r.begin()*STRIDE;
size_t size = r.size()*STRIDE;
func(reinterpret_cast<s8*>(dest) + offset, reinterpret_cast<const s8*>(source) + offset, size, red, green, blue, alpha);
}
/*
* The actual work is implemented into operator(), but the method has a body const.
* It means we cannot change object members. They can be passed as raw pointers,
* or marked mutable.
*/
void operator() (const tbb::blocked_range<int>& range) const {
for (int i = range.begin(); i < range.end(); i++) {
m_data[i] = i;
}
}
void operator()( const tbb::blocked_range<int>& r) const
{
for( int j = r.begin(); j < r.end(); ++j)
{
image::const_image_view_t::x_iterator top_it( src_.row_begin( std::max( j - 1, 0)));
image::const_image_view_t::x_iterator center_it( src_.row_begin( j));
image::const_image_view_t::x_iterator bottom_it( src_.row_begin( std::min( j + 1, (int) src_.height() - 1)));
image::image_view_t::x_iterator dst_it( dst_.row_begin( j));
image::pixel_t acc;
// first pixel
for( int k = 0; k < 3; ++k)
{
acc[k] = (*top_it)[k] * k_[0][0];
acc[k] += (*top_it)[k] * k_[0][1];
acc[k] += top_it[1][k] * k_[0][2];
acc[k] += (*center_it)[k] * k_[1][0];
acc[k] += (*center_it)[k] * k_[1][1];
acc[k] += center_it[1][k] * k_[1][2];
acc[k] += (*bottom_it)[k] * k_[2][0];
acc[k] += (*bottom_it)[k] * k_[2][1];
acc[k] += bottom_it[1][k] * k_[2][2];
acc[k] /= inv_sum_weights_;
}
*dst_it++ = acc;
++top_it;
++center_it;
++bottom_it;
// loop
for( int i = 1, e = src_.width() - 1; i < e; ++i)
{
for( int k = 0; k < 3; ++k)
{
acc[k] = top_it[-1][k] * k_[0][0];
acc[k] += ( *top_it)[k] * k_[0][1];
acc[k] += top_it[ 1][k] * k_[0][2];
acc[k] += center_it[-1][k] * k_[1][0];
acc[k] += ( *center_it)[k] * k_[1][1];
acc[k] += center_it[ 1][k] * k_[1][2];
acc[k] += bottom_it[-1][k] * k_[2][0];
acc[k] += ( *bottom_it)[k] * k_[2][1];
acc[k] += bottom_it[ 1][k] * k_[2][2];
acc[k] /= inv_sum_weights_;
}
*dst_it++ = acc;
++top_it;
++center_it;
++bottom_it;
}
// last pixel
for( int k = 0; k < 3; ++k)
{
acc[k] = top_it[-1][k] * k_[0][0];
acc[k] += ( *top_it)[k] * k_[0][1];
acc[k] += ( *top_it)[k] * k_[0][2];
acc[k] += center_it[-1][k] * k_[1][0];
acc[k] += ( *center_it)[k] * k_[1][1];
acc[k] += ( *center_it)[k] * k_[1][2];
acc[k] += bottom_it[-1][k] * k_[2][0];
acc[k] += ( *bottom_it)[k] * k_[2][1];
acc[k] += ( *bottom_it)[k] * k_[2][2];
acc[k] /= inv_sum_weights_;
}
*dst_it = acc;
}
}
// Note: we use <int> here instead of <long> in order to test for Quad 407676
void operator()( const tbb::blocked_range<int>& r ) const {
for( tbb::blocked_range<int>::const_iterator i=r.begin(); i!=r.end(); ++i )
++Array[i];
}
/** Increments counter once for each iteration in the iteration space. */
void operator()( tbb::blocked_range<size_t>& range ) const {
for( size_t i=range.begin(); i!=range.end(); ++i ) {
//! Every 8th access is a write access
bool write = (i%8)==7;
bool okay = true;
bool lock_kept = true;
if( (i/8)&1 ) {
// Try implicit acquire and explicit release
typename I::mutex_type::scoped_lock lock(invariant.mutex,write);
if( write ) {
long my_value = invariant.value[0];
invariant.update();
if( i%16==7 ) {
lock_kept = lock.downgrade_to_reader();
if( !lock_kept )
my_value = invariant.value[0] - 1;
okay = invariant.value_is(my_value+1);
}
} else {
okay = invariant.is_okay();
if( i%8==3 ) {
long my_value = invariant.value[0];
lock_kept = lock.upgrade_to_writer();
if( !lock_kept )
my_value = invariant.value[0];
invariant.update();
okay = invariant.value_is(my_value+1);
}
}
lock.release();
} else {
// Try explicit acquire and implicit release
typename I::mutex_type::scoped_lock lock;
lock.acquire(invariant.mutex,write);
if( write ) {
long my_value = invariant.value[0];
invariant.update();
if( i%16==7 ) {
lock_kept = lock.downgrade_to_reader();
if( !lock_kept )
my_value = invariant.value[0] - 1;
okay = invariant.value_is(my_value+1);
}
} else {
okay = invariant.is_okay();
if( i%8==3 ) {
long my_value = invariant.value[0];
lock_kept = lock.upgrade_to_writer();
if( !lock_kept )
my_value = invariant.value[0];
invariant.update();
okay = invariant.value_is(my_value+1);
}
}
}
if( !okay ) {
REPORT( "ERROR for %s at %ld: %s %s %s %s\n",invariant.mutex_name, long(i),
write?"write,":"read,", write?(i%16==7?"downgrade,":""):(i%8==3?"upgrade,":""),
lock_kept?"lock kept,":"lock not kept,", (i/8)&1?"imp/exp":"exp/imp" );
}
}
}
void operator()( const tbb::blocked_range<int>& y_range ) const {
u_.UpdateVelocity(Universe::Rectangle(1,y_range.begin(),u_.UniverseWidth-1,y_range.size()));
}
void operator()( const tbb::blocked_range<size_t>& r) const
{
for( std::size_t i = r.begin(), e = r.end(); i != e; ++i)
std::copy( src_.row_begin(i), src_.row_end(i), dst_.row_begin(i));
}
void operator() ( const tbb::blocked_range<int>& range ) const {
for ( int i = range.begin(); i != range.end(); ++i ) {
output[i] = (input[i-1]+input[i]+input[i+1])*(1/3.f);
}
}
void operator()( const tbb::blocked_range<size_t> &r ) const
{
for( size_t x=r.begin(); x<r.end(); x++ ) {
Body( x );
}
}
void operator()(tbb::blocked_range<long> const & range) {
for (auto i = range.begin(); i != range.end(); ++i) {
auto const x = (i - 0.5) * delta;
sum += 1.0 / (1.0 + x * x);
}
}
void operator()( tbb::blocked_range<size_t>& range ) const {
typename C::mutex_type::scoped_lock lock(counter.mutex);
recurse_till( range.begin(), range.end() );
}
ValueType operator() ( const tbb::blocked_range<ValueType*>& r, ValueType value ) const {
for ( ValueType* pv = r.begin(); pv != r.end(); ++pv )
value += *pv;
return value;
}
void operator()( const tbb::blocked_range<int> &r ) const {
for (int i = r.begin(); i != r.end(); ++i)
test_helper<T>::sum( sums.local(), 1 );
}
/**
* @brief operator () This is called from the TBB stye of code
* @param r The range to compute the values
*/
void operator()(const tbb::blocked_range<size_t>& r) const
{
generate(r.begin(), r.end());
}
void operator()(const tbb::blocked_range<int64_t>& r) const
{
compute(r.begin(), r.end());
}