Intel® Threading Building Blocks

A TBB example does not compile in VS 2013

Hello All,

I was able to build and run shortpath example using the nmake and the Makefile to build the example. In the command line window (in Spanish is: Simbolo del sistema, I think Prompt window in English) I ran tbbvars.bat and I fixed PATH and INCLUDE environment variables:

set PATH=C:\Program Files (x86)\Microsoft Visual C++ Compiler Nov 2013 CTP\bin;%PATH%

set INCLUDE=C:\Program Files (x86)\Microsoft Visual C++ Compiler Nov 2013 CTP\include;%INCLUDE%

Then I executed nmake and the executable was built and I ran it.

tbbmalloc operator new should check new_handler's before throwing std::bad_alloc

I have an installed new_handler using std::set_new_handler(new_handler), which I would like to be called when tbbmalloc runs out of memory on a call to new or new[]. The current implementation in src/tbbmalloc/proxy.cpp just returns std::bad_alloc if scalable_malloc returns NULL, rather than getting the new_handler if one exists and calling it.

This is an enhancement request for a future version of tbbmalloc.

Body classes of unlimited function nodes

For a long time my understanding of the prominent warning that the function node body will be copied was that there had to be at least as many instances of the body class as there are of concurrent threads executing that particular body. But that understanding was incorrect. Nothing seems to be preventing multiple threads from accessing the same instance of the body class, so there is an implicit (at least, I haven't seen it stated anywhere) assumption that the operator() associated with the body is reentrant. First of all, can somebody confirm this?

ask for helps on improving the TBB parallel efficiency regarding hyper-threading etc.

Hello! I have some confusing parallel timing results for my code, which performs
heavy numerical work.

For using 1 core, my timing is 882 seconds;
For using 8 cores, my timing is 121 seconds (7.3x faster);
for using 16 cores; my timing is 101 seconds (8.7x faster);
for using 32 logical cores; timing is 100 seconds, as same with using 16 cores.

My questions focus on two points:

Linearizability tester

We have recently evaluated tbb::concurrent_unordered_set with a new tool that finds linearizability violations, a certain class of concurrency-related bugs [1]. I just wanted to share that link in case there is interest in using the tool for other data structures in TBB. Of course, any form of feedback, questions, feature requests etc. are always warmly invited.

All best regards,

Alex

[1] https://github.com/ahorn/linearizability-tester

Performance comparison between Intel TBB task_list, openMP task and parallel for

I am planning on parallelizing a hotspot in a project. And I would like to know your opinion between the performance evaluation between parallel for, omp single followed by task and intel TBB task_list, under ideal conditions where number of threads are equal to computation items and when computation are much greater than available threads to see scheduling overhead(in order to evaluate the most efficient scheduler). I will also, be writing some sample test programs to evaluate myself but I also wanted to know if anybody had previously made these evaluations.

Thanks in advance.

Suscribirse a Intel® Threading Building Blocks