PowerMacInfo info
Diller
MP SDK)? It displays a great deal of information about my MP system.
However, I don't understand most of it. And I don't believe some of it...
Has anyone seen documentation or source code?
Thanks,
Diller
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Rene Vega
Diller wrote:
> Does anyone remember the MP demo program "PowerMacInfo" (distibuted in the
> MP SDK)?
Yes. I am most familiar with it.
> It displays a great deal of information about my MP system.
Indeed it does but not just MP systems. It displays the nanokernel metrics,
exceptions, multitasking activity, etc.
>
> However, I don't understand most of it. And I don't believe some of it...
Like what?
> Has anyone seen documentation or source code?
Yes. I wrote a bit of it as have others.
The source code isn't available because it references internal data
structures that are subject to change. A lot of what it acquires by means of
internal structures was made public by way of the MPExtractTaskState
function. PowerMacInfo has not been converted to use the public interfaces
and since it is a low priority tool (relative to all the other things needing
to be completed) I doubt if any more attention will be given to it.
Rene
René A. Vega
Diller wrote:
> Does anyone remember the MP demo program "PowerMacInfo" (distibuted in the
> MP SDK)?
Yes. I am most familiar with it.
> It displays a great deal of information about my MP system.
Indeed it does but not just MP systems. It displays the nanokernel metrics,
exceptions, multitasking activity, etc.
>
> However, I don't understand most of it. And I don't believe some of it...
Like what?
> Has anyone seen documentation or source code?
Yes. I wrote a bit of it as have others.
Diller
>> However, I don't understand most of it. And I don't believe some of it...
>
>Like what?
Is the program fully functional on systems after 8.5? I wonder if the
internal data structures haven't already changed. I don't believe the
program is entirely trustworthy because it says the processors are running
at 195 MHz. Even the Apple System Profiler knows it's 225 (yes, it's that
old...). There are other things that don't quite make sense. Some tasks
are shown with only 2 'Prmptns' (preemptions?), yet they seem to be
sharing a CPU. No preemptions suggests no sharing.
>> Has anyone seen documentation or source code?
>
>Yes. I wrote a bit of it as have others.
...
>The source code isn't available because it references internal data
>structures that are subject to change.
OK, so you saw her naked. If there aren't going to be any updates, and
the source is secret, is there at least some documentation available? For
mere mortals? There could be some useful info in there. At least I would
like to know the meanings of the heading on the Multitasking screen. In
particular, what is that first column ('.*01')? And how do I distinguish
between the 2 CPUs?
meeroh
dr...@slonet.org (Diller) wrote:
>And how do I distinguish between the 2 CPUs?
You open the "CPUs and floppies" control panel, click on the "Arrange
CPUs" button, and then click on the "Identify" button. If you then look
inside the case, you will see that one of the CPUs will have "1" written
on it, and the other will have "2".
If you hold down the option key, you can drag a smiley face from one to
the other. The one with the smiley face will be the one that crashes.
If you drag the CPUs on top of each other in the Arrange panel, then you
will enable CPU Mirroring, meaning that both will run exactly the same
code.
Hth :-)
meeroh
--
The contents of text files in a folder called "Random Signatures" in your Preferences folder are used as random signatures.
Bob Bradley
> In particular, what is that first column ('.*01')? And how do I
> distinguish between the 2 CPUs?
* means the task is running.
. means the task is ready.
(space) means the task is blocked.
The number immediately to the right is the CPU of the task (0 = first, 1 =
second, etc.).
Keep in mind that tasks dynamically migrate between CPU's depending on
load and the information shown in PowerMacInfo is a periodic sampling so
it only reflects the task state at the time of the sampling and it is very
likely to have already changed by time you can read it.
René A. Vega
Diller wrote:
> Is the program fully functional on systems after 8.5? I wonder if the
> internal data structures haven't already changed.
The early versions of PowerMacInfo will probably not work well on newer systems.
The latest version 1.7d5 should work on all systems. Items not supported are
ghosted.
> I don't believe the
> program is entirely trustworthy because it says the processors are running
> at 195 MHz. Even the Apple System Profiler knows it's 225 (yes, it's that
> old...).
Some machines prior to 8500s had problems determining the CPU frequency. ASP
worked around that. So, yes, on very old machines, PowerMacInfo could report
incorrectly. The CPU frequency problem in the system was fixed somewhere around
the time of the 8500s, but the number is always adjusted to its marketing value.
Thus a 499.92MHz machine reports as 500MHz as would a 501.1MHz machine. Crystals
drift, ya know.
> There are other things that don't quite make sense. Some tasks
> are shown with only 2 'Prmptns' (preemptions?), yet they seem to be
> sharing a CPU. No preemptions suggests no sharing.
If a task is blocked for a long period it obviously does not get any processor
time, so yes it is possible the preemption count is low. Also the cpu number
shown is a snapshot. If a task is blocked the number incidate which CPU the task
was running on at the time it blocked. If a task is ready or running, the CPU
number is just a snapshot at the time the stats were displayed. A task could
have bounced between CPUs hundreds or thousands of times between snapshots.
The low preemption number is especially the case for watchdog tasks that
initialize then wait for some exception situation to arise. In OS 9.x, every
application that creates at least one preemptive task (aka an MP task) will have
one death watch task created 'deth'. This task remains blocked until on or more
of the app's tasks terminate. The death watch task cleans up resources so it may
stay blocked for hours. When blocked, the death watch task takes zero processor
time and occupies about 3KB of RAM.
The system itself creates several tasks. The blue task is where the upper layer
OS runs. That includes the process manager, finder, all cooperative apps, and
the 68K interrupt handlers. The idle task (one per processor) is a sink running
only when there are no ready tasks on a processor. The idle task is a loop
calling a low level power management function in the kernel to place the
processor in low power mode, hence the processor is in low power mode whatever
percent of the time nothing is happening. The dbgr task is created by Macsbug.
That task registers itself as a debugger to catch MP task exceptions. Yes you
can debug MP tasks with Macsbug. The ager tasks run periodically to age pages
creating a working set profile. The accu task corrects time base clock drift.
The powr task performs various high level power management duties. It basically
is part of the processor cycling feature.
Colorsync creates tasks when adjusting the color space. Several QuickTime codecs
create tasks to decode DV streams. Final Cut Pro, SoundJam, iTunes, Photoshop,
etc. create tasks to run various algorithms in parallel.
> ...is there at least some documentation available? For
> mere mortals?
Yes, I'm working on some documentation, but for now:
Cpus: x Scheduled CPUs: x Total opaque
IDs: 0
Total tasks: x Pool extends: x
C Task Task Blocked Task Task Code Data
Task Task
P ID Name ID Q PR Weight Time Fault Fault
Preemptns SP
_ ________ ____ ________ ____ __ ______ ____________ ____ ______ ______
_________ ________
x xxxxxxxx xxxx xxxxxxxx xxxx x x 0:00:00.000 0% x x
x xxxxxxxx
Cpus - The number of processors in the machine. The nanokernel is written to
handle any number of processors dynamically. The practical limit is 16 before
some specific tuning is required. The most processors it has ever run is 4 on a
Daystar Genesis machine (oh yes, there's that rumor about the 24 processor
prototype. I'll never tell).
Scheduled Cpus - The number of processors online and being scheduled. The
nanokernel can add or withdraw processors dynamically. This happens on some MP
systems when processor cycling is enabled. If the system utilization is low, all
processors but one are withdrawn from scheduling and placed asleep.
Total opaque IDs - The number of IDs currently in use. All MP objects: address
spaces, areas, processors, memory coherence groups, queues, semaphores, critical
regions, event groups, timers, notifications, etc. are assigned an ID when
created, and they are accessed by way of this ID. The kernel presently handles
65,000 simultaneous IDs with a bit pattern reuse probability of 1 in 4 billion.
Total tasks - The number of created tasks in the system.
Pool extends - The number of 4 KB pages given to the nanokernel for its internal
structures.
CP - A snapshot of the processor in which a task was or is running. 0-first,
1-second, 2-third, etc.
'*n' means the task was executing on processor n.
'.n' means the task is ready and is/was scheduled to execute on processor n.
' n' means the task is blocked and was running on processor n.
Note that scheduling is event driven. A task could easily jump between
processors thousands of times per second, though the scheduler tries to avoid
that when feasible. PowerMacInfo displays a snapshot of the task's run history.
TaskID - The opaque ID of the task.
Task Name - a four byte arbitrary name. It can be set by calling MPSetTaskType()
but the default name is inherited from the app's creator code.
Blocked ID - If the task is blocked, this is the ID of the blocking object.
Task Q - The residing queue name of the task. A task is always queued on
something. If it is ready or running, it resides in the ready queue. If if is
blocked it resides on the blocking object's queue:
RDYQ = ready queue
MSGQ = message queue
SEMA = semaphore
CRGN = critical region
EVNT = event group
DBUG = suspend queue
PAGQ = page fault queue
PR - The task's priority. There are only four priorities: 0-3 with 0 the
highest. The nanokernel scheduler uses these priorities to implement constraint
base real time objectives.
0 - critical
1 - latency protection
2 - nominal
3 - idle
Tasks usually run at priority 2. Newly unblocked tasks run at priority 1 for a
bounded time. Some 68K interrupts run at priority 0. The idle task(s) always run
at priority 3.
Weight - The relative share of a task. A task is given time slice ratios equal
to its weight divided by the total weights of all ready tasks to control its
throughput. The overall time slice depends on the number of ready tasks.
Task Time - The accumulated processor time since the task was created. The
percentage is the task time average for the display interval
Code fault - The number of instruction fetch related page faults the task has
taken.
Data fault - The number of data access related page faults the task has taken.
Task Preemptns - The number of times a task has been preempted from running on a
processor either because it blocked itself, some other task of higher priority
took over, or it was time sliced.
Task SP - A snapshot of the task's stack pointer.
-------
Rene'