Response vs. performance
'Responsiveness' of an interface has two elements: The size of a timeslice, and the event handling model. It has nothing, directly, to do with SMP. UNIX folks have long enjoyed 'responsiveness,' and x86 folks generally went through this phase of thread-obsession in 1992 when OS/2 2.0 was released; again when NT 3.1 came out in 1993, and again when Win95 brought threading to the average Joe.
You should note that SMP was not common at those times.
The primary reason for the increased responsiveness of these systems was that the GUI no longer ran in a single 'thread' or 'process' (these are almost the same thing to a CPU), therefore an app that spent a long time processing an activity would not prevent the GUI from updating or responding. I'm sure the old Macs suffered from this in some way.
The key factor of responsiveness at the OS-GUI level became how quickly a thread could become the active thread; the longer a timeslice given to a thread, the longer it takes for the next thread to get active. The tradeoff is that you can have very short timeslices, and then waste all of your CPU in the switching overhead. The only benefit you get from SMP is that since you obviously have twice as many timeslice switches, you can theoretically cut your response time in half. The tradeoff still exists though; instead of simply doubling your speed with the same number of context switches (one CPU twice as fast), you've doubled your speed, but also doubled your context switches (two CPUs, same speed). This is an example of Amdahl's Law.
Now, the event model is the other key factor, and it is generally a given that you are going to at least not kill the whole OS-GUI once you have a true multitasking OS. The app creator can continue the effort and ensure that the app itself never freezes its own GUI either by multithreading itself. This is not really done to benefit from SMP; the benefit is achieved on a single processor as well. The actual code of what the app does is not automatically multithreaded, even if some GUI threads happen to automatically be created by the frameworks. The programmer would have to decide it was worth the effort to write certain parts in a multithread manner, and it would still be subject to Amdahl's Law.
I'm not sure what 'monitors' are; perhaps you refer to Java VM, perhaps to waiting for something to happen in general. But they are almost never implemented as a continuous CPU intensive polling effort. Instead, they almost always end up simply waiting for the OS to inform them that something has happened. This requires very little CPU power.
It also is rare that apps are 'given' a single CPU (called CPU affinity). Solaris allows it(perhaps Linux 2.6?), but the application (or admin) also has to specifically ask for it. It is common on applications where the cache is more important than CPU speed; database is a common one. Instead, the usual process is that threads or CPUs end up hopping among CPUs, so the shorter your timeslices, the greater chance the CPU cache gets thrown out and wasted. Another example of Amdahl's Law.
The bottom line is that multithread responsiveness is not a justification for SMP; SMP is only worth it when you've got specific apps that do not suffer as much from Amdahl's Law, such as some of the video apps you mentioned. The industry is being forced into SMP by difficulty making a single CPU run faster. If SMP was better than faster CPUs, Intel would have happily sold twice or quadruple as many CPUs in each computer since 1996 when NT 4.0 started showing up on advanced users desktops.
maxvamp said:
I have seen written several times on this thread alone that most, if not nearly all programs are single threaded. I then get told I am getting too excited.
...
While none of these apps will bring down a processor alone, the monitors they have , if each put into a single thread would bring down this system with just this select few apps open. Threading will keep the system responsive, even though the processors are not staying at 100%.
There are other aspects to threading besides driving the CPUs all at 100% for every action, and most apps now are multithreaded. To say otherwise, no matter what the context is a lie.
...
Max.