ResetEhGlobals( throwException, flog );

g_FedTasksCount = 0;

g_OuterParCalls = 0;

g_NestedPipelines = false;

g_TGCCancelled = 0;

if(!r.is_divisible()) return intptr_t(1);

range_type r2(r,tbb::split());

return CountSubranges(r) + CountSubranges(r2);

ResetGlobals();

g_ThrowException = false;

intptr_t outerCalls = NumSubranges(length, grain),

innerCalls = NumSubranges(inner_length, inner_grain),

maxExecuted = outerCalls * (innerCalls + 1);

tbb::parallel_for( range_type(0, length, grain), Body() );

ASSERT (g_CurExecuted == maxExecuted, "Wrong estimation of bodies invocation count");

return maxExecuted;

void operator()( const range_type& r ) const {

volatile count_type x = 0;

if(g_Master == Harness::CurrentTid()) g_MasterExecuted = true;

else g_NonMasterExecuted = true;

if( tbb::task::self().is_cancelled() ) ++g_TGCCancelled;

count_type end = r.end();

for( count_type i=r.begin(); i<end; ++i )

x += i;

}

ResetGlobals();

tbb::simple_partitioner p;

for( size_t i=0; i<10; ++i ) {

tbb::parallel_for( range_type(0, 0, 1), NoThrowParForBody() );

tbb::parallel_for( range_type(0, 0, 1), NoThrowParForBody(), p );

tbb::parallel_for( range_type(0, 128, 8), NoThrowParForBody() );

tbb::parallel_for( range_type(0, 128, 8), NoThrowParForBody(), p );

}

ParForBody m_Body;

void operator()( const range_type& r ) const { m_Body(r); }

SimpleParReduceBody() {}

SimpleParReduceBody( SimpleParReduceBody& left, tbb::split ) : m_Body(left.m_Body) {}

void join( SimpleParReduceBody& /*right*/ ) {}

Partitioner partitioner;

for( int i=0; i<2; ++i ) {

ResetGlobals();

TRY();

if( i==0 )

tbb::parallel_for( range_type(0, FLAT_RANGE, FLAT_GRAIN), ParForBody(), partitioner );

else {

SimpleParReduceBody<ParForBody> rb;

tbb::parallel_reduce( range_type(0, FLAT_RANGE, FLAT_GRAIN), rb, partitioner );

}

CATCH_AND_ASSERT();

// two cases: g_SolitaryException and !g_SolitaryException

// 1) g_SolitaryException: only one thread actually threw. There is only one context, so the exception

// (when caught) will cause that context to be cancelled. After this event, there may be one or

// more threads which are "in-flight", up to g_NumThreads, but no more will be started. The threads,

// when they start, if they see they are cancelled, TGCCancelled is incremented.

// 2) !g_SolitaryException: more than one thread can throw. The number of threads that actually

// threw is g_MasterExecutedThrow if only the master is allowed, else g_NonMasterExecutedThrow.

// Only one context, so TGCCancelled should be <= g_NumThreads.

//

// the reasoning is similar for nested algorithms in a single context (Test2).

//

// If a thread throws in a context, more than one subsequent task body may see the

// cancelled state (if they are scheduled before the state is propagated.) this is

// infrequent, but it occurs. So what was to be an assertion must be a remark.

ASSERT( g_TGCCancelled <= g_NumThreads, "Too many tasks ran after exception thrown");

if( g_TGCCancelled > g_NumThreads) REMARK( "Too many tasks ran after exception thrown (%d vs. %d)\n",

(int)g_TGCCancelled, (int)g_NumThreads);

ASSERT(g_CurExecuted <= g_ExecutedAtLastCatch + g_NumThreads, "Too many tasks survived exception");

if ( g_SolitaryException ) {

ASSERT(g_NumExceptionsCaught == 1, "No try_blocks in any body expected in this test");

ASSERT(g_NumExceptionsCaught == (g_ExceptionInMaster ? g_MasterExecutedThrow : g_NonMasterExecutedThrow),

"Not all throws were caught");

ASSERT(g_ExecutedAtFirstCatch == g_ExecutedAtLastCatch, "Too many exceptions occurred");

}

else {

ASSERT(g_NumExceptionsCaught >= 1, "No try blocks in any body expected in this test");

}

}

// The simple and auto partitioners should be const, but not the affinity partitioner.

TestParallelLoopAux<Body, const tbb::simple_partitioner >();

