NativeParallelForTask< Index, Body > Class Template Reference

For internal use by template function NativeParallelFor. More...

#include <harness_defs.h>

Public Member Functions
	NativeParallelForTask (Index index_, const Body &body_)
void	start ()
	Start task. More...
void	wait_to_finish ()
	Wait for task to finish. More...

Detailed Description

template<typename Index, typename Body>
class NativeParallelForTask< Index, Body >

For internal use by template function NativeParallelFor.

Definition at line 519 of file harness_defs.h.

Inheritance diagram for NativeParallelForTask< Index, Body >:

Constructor & Destructor Documentation

NativeParallelForTask()

template<typename Index , typename Body >

NativeParallelForTask< Index, Body >::NativeParallelForTask ( Index  index_, const Body &  body_  )

inline

Definition at line 521 of file harness_defs.h.

                                                           :
        index(index_),
        body(body_)
    {}

Member Function Documentation

start()

template<typename Index , typename Body >

void NativeParallelForTask< Index, Body >::start ( )

inline

Start task.

Definition at line 527 of file harness_defs.h.

                 {
#if _WIN32||_WIN64
        unsigned thread_id;
#if __TBB_WIN8UI_SUPPORT
        std::thread* thread_tmp = new std::thread(thread_function, this);
        thread_handle = thread_tmp->native_handle();
        thread_id = 0;
#else
        unsigned stack_size = 0;
#if HARNESS_THREAD_STACK_SIZE
        stack_size = HARNESS_THREAD_STACK_SIZE;
#endif
        thread_handle = (HANDLE)_beginthreadex(NULL, stack_size, thread_function, this, 0, &thread_id);
#endif
        ASSERT(thread_handle != 0, "NativeParallelFor: _beginthreadex failed");
#else
#if __ICC==1100
#pragma warning (push)
#pragma warning (disable: 2193)
#endif /* __ICC==1100 */
        // Some machines may have very large hard stack limit. When the test is
        // launched by make, the default stack size is set to the hard limit, and
        // calls to pthread_create fail with out-of-memory error.
        // Therefore we set the stack size explicitly (as for TBB worker threads).
#if !defined(HARNESS_THREAD_STACK_SIZE)
#if __i386__||__i386||__arm__
        const size_t stack_size = 1 * MByte;
#elif __x86_64__
        const size_t stack_size = 2 * MByte;
#else
        const size_t stack_size = 4 * MByte;
#endif
#else
        const size_t stack_size = HARNESS_THREAD_STACK_SIZE;
#endif /* HARNESS_THREAD_STACK_SIZE */
        pthread_attr_t attr_stack;
        int status = pthread_attr_init(&attr_stack);
        ASSERT(0 == status, "NativeParallelFor: pthread_attr_init failed");
        status = pthread_attr_setstacksize(&attr_stack, stack_size);
        ASSERT(0 == status, "NativeParallelFor: pthread_attr_setstacksize failed");
        status = pthread_create(&thread_id, &attr_stack, thread_function, this);
        ASSERT(0 == status, "NativeParallelFor: pthread_create failed");
        pthread_attr_destroy(&attr_stack);
#if __ICC==1100
#pragma warning (pop)
#endif
#endif /* _WIN32||_WIN64 */
    }

wait_to_finish()

template<typename Index , typename Body >

void NativeParallelForTask< Index, Body >::wait_to_finish ( )

inline

Wait for task to finish.

Definition at line 577 of file harness_defs.h.

                          {
#if _WIN32||_WIN64
        DWORD status = WaitForSingleObjectEx(thread_handle, INFINITE, FALSE);
        ASSERT(status != WAIT_FAILED, "WaitForSingleObject failed");
        CloseHandle(thread_handle);
#else
        int status = pthread_join(thread_id, NULL);
        ASSERT(!status, "pthread_join failed");
#endif
#if HARNESS_NO_ASSERT
        (void)status;
#endif
    }

---

The documentation for this class was generated from the following file:

• harness_defs.h