multicore

Follow up question from Multi-core usage, threads, thread-pools . Are threads moved from one core to another during their lifetime? Of course. Imagine you have three threads running on a dualcore system. Show me a fair schedule that doesn't involve regularly moving threads between cores. This is my first time on this site, so I didn't have enough rep to comment I guess. I decided to just make a new question referencing the one I wanted to comment on. What is the process of selecting a core to move a thread to. Is it like the scheduler has a list of threads that need processing time and as one

I have run simple parallel algorithm drawing the mandelbrot set to test parallel computations on a Nexus 7 (Tegra 3, 4+1 cores). After running several times I get 1.5 seconds for serial and 1.0 for parallel, but parallel and serial come really close to each other at 1.3 seconds. The square is 700x700 pixels, and the mandelbrot code I use is from http://rosettacode.org/wiki/Mandelbrot_set#Java The parallel implementation runs two halves of mandelbrot like this public void mandelbrotParallel() { Thread t1 = new Thread(new Runnable() { public void run() { mandelbrotOne(); } }); Thread t2 = new

From the documentation for GNU make: http://www.gnu.org/software/make/manual/make.html#Parallel When the system is heavily loaded, you will probably want to run fewer jobs than when it is lightly loaded. You can use the ‘-l’ option to tell make to limit the number of jobs to run at once, based on the load average. The ‘-l’ or ‘--max-load’ option is followed by a floating-point number. For example, -l 2.5 will not let make start more than one job if the load average is above 2.5. The ‘-l’ option with no following number removes the load limit, if one was given with a previous ‘-l’ option. More

Say if I have a processor like this which says # cores = 4, # threads = 4 and without Hyper-threading support. Does that mean I can run 4 simultaneous program/process (since a core is capable of running only one thread)? Or does that mean I can run 4 x 4 = 16 program/process simultaneously? From my digging, if no Hyper-threading, there will be only 1 thread (process) per core. Correct me if I am wrong. That's basically correct, with the obvious qualifier that most operating systems let you execute far more tasks simultaneously than there are cores or threads, which they accomplish by

I am playing around with haskell, starting with simple plotting programs to wet my feet. I need a library that will let me save a 2D array/vector to an image file. I don't want to write a list of colors. I want to use containers that are meant for array/vector like computations and can be (well, almost ) automagically parallelized. EDIT Ability to store color images is a must. I'd start with PGM library. This is a very simple uncompressed graymap format. Almost no additinal dependencies. You can convert PGM to other formats with ImageMagick or other tools. PGM supports generic IArray interface