TestParallelLoopAux<Body, const tbb::auto_partitioner >();

#define __TBB_TEMPORARILY_DISABLED 1

#if !__TBB_TEMPORARILY_DISABLED

// TODO: Improve the test so that it tolerates delayed start of tasks with affinity_partitioner

TestParallelLoopAux<Body, /***/ tbb::affinity_partitioner>();

#endif

#undef __TBB_TEMPORARILY_DISABLED

void operator()( const range_type& r ) const {

Harness::ConcurrencyTracker ct;

volatile long x = 0;

++g_CurExecuted;

if(g_Master == Harness::CurrentTid()) g_MasterExecuted = true;

else g_NonMasterExecuted = true;

if( tbb::task::self().is_cancelled() ) ++g_TGCCancelled;

for( count_type i = r.begin(); i != r.end(); ++i )

x += 0;

WaitUntilConcurrencyPeaks();

ThrowTestException(1);

}

void operator()( const range_type& ) const {

Harness::ConcurrencyTracker ct;

++g_OuterParCalls;

tbb::parallel_for( tbb::blocked_range<size_t>(0, INNER_RANGE, INNER_GRAIN), SimpleParForBody() );

}

void operator()( const range_type& ) const {

tbb::task_group_context ctx(tbb::task_group_context::isolated);

++g_OuterParCalls;

tbb::parallel_for( tbb::blocked_range<size_t>(0, INNER_RANGE, INNER_GRAIN), SimpleParForBody(), tbb::simple_partitioner(), ctx );

}

ResetGlobals();

typedef OuterParForBodyWithIsolatedCtx body_type;

intptr_t innerCalls = NumSubranges(INNER_RANGE, INNER_GRAIN),

// we expect one thread to throw without counting, the rest to run to completion

// this formula assumes g_numThreads outer pfor ranges will be started, but that is not the

// case; the SimpleParFor subranges are started up as part of the outer ones, and when

// the amount of concurrency reaches g_NumThreads no more outer Pfor ranges are started.

// so we have to count the number of outer Pfors actually started.

minExecuted = (g_NumThreads - 1) * innerCalls;

TRY();

tbb::parallel_for( range_type(0, OUTER_RANGE, OUTER_GRAIN), body_type() );

CATCH_AND_ASSERT();

minExecuted = (g_OuterParCalls - 1) * innerCalls; // see above

// The first formula above assumes all ranges of the outer parallel for are executed, and one

// cancels. In the event, we have a smaller number of ranges that start before the exception

// is caught.

//

// g_SolitaryException:One inner range throws. Outer parallel_For is cancelled, but sibling

// parallel_fors continue to completion (unless the threads that execute

// are not allowed to throw, in which case we will not see any exceptions).

// !g_SolitaryException:multiple inner ranges may throw. Any which throws will stop, and the

// corresponding range of the outer pfor will stop also.

//

// In either case, once the outer pfor gets the exception it will stop executing further ranges.

// if the only threads executing were not allowed to throw, then not seeing an exception is okay.

bool okayNoExceptionsCaught = (g_ExceptionInMaster && !g_MasterExecuted) || (!g_ExceptionInMaster && !g_NonMasterExecuted);

if ( g_SolitaryException ) {

ASSERT( g_TGCCancelled <= g_NumThreads, "Too many tasks survived exception");

ASSERT (g_CurExecuted > minExecuted, "Too few tasks survived exception");

ASSERT (g_CurExecuted <= minExecuted + (g_ExecutedAtLastCatch + g_NumThreads), "Too many tasks survived exception");

ASSERT (g_NumExceptionsCaught == 1 || okayNoExceptionsCaught, "No try_blocks in any body expected in this test");

}

else {

ASSERT (g_CurExecuted <= g_ExecutedAtLastCatch + g_NumThreads, "Too many tasks survived exception");

ASSERT (g_NumExceptionsCaught >= 1 || okayNoExceptionsCaught, "No try_blocks in any body expected in this test");

}

void operator()( const range_type& ) const {

tbb::task_group_context ctx(tbb::task_group_context::isolated);

++g_OuterParCalls;

TRY();

tbb::parallel_for( tbb::blocked_range<size_t>(0, INNER_RANGE, INNER_GRAIN), SimpleParForBody(), tbb::simple_partitioner(), ctx );

CATCH(); // this macro sets g_ExceptionCaught

}

ResetGlobals( true, true );

