5 ms·

"As a side note, the parallel version uses about 280 threads on my machine vs a single thread for the serial version." This is a great example of how you shoul

"As a side note, the parallel version uses about 280 threads on my machine vs a single thread for the serial version." This is a great example of how you shouldn't run things in parallel. Running 280 Threads on 2-4 cores machine makes no sense at all.

octopus 14y ago
Actually it makes sense, if you manually force the code to use only 4 threads it will take more time to finish that in the case when you let the compiler split the work for you. On a given machine there are hundreds of threads running concurrently, the OS will let them run in time slices on the available hardware. Using the same number of threads as the number of available processors does not mean your code will be faster than when you use a larger number of threads. Obviously this is OS and compiler dependent.
- Nursie 14y ago
  It does reduce thread switching overhead considerably, usually resulting in less time spent storing and retrieving thread contexts and more time spent actually processing the thread. It's possible on newer intel hardware we've reached the stage where context switching is no longer much of a cost I guess...
- exDM69 14y ago
  > Actually it makes sense, if you manually force the code to use only 4 threads it will take more time to finish that in the case when you let the compiler split the work for you. While I think this is correct, I think your reasoning is off. And as far as I know, the compiler does not do anything clever here (unlike in some smarter, less mainstream languages) and you're just launching a huge number of threads. If you use only 4 threads in a similar manner in a loop, the problem is that the background threads finish and the CPU is idle while the serial loop that creates the threads is occupied by creating and launching the threads and there are not enough threads to keep the cpu busy. (edit: this is more likely about waiting for I/O, see below). If you're truly CPU bound, you will not gain from having a lot more threads than CPU cores (* ~1.5 for hyperthreads). If your threads are waiting for I/O, adding more will cause the OS to switch to an available thread but you gain more by using asynchronous I/O functions (like aio and epoll or kqueue, which you won't find an abstraction for in C++ stdlib). The way the code in the blog works is actually spending a whole lot of good cpu cycles for doing context switching from one thread to another and wasting a lot of memory for maintaining threads that wait for disk I/O. What you can't see from the tutorial source is what the worker actually does (make_perlin_noise), I assume that function also does the writing to disk which would explain why you benefit from launching a huge number of threads. On the other hand, your memory use is completely unacceptable with this solution. You should try this: split the number of images evenly and make each thread compute a number of images. Launch roughly as many threads as there are cpu cores and do not make the threads wait for disk I/O. You should see performance go up and memory use go down.
  - Nursie 14y ago
    One of the patterns I've used before is to use thread pools rather than starting and stopping threads all the time. Each thread in the pool can be passed a list of the tasks it needs to do, or grab tasks from a central list as it finishes a previous one. Then after a few runs you can tune the pool size so that you get the most out of the machine. Obviously there are still gains to be made by switching to async io, avoiding any serial choke points etc, and keeping the pool size small, but it seems to be a decent approach.
- ezy 14y ago
  This very much depends on what the threads are doing. Like some others have mentioned, threads are sometimes an abstraction of context and sometimes a CPU. THere is no pat answer -- unless you're doing only one kind of thing -- if you're all IO bound or all CPU bound, the answer is obvious, otherwise... I worked on a platform that could have 200+ threads running through it, but in areas of the code where it mattered, only NCPU+epsilon threads were allowed to do intense CPU-bound work. Doing this, as you might expect, improves performance substantially when the system is loaded, while at the same time allowing one to use threads as an abstraction of context in the non-CPU bound areas of the code.
exDM69 14y ago
My thoughts exactly. Unless you use a language with cheap and fast green threads that multiplex on OS threads (like Haskell), you should use a number of threads that is roughly in the same order of magnitude as the number of CPU cores + hyper threads. I am very surprised by the fact that there was any speedup at all and not surprised that the parallel version used 200x (!!) memory. On the other hand, this is probably one of those thing that was done for demonstration purposes, not really something you'd do on practice. Btw. is async a part of C++11 standard at all? I thought it was omitted from the standard but may be still implemented by some compilers/stdlibs. Does every async call start a new thread and why?
- octopus 14y ago
  std::async is included in the C++11 standard. The number of threads that async will use is implementation dependent, I bet on Windows with VS2012 you will see a different number of threads. You could force async to run asynchronously or in a lazy evaluation mode using launch policies.
- vonmoltke 14y ago
  > Unless you use a language with cheap and fast green threads that multiplex on OS threads (like Haskell), you should use a number of threads that is roughly in the same order of magnitude as the number of CPU cores + hyper threads. The optimal number of threads per core is workload and machine dependent, but rarely is that number 1 per hardware thread[1]. For maximum CPU utilization and computational efficiency, you need multiple software threads per hardware thread so that the OS always has a thread ready to go when another thread blocks or the CPU has an unused component. How much the threads block and what parts of the CPU the exercise is the workload-dependent part. Ideally, the number of threads would be a tunable performance parameter. As an example of this, I recently wrote some math-heavy code to transform the cells of a matrix by a particular transfer function. Each cell calculation was independent, so I parallelized them. The most efficient parallelization for my 6-core AMD processor turned out to be 6 threads per core. [1] The main exception I can think of is when running multiple applications in parallel that in turn parallelize their work.
  - 14y ago
JoeAltmaier 14y ago
Threads are for context switching. Can you switch context faster in code than the hardware can do it? Why would you think that? If there is significant context with synchronization points, then threads are appropriate. This can occur in message-passing systems - its about all that happens in fact. I'm not sure what the OP was doing (I should have read that first) but I just wanted to chime in and defend the use of threads where appropriate. In particular, where its algorithmically matched and where 'doing it yourself' would add more overhead.
- exDM69 14y ago
  > Threads are for context switching. Can you switch context faster in code than the hardware can do it? Why would you think that? This code is using a whole bunch of threads that are waiting for disk I/O. You can do that faster than with threads using asynchronous I/O routines provided by your OS. E.g. aio(7) in POSIX.
  - octopus 14y ago
    Obviously you will write faster code if you use directly OS functions, but your code will be less portable.
    - exDM69 14y ago
      That is very unfortunate, but sometimes performance goes over portability. I think it was a major omission to leave out async I/O abstractions from C11 and C++11 standard libraries. But you can't do much with only the standard library anyway. In addition to async filesystem i/o, it's completely lacking network sockets (async or otherwise) and other important, almost standard functionality. And besides, aio is a POSIX standard, so it should be fairly widely supported. With POSIX aio + Win32 async i/o you should get quite good portability. And in any case, it's just a bad idea to have a ton of threads waiting for synchronous I/O completion. If using async i/o is out of the question, use a thread pool to keep your resource consumption sane.
      - 14y ago
alpatters 14y ago
Well, getting 1.7x speedup on a dual core box isn't so bad and makes some sense. Showing at least the context switching isn't crippling, if you can cope with the memory overhead. Anthony William's book "C++ Concurrency in Action" gave me the impression that implementations of std::async would stop spawning new threads at some implementation defined limit based on harware concurrency levels. Instead, delay execution or switch to serial for extra tasks.
- octopus 14y ago
  This is apparently true for VS2012 + Win7, at least from my tests. On a quad-core machine the max numbers of threads spawned by std::async is 10.

octopus 14y ago

Actually it makes sense, if you manually force the code to use only 4 threads it will take more time to finish that in the case when you let the compiler split the work for you. On a given machine there are hundreds of threads running concurrently, the OS will let them run in time slices on the available hardware. Using the same number of threads as the number of available processors does not mean your code will be faster than when you use a larger number of threads. Obviously this is OS and compiler dependent.

Nursie 14y ago
It does reduce thread switching overhead considerably, usually resulting in less time spent storing and retrieving thread contexts and more time spent actually processing the thread. It's possible on newer intel hardware we've reached the stage where context switching is no longer much of a cost I guess...
exDM69 14y ago
> Actually it makes sense, if you manually force the code to use only 4 threads it will take more time to finish that in the case when you let the compiler split the work for you. While I think this is correct, I think your reasoning is off. And as far as I know, the compiler does not do anything clever here (unlike in some smarter, less mainstream languages) and you're just launching a huge number of threads. If you use only 4 threads in a similar manner in a loop, the problem is that the background threads finish and the CPU is idle while the serial loop that creates the threads is occupied by creating and launching the threads and there are not enough threads to keep the cpu busy. (edit: this is more likely about waiting for I/O, see below). If you're truly CPU bound, you will not gain from having a lot more threads than CPU cores (* ~1.5 for hyperthreads). If your threads are waiting for I/O, adding more will cause the OS to switch to an available thread but you gain more by using asynchronous I/O functions (like aio and epoll or kqueue, which you won't find an abstraction for in C++ stdlib). The way the code in the blog works is actually spending a whole lot of good cpu cycles for doing context switching from one thread to another and wasting a lot of memory for maintaining threads that wait for disk I/O. What you can't see from the tutorial source is what the worker actually does (make_perlin_noise), I assume that function also does the writing to disk which would explain why you benefit from launching a huge number of threads. On the other hand, your memory use is completely unacceptable with this solution. You should try this: split the number of images evenly and make each thread compute a number of images. Launch roughly as many threads as there are cpu cores and do not make the threads wait for disk I/O. You should see performance go up and memory use go down.
- Nursie 14y ago
  One of the patterns I've used before is to use thread pools rather than starting and stopping threads all the time. Each thread in the pool can be passed a list of the tasks it needs to do, or grab tasks from a central list as it finishes a previous one. Then after a few runs you can tune the pool size so that you get the most out of the machine. Obviously there are still gains to be made by switching to async io, avoiding any serial choke points etc, and keeping the pool size small, but it seems to be a decent approach.
ezy 14y ago
This very much depends on what the threads are doing. Like some others have mentioned, threads are sometimes an abstraction of context and sometimes a CPU. THere is no pat answer -- unless you're doing only one kind of thing -- if you're all IO bound or all CPU bound, the answer is obvious, otherwise... I worked on a platform that could have 200+ threads running through it, but in areas of the code where it mattered, only NCPU+epsilon threads were allowed to do intense CPU-bound work. Doing this, as you might expect, improves performance substantially when the system is loaded, while at the same time allowing one to use threads as an abstraction of context in the non-CPU bound areas of the code.

exDM69 14y ago

My thoughts exactly. Unless you use a language with cheap and fast green threads that multiplex on OS threads (like Haskell), you should use a number of threads that is roughly in the same order of magnitude as the number of CPU cores + hyper threads. I am very surprised by the fact that there was any speedup at all and not surprised that the parallel version used 200x (!!) memory. On the other hand, this is probably one of those thing that was done for demonstration purposes, not really something you'd do on practice. Btw. is async a part of C++11 standard at all? I thought it was omitted from the standard but may be still implemented by some compilers/stdlibs. Does every async call start a new thread and why?

octopus 14y ago
std::async is included in the C++11 standard. The number of threads that async will use is implementation dependent, I bet on Windows with VS2012 you will see a different number of threads. You could force async to run asynchronously or in a lazy evaluation mode using launch policies.
vonmoltke 14y ago
> Unless you use a language with cheap and fast green threads that multiplex on OS threads (like Haskell), you should use a number of threads that is roughly in the same order of magnitude as the number of CPU cores + hyper threads. The optimal number of threads per core is workload and machine dependent, but rarely is that number 1 per hardware thread[1]. For maximum CPU utilization and computational efficiency, you need multiple software threads per hardware thread so that the OS always has a thread ready to go when another thread blocks or the CPU has an unused component. How much the threads block and what parts of the CPU the exercise is the workload-dependent part. Ideally, the number of threads would be a tunable performance parameter. As an example of this, I recently wrote some math-heavy code to transform the cells of a matrix by a particular transfer function. Each cell calculation was independent, so I parallelized them. The most efficient parallelization for my 6-core AMD processor turned out to be 6 threads per core. [1] The main exception I can think of is when running multiple applications in parallel that in turn parallelize their work.
- 14y ago

JoeAltmaier 14y ago

Threads are for context switching. Can you switch context faster in code than the hardware can do it? Why would you think that? If there is significant context with synchronization points, then threads are appropriate. This can occur in message-passing systems - its about all that happens in fact. I'm not sure what the OP was doing (I should have read that first) but I just wanted to chime in and defend the use of threads where appropriate. In particular, where its algorithmically matched and where 'doing it yourself' would add more overhead.

exDM69 14y ago
> Threads are for context switching. Can you switch context faster in code than the hardware can do it? Why would you think that? This code is using a whole bunch of threads that are waiting for disk I/O. You can do that faster than with threads using asynchronous I/O routines provided by your OS. E.g. aio(7) in POSIX.
- octopus 14y ago
  Obviously you will write faster code if you use directly OS functions, but your code will be less portable.
  - exDM69 14y ago
    That is very unfortunate, but sometimes performance goes over portability. I think it was a major omission to leave out async I/O abstractions from C11 and C++11 standard libraries. But you can't do much with only the standard library anyway. In addition to async filesystem i/o, it's completely lacking network sockets (async or otherwise) and other important, almost standard functionality. And besides, aio is a POSIX standard, so it should be fairly widely supported. With POSIX aio + Win32 async i/o you should get quite good portability. And in any case, it's just a bad idea to have a ton of threads waiting for synchronous I/O completion. If using async i/o is out of the question, use a thread pool to keep your resource consumption sane.
    - 14y ago

alpatters 14y ago

Well, getting 1.7x speedup on a dual core box isn't so bad and makes some sense. Showing at least the context switching isn't crippling, if you can cope with the memory overhead. Anthony William's book "C++ Concurrency in Action" gave me the impression that implementations of std::async would stop spawning new threads at some implementation defined limit based on harware concurrency levels. Instead, delay execution or switch to serial for extra tasks.

octopus 14y ago
This is apparently true for VS2012 + Win7, at least from my tests. On a quad-core machine the max numbers of threads spawned by std::async is 10.