multicore

If you were writing a new application from scratch today, and wanted it to scale to all the cores you could throw at it tomorrow, what parallel programming model/system/language/library would you choose? Why? I am particularly interested in answers along these axes: Programmer productivity / ease of use (can mortals successfully use it?) Target application domain (what problems is it (not) good at?) Concurrency style (does it support tasks, pipelines, data parallelism, messages...?) Maintainability / future-proofing (will anybody still be using it in 20 years?) Performance (how does it scale

I was very confused but the following thread cleared my doubts: Multiprocessing, Multithreading,HyperThreading, Multi-core But it addresses the queries from the hardware point of view. I want to know how these hardware features are mapped to software? One thing that is obvious is that there is no difference between MultiProcessor(=Mutlicpu) and MultiCore other than that in multicore all cpus reside on one chip(die) where as in Multiprocessor all cpus are on their own chips & connected together. So, mutlicore/multiprocessor systems are capable of executing multiple processes (firefox

I am playing around a bit with my program (trying to multicore a few parts) and I've noticed the "CPU history" looks a bit different, depend on how many workers I start. 2-4 workers seems to produce a "stable" workflow, however pegging 5-8 workers produces erratic behavior (from zero to max, see pictures). I should point out that all runs started out with "smooth" max capacity (e.g. 2 cores with only 25%), and started to exhibit erratic behavior only after a minute or so. What's going on? I have 4 core processor, and do you think this behavior may be related to this fact? I hope you can see

I'm testing this Go code on my VirtualBoxed Ubuntu 11.4 package main import ("fmt";"time";"big") var c chan *big.Int func sum( start,stop,step int64) { bigStop := big.NewInt(stop) bigStep := big.NewInt(step) bigSum := big.NewInt(0) for i := big.NewInt(start);i.Cmp(bigStop)<0 ;i.Add(i,bigStep){ bigSum.Add(bigSum,i) } c<-bigSum } func main() { s := big.NewInt( 0 ) n := time.Nanoseconds() step := int64(4) c = make( chan *big.Int , int(step)) stop := int64(100000000) for j:=int64(0);j<step;j++{ go sum(j,stop,step) } for j:=int64(0);j<step;j++{ s.Add(s,<-c) } n = time.Nanoseconds() - n fmt.Println

I can understand how one can write a program that uses multiple processes or threads: fork() a new process and use IPC, or create multiple threads and use those sorts of communication mechanisms. I also understand context switching. That is, with only once CPU, the operating system schedules time for each process (and there are tons of scheduling algorithms out there) and thereby we achieve running multiple processes simultaneously. And now that we have multi-core processors (or multi-processor computers), we could have two processes running simultaneously on two separate cores. My question is

Do pthread_mutex_lock and pthread_mutex_unlock functions call memory fence/barrier instructions? Or do the the lower level instructions like compare_and_swap implicity have memory barriers? Do pthread_mutex_lock and pthread_mutex_unlock functions call memory fence/barrier instructions? They do, as well as thread creation. Note, however, there are two types of memory barriers: compiler and hardware. Compiler barriers only prevent the compiler from reordering reads and writes and speculating variable values, but don't prevent the CPU from reordering. The hardware barriers prevent the CPU from