intptr_t innerCalls = NumSubranges(INNER_RANGE, INNER_GRAIN),

outerCalls = NumSubranges(OUTER_RANGE, OUTER_GRAIN);

TRY();

tbb::parallel_for( range_type(0, OUTER_RANGE, OUTER_GRAIN), OuterParForExceptionSafeBody() );

CATCH();

// g_SolitaryException : one inner pfor will throw, the rest will execute to completion.

// so the count should be (outerCalls -1) * innerCalls, if a throw happened.

// !g_SolitaryException : possible multiple inner pfor throws. Should be approximately

// (outerCalls - g_NumExceptionsCaught) * innerCalls, give or take a few

intptr_t minExecuted = (outerCalls - g_NumExceptionsCaught) * innerCalls;

bool okayNoExceptionsCaught = (g_ExceptionInMaster && !g_MasterExecuted) || (!g_ExceptionInMaster && !g_NonMasterExecuted);

if ( g_SolitaryException ) {

// only one task had exception thrown. That task had at least one execution (the one that threw).

// There may be an arbitrary number of ranges executed after the throw but before the exception

// is caught in the scheduler and cancellation is signaled. (seen 9, 11 and 62 (!) for 8 threads)

ASSERT (g_NumExceptionsCaught == 1 || okayNoExceptionsCaught, "No exception registered");

ASSERT (g_CurExecuted >= minExecuted, "Too few tasks executed");

ASSERT( g_TGCCancelled <= g_NumThreads, "Too many tasks survived exception");

// a small number of threads can execute in a throwing sub-pfor, if the task which is

// to do the solitary throw swaps out after registering its intent to throw but before it

// actually does so. (Or is this caused by the extra threads participating? No, the

// number of extra tasks is sometimes far greater than the number of extra threads.)

ASSERT (g_CurExecuted <= minExecuted + g_NumThreads, "Too many tasks survived exception");

if(g_CurExecuted > minExecuted + g_NumThreads) REMARK("Unusual number of tasks executed after signal (%d vs. %d)\n",

(int)g_CurExecuted, minExecuted + g_NumThreads);

}

else {

ASSERT ((g_NumExceptionsCaught >= 1 && g_NumExceptionsCaught <= outerCalls) || okayNoExceptionsCaught, "Unexpected actual number of exceptions");

ASSERT (g_CurExecuted >= minExecuted, "Too few executed tasks reported");

ASSERT (g_CurExecuted <= g_ExecutedAtLastCatch + g_NumThreads, "Too many tasks survived multiple exceptions");

if(g_CurExecuted > g_ExecutedAtLastCatch + g_NumThreads) REMARK("Unusual number of tasks executed after signal (%d vs. %d)\n",

(int)g_CurExecuted, g_ExecutedAtLastCatch + g_NumThreads);

ASSERT (g_CurExecuted <= outerCalls * (1 + g_NumThreads), "Too many tasks survived exception");

}

void operator()( const range_type& ) const {

++g_CurExecuted;

CancellatorTask::WaitUntilReady();

}

tbb::task_group_context &my_ctx;

tbb::task* execute () {

tbb::parallel_for( range_type(0, FLAT_RANGE, FLAT_GRAIN), B(), tbb::simple_partitioner(), my_ctx );

return NULL;

}

ParForLauncherTask ( tbb::task_group_context& ctx ) : my_ctx(ctx) {}

tbb::task_group_context &m_GroupToCancel;

tbb::task* execute () {

Harness::ConcurrencyTracker ct;

WaitUntilConcurrencyPeaks();

m_GroupToCancel.cancel_group_execution();

g_ExecutedAtLastCatch = g_CurExecuted;

return NULL;

}

CancellatorTask2 ( tbb::task_group_context& ctx, intptr_t ) : m_GroupToCancel(ctx) {}

void operator()( const range_type& ) const {

++g_CurExecuted;

Harness::ConcurrencyTracker ct;

// The test will hang (and be timed out by the test system) if is_cancelled() is broken

while( !tbb::task::self().is_cancelled() )

__TBB_Yield();

}

ResetGlobals();

RunCancellationTest<ParForLauncherTask<ParForBodyToCancel2>, CancellatorTask2>();

ASSERT (g_ExecutedAtLastCatch < g_NumThreads, "Somehow worker tasks started their execution before the cancellator task");

ASSERT( g_TGCCancelled <= g_NumThreads, "Too many tasks survived cancellation");

