multi threading

[Nineballo]

could it be possible to have a software layer directing single threaded programs to spread the load across multiple cores without the program really knowing(for compatibility) then directing the then processed information back into the program as one thread?

[Cereal5]

I think you're over thinking it... What would this be used for?

[Nineballo]

help spread the load across the whole cpu i think this would come in handy with the crazy core count cpus (24+ cores) because the speed of the individual cores isn't great but if you could have them all working together it might be able to do something.

 

 

im just dipping my feet into programming and thought of this figured i might as well see if this would make sense or change anything.

 

[Nineballo]

diagram of a single threaded program

 

                                 program

                                     | single thread

      layer -->    --------------------------

                         /    /   /   /    \   \  \  \  \      split between in this case 9 cores

 CORE # -->    1    2  3  4    5  6  7 8 9

 

does it kinda make scene now?

 

[Nineballo]

im tired maybe this just is completely wrong...

[WereCatf]

20 minutes ago, Domi-Nate said:

could it be possible to have a software layer directing single threaded programs to spread the load across multiple cores without the program really knowing(for compatibility) then directing the then processed information back into the program as one thread?

Short answer: no. Longer answer: if it was e.g. an interpreted language or a VM-based thing, like e.g. Java, the interpreter/VM itself could be multithreaded and some specific operations could be spread to other cores/threads, but it's still not quite the same thing as you're thinking of.

[Nineballo]

aight thx for the answer

[Mira Yurizaki]

46 minutes ago, Domi-Nate said:

could it be possible to have a software layer directing single threaded programs to spread the load across multiple cores without the program really knowing(for compatibility) then directing the then processed information back into the program as one thread?

In theory, you could as certain parts of a program are self contained chunks you could consider as miniature programs. Though this would require said software to look ahead and see what the program is doing and evaluate whether or not there's no dependencies. This would probably take longer to do than if you were to just do it.

 

Though I think certain code-morphing systems like Project Denver can do something like this.

[vanished]

Given a typical program that's probably not already multi-threaded to the maximum possible degree, in theory this could be done, but there's two issues:

• The processor or some other mechanism would have to figure out what parts of the program can be split up on the fly.  I can't even imagine how difficult (not to mention demanding) this would be.
• At some point, you get down to indivisible workloads.  At this point there's just no way to split it further.  If you could, that would really be a holy grail of sorts since no longer would CPUs have to trade off between multi-core and single-core performance - any task could just use the whole CPU and it would be amazing.

[Franck]

5 hours ago, Ryan_Vickers said:

Given a typical program that's probably not already multi-threaded to the maximum possible degree, in theory this could be done, but there's two issues:

• The processor or some other mechanism would have to figure out what parts of the program can be split up on the fly.  I can't even imagine how difficult (not to mention demanding) this would be.
• At some point, you get down to indivisible workloads.  At this point there's just no way to split it further.  If you could, that would really be a holy grail of sorts since no longer would CPUs have to trade off between multi-core and single-core performance - any task could just use the whole CPU and it would be amazing.

it would be difficult and would cause a crap ton of context switching where instruction does not except one to happen. I know for a fact on a VM server you can fake 1 core to show as 2 but i have never seen the inverse and anyhow that crazy split is quite a big performance hit.

[reniat]

Autovectorization is a thing in compilers, though it's probably not quite as effective as what you are looking for and it can't work on existing binaries (aka you couldn't take an application and emulate your way to threading). It's like an extension to loop unrolling, where it takes the unrolled loops and tries to parallelizee them, but it's not a smoking gun as it's actually pretty unlikely that you can just take source code written without any threading in mind, apply the autovectorizer, and get meaningful improvements, and sometimes it can actually make things worse.

https://msdn.microsoft.com/en-us/library/hh872235.aspx
https://en.wikipedia.org/wiki/Automatic_vectorization

[wanderingfool2]

16 hours ago, Ryan_Vickers said:

Given a typical program that's probably not already multi-threaded to the maximum possible degree, in theory this could be done, but there's two issues:

• The processor or some other mechanism would have to figure out what parts of the program can be split up on the fly.  I can't even imagine how difficult (not to mention demanding) this would be.
• At some point, you get down to indivisible workloads.  At this point there's just no way to split it further.  If you could, that would really be a holy grail of sorts since no longer would CPUs have to trade off between multi-core and single-core performance - any task could just use the whole CPU and it would be amazing.

Actually, this is sort of like speculative execution (the good ol' thing that led to Spectre and Meltdown).

 

In general to the original topic creator.  In theory you could create a program that looks ahead in the code and starts execution of code that is thought to be run or independent from the currently running code, but the issue with programs written in single threads is that they tend to just share data (which means you can't just separate them and run the code, without probably doing some very tricky analysis, but this would probably be slower than just running the thing anyways)