🚀 go-pugleaf

In article <nevin-0602962253080001@150.135.1.79>, nevin@CS.Arizona.EDU
(Nevin ":-]" Liber) wrote:

>So, you can't figure out how to get this to work well on a Mac, eh? 
>Hmmmm...  <in deep thought for 4.2 seconds>  How about putting a
>WaitNextEvent() call in one of the inner loops of
>do_the_computationally_intensive_useful_work();?
>
>Is this really rocket science for you, Kevin?

I doubt it's rocket science for him.  However, WaitNextEvent() is not a
panacaea.  The true advantage of PMT in this respect is that it works well
automatically with no effort by the app programmer.  With CMT, the
programmer has to ensure that the processor is released at reasonable time
intervals.  If you aren't careful about how much processing you do between
calls to WaitNextEvent(), you can end up sucking down all the system's CPU
time or getting nearly none at all.  Worse, every time you add something
to an algorithm, or optimize it, or do anything at all that changes how
fast it executes, you have to retune your WaitNextEvent() calling
frequency.  If you want to do it in a generally correct way, you have to
start looking into Time Manager calls so that you can check how many
milliseconds have passed since the last call.  Now you've got some
inefficiency from calling the Time Manager, and you've easily gotten into
a realm that the scientific programmer isn't interested in figuring out at
all...

Mind you, I like the Mac and the MacOS, but I view its lack of preemptive
multitasking and memory protection as obvious and glaring weaknesses. 
Trying to bury your head in the sand by ignoring the very real
difficulties for the application programmer under CMT doesn't make the
problem go away.

If you're a scientist who wants to whip out a quick little program that
does some matrix ops on some rather _large_ data sets (say, multiple
megabytes), while still being able to word process in the foreground
without difficulty, the MacOS is much harder to use than UNIX.  Under
UNIX, you write the processing algorithm, compile it, fire it up, and go
off to do whatever floats your boat while your code grinds away.  Under
MacOS, you write the processing algorithm, try to figure out a good way to
stick in the WaitNextEvent() calls, spend at least a half-hour fiddling
with it to get good responsiveness from foreground apps, and then go off
to work on other things.

+-----------------------------------------------------------+
|Tim Seufert, bwanga@cats.ucsc.edu | UselessWastedSpace(tm) |
| "I never give them hell. I just tell the truth, and they  |
|  think it is hell."  -Harry S Truman                      |
+-----------------------------------------------------------+