ASSERT (g_CurExecuted <= g_ExecutedAtLastCatch + g_NumThreads, "Some tasks were executed after cancellation");

static const int max_nesting = 3;

static const int reduce_range = 1024;

static const int reduce_grain = 256;

int DoWork (int level);

int Validate (int start_level) {

int expected = 1; // identity for multiplication

for(int i=start_level+1; i<max_nesting; ++i)

expected *= reduce_range;

return expected;

}

Worker * m_SharedWorker;

int m_NestingLevel;

int m_Result;

RecursiveParReduceBodyWithSharedWorker ( RecursiveParReduceBodyWithSharedWorker& src, tbb::split )

: m_SharedWorker(src.m_SharedWorker)

, m_NestingLevel(src.m_NestingLevel)

, m_Result(0)

{}

RecursiveParReduceBodyWithSharedWorker ( Worker *w, int outer )

: m_SharedWorker(w)

, m_NestingLevel(outer)

, m_Result(0)

{}

void operator() ( const tbb::blocked_range<size_t>& r ) {

if(g_Master == Harness::CurrentTid()) g_MasterExecuted = true;

else g_NonMasterExecuted = true;

if( tbb::task::self().is_cancelled() ) ++g_TGCCancelled;

for (size_t i = r.begin (); i != r.end (); ++i) {

m_Result += m_SharedWorker->DoWork (m_NestingLevel);

}

}

void join (const RecursiveParReduceBodyWithSharedWorker & x) {

m_Result += x.m_Result;

}

int result () { return m_Result; }

++level;

if ( level < max_nesting ) {

RecursiveParReduceBodyWithSharedWorker rt (this, level);

tbb::parallel_reduce (tbb::blocked_range<size_t>(0, reduce_range, reduce_grain), rt);

return rt.result();

}

else

return 1;

Worker w;

int result = w.DoWork (0);

int expected = w.Validate(0);

ASSERT ( result == expected, "Wrong calculation result");

tbb::atomic<size_t> my_total_created;

tbb::atomic<size_t> my_total_deleted;

StatsCounters() {

my_total_created = 0;

my_total_deleted = 0;

}

StatsCounters* my_stats;

size_t my_id;

bool my_exception;

ParReduceBody( StatsCounters& s_, bool e_ ) : my_stats(&s_), my_exception(e_) {

my_id = my_stats->my_total_created++;

}

ParReduceBody( const ParReduceBody& lhs ) {

my_stats = lhs.my_stats;

my_id = my_stats->my_total_created++;

}

ParReduceBody( ParReduceBody& lhs, tbb::split ) {

my_stats = lhs.my_stats;

my_id = my_stats->my_total_created++;

}

~ParReduceBody(){ ++my_stats->my_total_deleted; }

void operator()( const tbb::blocked_range<std::size_t>& /*range*/ ) const {

//Do nothing, except for one task (chosen arbitrarily)

if( my_id >= 12 ) {

if( my_exception )

ThrowTestException(1);

else

tbb::task::self().cancel_group_execution();

}

}

void join( ParReduceBody& /*rhs*/ ) {}

StatsCounters statsObj;

__TBB_TRY {

tbb::task_group_context tgc1, tgc2;

ParReduceBody body_for_cancellation(statsObj, false), body_for_exception(statsObj, true);

tbb::parallel_reduce( tbb::blocked_range<std::size_t>(0,100000000,100), body_for_cancellation, tbb::simple_partitioner(), tgc1 );

tbb::parallel_reduce( tbb::blocked_range<std::size_t>(0,100000000,100), body_for_exception, tbb::simple_partitioner(), tgc2 );

REMARK( "parallel for and reduce tests\n" );

tbb::task_scheduler_init init (g_NumThreads);

g_Master = Harness::CurrentTid();

#if TBB_USE_EXCEPTIONS && !__TBB_THROW_ACROSS_MODULE_BOUNDARY_BROKEN

Test0();

Test1();

Test2();

Test3();

Test4();

#endif /* TBB_USE_EXCEPTIONS && !__TBB_THROW_ACROSS_MODULE_BOUNDARY_BROKEN */

TestCancelation1();

TestCancelation2();

TestCancelation3();

TestCancelation4();

if (g_FedTasksCount < ITEMS_TO_FEED) {

++g_FedTasksCount;

feeder.add(val);

}

void operator() ( size_t &value ) const {

++g_CurExecuted;

if(g_Master == Harness::CurrentTid()) g_MasterExecuted = true;

else g_NonMasterExecuted = true;

if( tbb::task::self().is_cancelled() ) ++g_TGCCancelled;

Harness::ConcurrencyTracker ct;

value += 1000;

WaitUntilConcurrencyPeaks();

ThrowTestException(1);

}

void operator() ( size_t &value, tbb::parallel_do_feeder<size_t> &feeder ) const {

Feed(feeder, 0);

SimpleParDoBody::operator()(value);

}

ResetGlobals();

PREPARE_RANGE(Iterator, ITER_RANGE);

TRY();

tbb::parallel_do<Iterator, simple_body>(begin, end, simple_body() );

CATCH_AND_ASSERT();

ASSERT (g_CurExecuted <= g_ExecutedAtLastCatch + g_NumThreads, "Too many tasks survived exception");

ASSERT( g_TGCCancelled <= g_NumThreads, "Too many tasks survived cancellation");

ASSERT (g_NumExceptionsCaught == 1, "No try_blocks in any body expected in this test");

if ( !g_SolitaryException )

ASSERT (g_CurExecuted <= g_ExecutedAtLastCatch + g_NumThreads, "Too many tasks survived exception");

void operator()( size_t& /*value*/ ) const {

++g_OuterParCalls;

PREPARE_RANGE(Iterator, INNER_ITER_RANGE);

tbb::parallel_do<Iterator, SimpleParDoBody>(begin, end, SimpleParDoBody());

}

void operator()( size_t& value, tbb::parallel_do_feeder<size_t>& feeder ) const {

Feed(feeder, 0);

OuterParDoBody<Iterator>::operator()(value);

}

ResetGlobals();

PREPARE_RANGE(Iterator, ITER_RANGE);

TRY();

tbb::parallel_do<Iterator, outer_body >(begin, end, outer_body() );

CATCH_AND_ASSERT();

//if ( g_SolitaryException )

ASSERT (g_CurExecuted <= g_ExecutedAtLastCatch + g_NumThreads, "Too many tasks survived exception");

ASSERT( g_TGCCancelled <= g_NumThreads, "Too many tasks survived cancellation");

ASSERT (g_NumExceptionsCaught == 1, "No try_blocks in any body expected in this test");

if ( !g_SolitaryException )

ASSERT (g_CurExecuted <= g_ExecutedAtLastCatch + g_NumThreads, "Too many tasks survived exception");

void operator()( size_t& /*value*/ ) const {

tbb::task_group_context ctx(tbb::task_group_context::isolated);

++g_OuterParCalls;

PREPARE_RANGE(Iterator, INNER_ITER_RANGE);

tbb::parallel_do<Iterator, SimpleParDoBody>(begin, end, SimpleParDoBody(), ctx);

}

void operator()( size_t& value, tbb::parallel_do_feeder<size_t> &feeder ) const {

Feed(feeder, 0);

OuterParDoBodyWithIsolatedCtx<Iterator>::operator()(value);

}

ResetGlobals();

PREPARE_RANGE(Iterator, OUTER_ITER_RANGE);

intptr_t innerCalls = INNER_ITER_RANGE,

// The assumption here is the same as in outer parallel fors.

minExecuted = (g_NumThreads - 1) * innerCalls;

g_Master = Harness::CurrentTid();

TRY();

tbb::parallel_do<Iterator, outer_body >(begin, end, outer_body());

CATCH_AND_ASSERT();

// figure actual number of expected executions given the number of outer PDos started.

minExecuted = (g_OuterParCalls - 1) * innerCalls;

// one extra thread may run a task that sees cancellation. Infrequent but possible

ASSERT( g_TGCCancelled <= g_NumThreads, "Too many tasks survived exception");

if(g_TGCCancelled > g_NumThreads) REMARK("Extra thread(s) executed after cancel (%d vs. %d)\n",

(int)g_TGCCancelled, (int)g_NumThreads);

if ( g_SolitaryException ) {

ASSERT (g_CurExecuted > minExecuted, "Too few tasks survived exception");

ASSERT (g_CurExecuted <= minExecuted + (g_ExecutedAtLastCatch + g_NumThreads), "Too many tasks survived exception");

}

ASSERT (g_NumExceptionsCaught == 1, "No try_blocks in any body expected in this test");

if ( !g_SolitaryException )

ASSERT (g_CurExecuted <= g_ExecutedAtLastCatch + g_NumThreads, "Too many tasks survived exception");

void operator()( size_t& /*value*/ ) const {

tbb::task_group_context ctx(tbb::task_group_context::isolated);

++g_OuterParCalls;

PREPARE_RANGE(Iterator, INNER_ITER_RANGE);

TRY();

tbb::parallel_do<Iterator, SimpleParDoBody>(begin, end, SimpleParDoBody(), ctx);

CATCH();

}

void operator()( size_t &value, tbb::parallel_do_feeder<size_t> &feeder ) const {

Feed(feeder, 0);

OuterParDoWithEhBody<Iterator>::operator()(value);

}

ResetGlobals( true, true );

PREPARE_RANGE(Iterator, OUTER_ITER_RANGE);

g_Master = Harness::CurrentTid();

TRY();

tbb::parallel_do<Iterator, outer_body_with_eh>(begin, end, outer_body_with_eh());

CATCH();

ASSERT (!l_ExceptionCaughtAtCurrentLevel, "All exceptions must have been handled in the parallel_do body");

intptr_t innerCalls = INNER_ITER_RANGE,

outerCalls = OUTER_ITER_RANGE + g_FedTasksCount,

maxExecuted = outerCalls * innerCalls,

minExecuted = 0;

ASSERT( g_TGCCancelled <= g_NumThreads, "Too many tasks survived exception");

if ( g_SolitaryException ) {

minExecuted = maxExecuted - innerCalls;

ASSERT (g_NumExceptionsCaught == 1, "No exception registered");

ASSERT (g_CurExecuted >= minExecuted, "Too few tasks executed");

// This test has the same property as Test4 (parallel_for); the exception can be

// thrown, but some number of tasks from the outer Pdo can execute after the throw but

// before the cancellation is signaled (have seen 36).

ASSERT_WARNING(g_CurExecuted < maxExecuted || g_TGCCancelled, "All tasks survived exception. Oversubscription?");

}

else {

minExecuted = g_NumExceptionsCaught;

ASSERT (g_NumExceptionsCaught > 1 && g_NumExceptionsCaught <= outerCalls, "Unexpected actual number of exceptions");

ASSERT (g_CurExecuted >= minExecuted, "Too many executed tasks reported");

ASSERT (g_CurExecuted < g_ExecutedAtLastCatch + g_NumThreads + outerCalls, "Too many tasks survived multiple exceptions");

ASSERT (g_CurExecuted <= outerCalls * (1 + g_NumThreads), "Too many tasks survived exception");

}

//! This form of the function call operator can be used when the body needs to add more work during the processing

void operator() ( size_t &value, tbb::parallel_do_feeder<size_t> &feeder ) const {

++g_CurExecuted;

if(g_Master == Harness::CurrentTid()) g_MasterExecuted = true;

else g_NonMasterExecuted = true;

if( tbb::task::self().is_cancelled() ) ++g_TGCCancelled;

Feed(feeder, 1);

if (value == 1)

ThrowTestException(1);

}

ResetGlobals();

PREPARE_RANGE(Iterator, ITER_RANGE);

g_Master = Harness::CurrentTid();

TRY();

tbb::parallel_do<Iterator, ParDoBodyWithThrowingFeederTasks>(begin, end, ParDoBodyWithThrowingFeederTasks());

CATCH();

if (g_SolitaryException) {

// Failure occurs when g_ExceptionInMaster is false, but all the 1 values in the range

// are handled by the master thread. In this case no throw occurs.

ASSERT (l_ExceptionCaughtAtCurrentLevel // we saw an exception

|| (!g_ExceptionInMaster && !g_NonMasterExecutedThrow) // non-master throws but none tried

|| (g_ExceptionInMaster && !g_MasterExecutedThrow) // master throws but master didn't try

, "At least one exception should occur");

if(!g_ExceptionCaught) {

if(g_ExceptionInMaster)

REMARK("PDo exception not thrown; non-masters handled all throwing values.\n");

else

REMARK("PDo exception not thrown; master handled all throwing values.\n");

}

}

void operator()( size_t& /*value*/ ) const {

++g_CurExecuted;

CancellatorTask::WaitUntilReady();

}

void operator()( size_t& value, tbb::parallel_do_feeder<size_t> &feeder ) const {

Feed(feeder, 0);

ParDoBodyToCancel::operator()(value);

}

tbb::task_group_context &my_ctx;

tbb::task* execute () {

PREPARE_RANGE(Iterator, INNER_ITER_RANGE);

tbb::parallel_do<Iterator, B>( begin, end, B(), my_ctx );

return NULL;

}

ParDoWorkerTask ( tbb::task_group_context& ctx ) : my_ctx(ctx) {}

ResetGlobals( false );

intptr_t threshold = 10;

tbb::task_group_context ctx;

ctx.reset();

tbb::empty_task &r = *new( tbb::task::allocate_root() ) tbb::empty_task;

r.set_ref_count(3);

r.spawn( *new( r.allocate_child() ) CancellatorTask(ctx, threshold) );

__TBB_Yield();

r.spawn( *new( r.allocate_child() ) ParDoWorkerTask<body_to_cancel, Iterator>(ctx) );

TRY();

r.wait_for_all();

CATCH_AND_FAIL();

ASSERT (g_CurExecuted < g_ExecutedAtLastCatch + g_NumThreads, "Too many tasks were executed after cancellation");

r.destroy(r);

void operator()( size_t& /*value*/ ) const {

++g_CurExecuted;

Harness::ConcurrencyTracker ct;

// The test will hang (and be timed out by the test system) if is_cancelled() is broken

while( !tbb::task::self().is_cancelled() )

__TBB_Yield();

}

void operator()( size_t& value, tbb::parallel_do_feeder<size_t> &feeder ) const {

Feed(feeder, 0);

ParDoBodyToCancel2::operator()(value);

}

REMARK( "parallel do tests\n" );

tbb::task_scheduler_init init (g_NumThreads);

g_Master = Harness::CurrentTid();

#if TBB_USE_EXCEPTIONS && !__TBB_THROW_ACROSS_MODULE_BOUNDARY_BROKEN

RunWithSimpleBody(Test1_parallel_do, SimpleParDoBody);

RunWithTemplatedBody(Test2_parallel_do, OuterParDoBody);

RunWithTemplatedBody(Test3_parallel_do, OuterParDoBodyWithIsolatedCtx);

RunWithTemplatedBody(Test4_parallel_do, OuterParDoWithEhBody);

Test5_parallel_do<Harness::ForwardIterator<size_t> >();

Test5_parallel_do<Harness::RandomIterator<size_t> >();

#endif /* TBB_USE_EXCEPTIONS && !__TBB_THROW_ACROSS_MODULE_BOUNDARY_BROKEN */

RunWithSimpleBody(TestCancelation1_parallel_do, ParDoBodyToCancel);

RunWithSimpleBody(TestCancelation2_parallel_do, ParDoBodyToCancel2);

tbb::atomic<size_t> m_Item;

size_t m_Buffer[NUM_ITEMS + 1];

InputFilter() : tbb::filter(parallel) {

m_Item = 0;

for (size_t i = 0; i < NUM_ITEMS; ++i )

m_Buffer[i] = 1;

m_Buffer[NUM_ITEMS] = c_DataEndTag;

}

void* operator()( void* ) {

size_t item = m_Item.fetch_and_increment();

if(g_Master == Harness::CurrentTid()) g_MasterExecuted = true;

else g_NonMasterExecuted = true;

if( tbb::task::self().is_cancelled() ) ++g_TGCCancelled;

if(item == 1) {

++g_PipelinesStarted; // count on emitting the first item.

}

if ( item >= NUM_ITEMS )

return NULL;

m_Buffer[item] = 1;

return &m_Buffer[item];

}

size_t* buffer() { return m_Buffer; }

size_t m_Value;

enum operation {

addition,

subtraction,

multiplication

} m_Operation;

NoThrowFilter(operation _operation, size_t value, bool is_parallel)

: filter(is_parallel? tbb::filter::parallel : tbb::filter::serial_in_order),

m_Value(value), m_Operation(_operation)

{}

void* operator()(void* item) {

size_t &value = *(size_t*)item;

if(g_Master == Harness::CurrentTid()) g_MasterExecuted = true;

else g_NonMasterExecuted = true;

if( tbb::task::self().is_cancelled() ) ++g_TGCCancelled;

ASSERT(value != c_DataEndTag, "terminator element is being processed");

switch (m_Operation){

case addition:

value += m_Value;

break;

case subtraction:

value -= m_Value;

break;

case multiplication:

value *= m_Value;

break;

default:

ASSERT(0, "Wrong operation parameter passed to NoThrowFilter");

} // switch (m_Operation)

return item;

}