What’s New
Welcome to the Pooch manual! Pooch has been updated. New features include:

version 1.7:

• Universal Binary for running on mixed clusters of Intel- and PowerPC-Macs
  
  • manages both types of nodes, making all cluster data available
    
  • launches Universal binaries, enabling cross-processor clustering; Pooch is the first and only clustering solution to launch Universal Binaries in parallel
    
• Remote job, file, and folder retrieval support, even through proxy nodes
  
• New Job file format support, including saving and loading job data
  
  • save commonly used jobs, file and node combinations, to disk
    
  • supports standard file dialog and reminder sheets
    
• Head node setting to access and control clusters with Linux-style topologies
  
  • accesses nodes behind a head node acting as a firewall and NAT router
    
  • coordinates Pooch features to launch jobs via the head node
    
• Enhancements to the AppleEvent interface for job and user data
  
• Automatic detection and retry of preferred IP address of remote nodes
  
• Pooch Pro automatic user login using Keychain services
  
• Other features, enhancements, bug fixes, and updates
  

Please read on for more!

Pooch Application

Parallel OperatiOn and Control Heuristic Application
Version 1.7



Copyright © 2001-6 Dauger Research, Inc.

Code and manual written by Dean E. Dauger

I. Installing Pooch ·············································3

II. Your First Parallel Computation ·············································4

III. Introduction ·············································7

IV. Menus and Windows
Menus ··········································12
Job Window ··········································24
Network Scan Window ··········································35
Node Info Window ··········································48
Get Files Window ··········································49
Node Registration Schedule Dialog ··········································50

V. Pooch Pro ··········································51

VI. AppleScript
Standard Suite ··········································63
Pooch Suite ··········································67

VII. Security ··········································71

VIII. Frequently Asked Questions ··········································73

IX. Revision History ··········································78

X. Credits ········································106

XI. Contact Information ········································107

A. Compiling the MPIs ········································108

Step Two - Selecting Nodes

By default, Pooch selects your own node as participating in the parallel job. To add other nodes, click on Select Nodes… in the Job Window to invoke the Network Scan Window.

Double-clicking on a node moves it to the node list of the Job Window.








Step Three - Launching the Parallel Job

Finally, click Launch Job to start your parallel job.

Pooch should now be distributing the code and starting the parallel application. Once the job runs, you should see a measurable performance increase.

Congratulations! You are now operating your first parallel computer.

Optional - Your Second Parallel Computation

1. Open version 1.1 or later of Power Fractal. Note its performance.
2. From the Parallel menu, select “Automatically Launch onto Four Nodes”.

The demo will now automatically ask Pooch to create a job using the four best nodes on the local network, then submit itself for parallel launch. This is an example of “Computational Grid” computing.

• A dedicated Macintosh cluster - Perhaps the simplest configuration, a group of eight, sixteen, or thirty-two identical Macintoshes or Xserves devoted to computation at all hours of the day. Pooch enables members of your group to submit jobs to the cluster and retrieve the output at a later time. Also, a subset of the nodes can be used for one job while a second job runs on the others. Many, including UCLA’s Department of Statistics and NASA’s Jet Propulsion Laboratory, have clusters like this.
  
  
• Reusing a network of individual Macs for computations - There are secretaries, scientists, artists, and professors using their own Macs for e-mail, spreadsheets, web browsing, and word processing during the day. After they leave for home, the Macs are usually idle and unused. Merely with the addition of Pooch, this network of Macs can become a computational cluster at night or on weekends.
  
  
• Combinations of dedicated and individual Macs - A few Macs, perhaps four at a time, can be added to an existing network of Macs as described in the preceding example. The groups of four devoted computational nodes can be used for debugging and diagnosing an experimental parallel code during the day, but then the entire network can be combined in the off-hours for larger (and well-tested) parallel codes. As new hardware is purchased, the compute nodes are mixed with the rest of the population as needed. This more dynamic model is in practice in the Plasma Physics group at UCLA. This setup is well suited for a circumstance where, often, the groups of four are enough for most computations, but occasionally a member of the Plasma Physics group needs to complete some large runs to meet, for example, a conference deadline. So this researcher asks the group and gets time on the entire network. This flexibility has saved the day for more than one researcher’s work.
  
  
• Be creative: You may find additional scenarios useful. For example, from a PowerBook connected to the Internet via Airport, the author has initiated and controlled, in real-time, parallel jobs computed over 40 miles away. Using a network connection at the Max-Planck-Institut für extraterrestrische Physik in Garching, Germany, the distance record has increased to 6000 miles.
  

• New Job… - Opens a new Job Window (see the Job Window section)
  
  
• New Queue Job… - Opens a new Job Window enabling the Queue Job and Automatically Acquire options.
  
  
• Save Job As… - Saves the job of a Job Window to a file on disk, which can later be used for another job. New in 1.7.
  
  
• Select App and Files… - Opens a get files dialog for selecting an application and files for the Job Window. If the Job Window is present, the file dialog will appear as a sheet. If the Job Window is not present, the dialog will be standalone, but if a file is selected it will be added to a new created Job Window.
  
  
• Reveal Remote Files Folder in Finder - When Pooch receives files from another node, Pooch must hold the files in a folder on the hard drive. Invoking this item directs the Finder to open that folder where those files are being held. See Collect Remote Files. Also, this item is available by control-clicking the Pooch icon in the Dock.
  
  
• Select Nodes… - Opens the Node View of the Network Scan Window (see the Network Scan Window section)
  
  
• Show Job View… - Opens the Job View of the Network Scan Window (see the Network Scan Window section)
  
  
• Recent Node Lists - When the Job Window is open, this submenu lists the node lists of the most recently launched jobs. The number before the “:” is the number of nodes. When the node names have similarities, Pooch attempts to abbreviate the names. For example, a node list of four computers named node01, node02, node26, and node27, will be abbreviated to “4: node01, …02, …26, …27”.
  
  
• Recent Apps and Files - When the Job Window is open, this submenu lists the file lists of the most recently launched jobs. The number before the “:” is the number of files. If one of the files is an executable that was launched, it will be listed first.
  
  
• Set Pooch in Account Startup Items - Makes (or updates) an entry for Pooch in the Login Items system preference so that Pooch will automatically start up and make this Mac available for parallel computation after a restart. This feature is provided as a convenience.
  
  
• Collect Remote Files In - When Pooch receives files from another node, it must store those files in a folder on the hard drive. Pooch can hold those files either: 1. in the folder where the Pooch App itself resides; 2. inside the Temporary Items folder, as designated by the OS; 3. in the path /tmp/pooch, which is the default case on OS X; or 4. in the path /Users/Shared/pooch/remote. Note that files in /tmp may be deleted when the machine is restarted.
  
  
• Open Pooch Log - Opens the Pooch Log in Console.app. Pooch logs events into a text file located at /Users/Shared/pooch/poochlog.txt. These entries detail steps in the launch process, the queuing system, and network access.
  
  
• Quit Pooch - Selecting this item, or pressing Command-Option-Q, will quit Pooch. Pooch is an unusual application because, while its user interface is not in use, it is meant to run at all times in the background. This mechanism will make it less likely to be quit accidentally.
  
  
• Finder to the Foreground - Selecting this item sends Finder to the foreground.
  

• Paste - Invoking this item in the Job Window pastes an item on the clipboard into its file pane. Launching such a job distributes the clipboard to the clipboards on the target nodes. In the Network Scan Window, this pastes into the remote network address field. Modified in 1.7.
  

• Get Node Info - Invokes a Node Info Window that retrieves a variety of information about a node, such as processor type, OS version, load, and free memory. It also retrieves a list of running processes (an application is one type of process) on that node.
  
  
• Get Job Queue - Retrieves the parallel jobs queued on that node. Typically, a job is forwarded to the Pooch at the job’s node zero and held there until certain conditions have developed. For example, a job might start only when its designated start time has passed and the target nodes are no longer busy.
  
  
• Get Files - Opens a new window where you can retrieve files from the remote node.
  
  
• Connect to Server... - Opens an Apple File Sharing connection to that node, much like the menu item of the same name in the Finder. If that node has File Sharing on, you can enter your password to access files on its volumes. This feature is provided for your convenience.
  
  

• Register this Node - Pooch, by default, registers its node on the network, meaning that it puts up a flag that other Pooches can see. This flag has enough information for other Pooches to identify and communicate with this particular Macintosh. Selecting “Never” removes this flag, making this Pooch invisible to other Pooches. Selecting “On a Schedule…” opens a node registration schedule dialog (see below). Pooch will then register and deregister itself according to the specified schedule.
  
  
• Local Scan Includes this Node - When scanning for nodes in the local network, selecting Always will cause Pooch to always add itself to the network results, regardless of the Register this Node settings. Otherwise your node might not appear in the local network scan if your Pooch did not register itself. Selecting Always does not cause other Pooches to see your node.
  
  
• On Node Deregistration - When Pooch deregisters itself, Pooch will kill all jobs it is tracking on this node if Kill All Jobs is checked. For example, when this node deregisters itself according to the node registration dialog (see “On a Schedule…” of the “Register this Node” submenu, above), Pooch will kill any remaining jobs that it launched. If this menu item is not checked, Pooch will allow jobs to continue to their own completion.
  
  
• Primary Address - This submenu specifies which active IP address Pooch registers as “primary” or the default address. Use System Default has Pooch follow the precedence specified by the system, usually set via the port ordering in the Network system preference. Setting this to another IP address, if available, resets Pooch’s network registration of this node to the new setting. It will encourage, but not guarantee, that other Pooches and their jobs will use that address, perhaps because of its more optimal performance. Pooch will still listen on the other addresses, as not every IP address will be accessible from other nodes. New in 1.6, selecting the Import Addresses… option selects a whitespace-delimited text file containing additional addresses that identify this node. This is appropriate when, for example, a firewall redirects activity from a public IP address to a private one.
  
  
• Network Scan Columns - This submenu allows you to show and hide columns in the Network Scan Window. Check and uncheck the items to toggle them. See the Network Scan Window section for descriptions. Selecting “Show Columns…” opens a window where multiple columns can be toggled at once.
  
  
• Automatic Rescan - When the Network Scan Window is open, Pooch will automatically repeat its scans on the network at a particular interval. You can set this time interval, or shut off the automatic rescan, by selecting an item on this menu.
  
  
• Job View Access Time - This setting determines how far back in time the Network Scan Window, when in Job View, will query when compiling archived job information.
  
  
• Discover using - Since its birth, Pooch used Apple’s implementation of the Service Location Protocol (SLP), an IETF standard, to perform discovery of other Pooches on a TCP/IP network. In May 2002, Apple introduced Bonjour (formerly Rendezvous), also known as ZeroConfig or mDNS, to perform discovery as well. The latest version of Pooch uses both to discover on a network. For best compatibility, the default setting uses both SLP and Bonjour so that this Pooch can discover and be discovered by Pooches running on OS’s that do not support Bonjour (such as OS 9). You may select Bonjour Only if you know you will only be using Macs running OS X 10.2 or later. The benefit of using only Bonjour is faster discovery, but its drawback is not being able to locate Macs running older versions of the Mac OS.
  
  
• Access Nodes - Normally Pooch contacts other nodes directly to inquire about their status. A node accessed using the Remote Node Scan feature could return the addresses of nodes behind a firewall or other network barriers. Selecting via Proxy will use the proxy connection provided by the first remote node to forward data between your local machine and those behind the firewall. New in 1.6 and available only on OS X 10.4 “Tiger”, Pooch can access an Xgrid cluster. To access Xgrid, enter the host address of the Xgrid controller and its password using the via Xgrid… item of this submenu. If no password is required, leave that field blank. Pooch spawns jobs containing a piece of itself through Xgrid, which Pooch can then discover and access.
  
  
• Remote Network Job Access - Normally Pooch on other nodes contacts yours directly to forward jobs and files. For example, a node accessed using the Remote Node Scan feature might not be able to return files to your nodes because of firewalls or other network barriers. This feature permits the Network Scan Window to pull these files onto your machine. Typically this is used in combination with the via Proxy setting of the previous item. None turns off this feature, Only My Jobs accesses only jobs that resulted from a job from this node and user, typically a job triggered by Retrieve Output job option (see Options of the Job Window), while All Jobs will pull all jobs destined for this node. If the name and IP address of your node changes, then this feature might not successfully locate the jobs. New in 1.7.
  

• New Job Automatically Reloads - When the Job Window is created, it will remember information, such as the file list (including the application), the node list, and various job options, from the last parallel job submitted. This submenu toggles what portions of the last job it will retain and what it will discard. Note: some of this information may become stale, such as when you move the app on your hard drive or if a node has a dynamic IP address (which could happen if your network uses DHCP). Extended in 1.7. Selecting On Job Submit triggers a new job to invoke as soon as the previous job is submitted to the launch queue. New in 1.7.
  
  
• Remember Recent Node Lists - This setting determines how many node lists will be displayed in the “Recent Node Lists” submenu of the File menu.
  
  
• Remember Recent Apps and Files - This setting determines how many lists of apps and files will be displayed in the “Recent Apps and Files” submenu of the File menu.
  
  
• Job Port Number Range - When Pooch launches a job it pseudorandomly assigns a primary TCP port number to the job for its communications. Normally Pooch chooses from 16384 up to 49152. You may specify a different range of port numbers here, say, for compatibility with a firewall. The Use Port Number… option in the Job Window overrides this setting.
  
  
• Launch Unix Jobs - By selecting in the Background, Unix-based executables (such as Mach-O executables and Unix scripts) are launched in the background, with output directed to a stdout.txt file. Selecting using Terminal directs this Pooch to launch Unix-based executables in a window of the Terminal app, allowing for user-input. This setting is local to this node: the launch on the remote nodes will use Terminal instead of background launching if using Terminal is checked on those nodes as well.
  
  
• Restrict/Allow Access to Local Processes - When this item is set to restrict, Pooch will block other nodes from seeing process IDs of processes not launched by Pooch. This prevents someone else from using the Node Info window to kill, say, your word processor. Use this item only if you wish to restrict control of processes on this node by other Pooches.
  
  
• Accept Pooch Commands from - When set to Local Subnet, Pooch will check the IP address of incoming connections against its local subnet. If they do not match, the connection will be rejected and this Pooch’s listener port will reset. Selecting Import Addresses… allows you to select a whitespace-delimited text file containing a list of IP addresses. Pooch will compare the addresses of incoming connections against this list, including the resolution of DNS data. Setting to Any Address removes this restriction. Use this item only if you do not want to control this node from other subnets of the Internet.
  
  
• Reject/Accept Remote Preferences Command - When set to accept, other Pooches will be allowed to overwrite this Pooch’s preferences and settings. For example, the node registration schedule may be modified remotely. When set to reject, other Pooches will not be allowed to modify settings of this Pooch.
  
  
• Disable/Enable Pooch at Logout… - Selecting this item will direct Pooch to run while nobody is logged in. This feature makes it possible to use unutilized, logged-out machines for parallel applications. Pooch automatically quits when someone logs in and will return when the user logs out or if they run Pooch. Toggling this item may require administrative authorization. The words “(To Be Enabled On Restart)” will be appended if it is necessary to restart the machine to fully enable this feature. Updated in 1.7.
  
  
• Disable/Enable Verbose Error Reporting - Reports internal errors, such as network errors, in notification windows. The information reported most useful when diagnosing difficult-to-find problems during Pooch operation. It also reports a problem when Pooch encounters AppleScript objects or commands that it cannot recognize.
  
  

• About Pooch… - displays the About Box of Pooch, which also can contain status messages. This window normally opens briefly, then closes on its own, at startup. Clicking on the window closes it.
  
  
• Preferences… - displays the Pooch Preferences window. This window displays all of the preferences available in Pooch. These settings are divided into three categories: General, Nodes, and Jobs. Updated in 1.7.
  

General Preference Pane

Clicking on the icons in the toolbar at the top of the window switches the Preference Window to the other panes. It is normal for this window to disappear when Pooch is in the background. For backwards compatibility, the Settings Menu is shown by default.

Remote Head Node - This preference modifies and coordinates four elements of Pooch’s behavior to support launching jobs into and retrieving files from a cluster with a designated head node. If this feature is enabled, the default Network Scan window scans the head node’s network instead of the Local network, the Forward via job option chooses the head node, the Retrieve Output and Queue Job options are enabled, the Access Nodes via Proxy setting is enabled, and the Automatically Acquire Nodes job option automatically selects the head node as the starting node. New head node IP addresses can be entered via the address field of the Network Scan window. New in 1.7.

Nodes Preference Pane

Remote Network Job Access - Normally Pooch on other nodes contacts yours directly to forward jobs and files. For example, a node accessed using the Remote Node Scan feature might not be able to return files to your nodes because of firewalls or other network barriers. This feature permits the Network Scan Window to pull these files onto your machine. Typically this is used in combination with the via Proxy setting of the previous item. None turns off this feature, Only My Jobs accesses only jobs that resulted from a job from this node and user, typically a job triggered by Retrieve Output job option (see Options of the Job Window), while All Jobs will pull all jobs destined for this node. If the name and IP address of your node changes, then this feature might not successfully locate the jobs. New in 1.7.

Jobs Preference Pane

Selecting On Job Submit of the New Job Automatically Reloads menu triggers a new job to invoke as soon as the previous job is submitted to the launch queue. New in 1.7.

The Job Window is where all parallel jobs are prepared for launching, scheduling, or queuing. A job requires information about the parallel application you want executed and what nodes will run this application. This window is resizable so it can display large amounts of information.

• File List - The left pane of this window displays the list of files in this job. This list can include an application³ , which, if present, is placed at the top of the list. Additional applications dragged here will be added to the end of the list, but they will not be launched by Pooch. Removing the first application in this list will cause the next application, if present, to shift to the top of the list. Additional files may be added, which some parallel apps use for input data, here. Pooch will distribute these files to the nodes on launch. Pooch is also capable of selecting and copying folder structures⁴ to other nodes. The folder tree will be scanned recursively. Files inside these folders will be copied as well, but only those files present at the moment of launch. Aliases will not be resolved. You may use the Select App… button to invoke a dialog sheet to select an application to execute and files to distribute, or you may drag them from Finder to this pane if you prefer. Use the Remove All button to clear the file list, and select a file or files and click the Remove button to remove individual files.
  
  
• Node List - The right pane displays the list of nodes for this job. Each node you select is assigned to run an MPI task or tasks. Each task is given a unique identification number. The number(s) on the icon to the left of the node’s name indicates which task(s) that node will be assigned. (See the Tasks per Computer job option, below.) This information will be relayed to MacMPI. The parallel code can retrieve this information from MacMPI and use it to partition its problem among the processors. Experimenting with the order of these nodes or the number of tasks can be useful for debugging. Clicking on Select Nodes… invokes the Network Scan Window. You can add nodes to the node list by selecting them in the Network Scan Window or dragging them from that window to this one. Remove All clears the node list, and selecting a node or nodes and clicking Remove removes individual nodes from the list. The limit on the number of nodes is determined when this Pooch is registered. Note: Pooch mandates that your Mac is node zero if it is participating in the computation.
  
  
• Job Options - In OS X 10.3 and later, clicking the Options… button produces a drawer presenting options for this job. Holding down the Options… pop-up creates a menu containing the same options. Only the menu is available on previous OS versions.
  

• Place in Subdirectory… - When sending files to another Mac, Pooch by default places all apps and files within the same folder in which Pooch resides. Over the course of many jobs, the mixture of files can become confusing. Specifying a name here asks Pooch to create a subdirectory inside that Pooch’s folder and place all apps and files in that new subdirectory. (Pooch does not write outside its folder during the launch process.) For the purposes of organization, you can name these subdirectories based on the job name, or the date, or the name of the user who submitted the job.
  
  
• Start Job at Time… - By default, when you submit a job, Pooch will start the job on the specified nodes immediately. This option, however, allows you to have Pooch place the job in the job queue and delay its start until a particular future time, any minute, any day. The job will be held in the queue on the node designated zero in the node list. (So, if your Mac is not node zero, it will be forwarded to that node.) The following shows the dialog that appears when selecting a start time:
  

• Tasks per Computer - Many of the recent Power Macintoshes have more than one processor each, so it would be appropriate to be able to allocate one parallel processing task per processor, enabling parallel computing inside boxes as well as between boxes. By default, this option is set to do just that. You may override this setting by selecting a specific number of tasks per processor. Increasing the number of tasks beyond the number of nodes will probably be less efficient, but this possibility is useful for debugging parallel code. Because multitasking is significantly better in OS X than in OS 9, we recommend launching multiple tasks per computer only on OS X. (By default, Pooch will launch only one task per computer running OS 9.) New in 1.7, control-clicking on the node icon in the node list will override this setting, allowing you to select different task counts for each node.
  
  
• Job Type - This option specifies the type of parallel launch needed for this parallel job. MacMPI, mpich, MPI-Pro, mpich-gm, and LAM/MPI need information about the cluster configuration, but they each require significantly different data formats and launch procedures. The MacMPI launch type is the default. It is generally the case that only Unix-based executables can accept information the way that the other MPIs require it, so Carbon, Cocoa, and most other types of apps will usually follow the MacMPI convention. See below for the Grid Job Type.
  
  
• Command-Line Arguments… - This option specifies command-line arguments to add when launching Unix-style Mach-O executables. Only some Unix-based executables require input information using such options (such as “-a -e iou”), and it is usually preferable to supply such input information via input files for portability. This item will be disabled when the file list contains other executable types.
  
  
• Use Port Number… - In order to use TCP/IP, an MPI needs to use a particular TCP port number to initialize its network connections. Under normal circumstances, Pooch generates a pseudorandom port number based on the job name and the time of day and supplies this number to the MPI. You can use this job option to override that random value and set a particular port number. This feature can be useful to comply with firewalls that only have specific ports open. However, the TCP convention requires that the same port number not be used again for approximately two minutes. Some TCP implementations follow this convention, and some do not, so your network could appear to be blocked if you launch a second job using the same port number too soon.
  
  
• Forward via - Normally Pooch attempts to contact all nodes directly when launching jobs and distributing data. In some configurations, nodes of a cluster could be protected by a firewall or a machine acting as a firewall, such as a “head node”, which prevents this kind of access. This feature allows you to forwarding the job to an “in-between” node, which acts as a proxy. The job will be forwarded to the proxy node, which then forwards it to node 0 in your node list. Usually such proxy nodes should be chosen from the ones used for the Remote Node Scan. (New in 1.5.5)
  
  
• Retrieve Output - Turning this setting on directs Pooch to automatically retrieve files created and modified by a job after Pooch detects that the job has ended. Pooch checks for this condition once per minute, and the queuing system also operates on a one-minute cycle. This feature can be set to only send back the files generated at node 0 or on all the nodes. Pooch will make a “best effort” to place files in the directory on the node where the executable originated. If that node is not available for some reason, the forwarding process will be queued until it is able to complete the task. As needed, the files will be forwarded through the proxy node specified in the Forward via feature, above. New in 1.6, the retrieved files are accompanied by a .joblog text file containing useful information about the job’s execution.
  
  
• Bark - Pooch will not bark when launching a job if this item is unchecked.
  
  
• Don’t Use Busy Nodes - Normally, Pooch checks if the nodes on the node list are already running a job submitted using Pooch. If any of the nodes are running such a job, Pooch will not launch the new job. This feature is useful because a parallel job usually runs best if there are no other jobs running. Unchecking this item disables this feature.
  
  
• Queue this Job - If this option is enabled, Pooch will save this job into a job queue and launch it as soon as possible. If the job launch process fails, which can happen if the nodes are busy or inaccessible, the job will be saved back into the job queue of the node from which the launch was attempted. Pooch will check the queue once per minute. (See the Node Info Window or the Job View of the Network Scan Window to access this queue.) Otherwise, Pooch discards the job after the first attempt. If you are using the Start Job at Time… feature, you may want to consider checking this flag in case a different job is already running on the same nodes.
  
  
• Automatically Acquire Nodes - If this option is enabled, the Job Window will replace the node list with options to automatically acquire the nodes needed to run this job. Pooch will attempt to fulfill the request specified in the acquire controls just prior to launch. Used in conjunction with the Start Job at Time… option, the acquisition will be scheduled for that specified time. Used in conjunction with the Queue this Job option, the acquisition will be attempted again if the request was not satisfied.
  

• Launching, Scheduling, or Queuing a parallel job - Clicking on Launch/Schedule/Queue Job will ask Pooch to launch, schedule, or queue, depending on the Start Job at Time… and Queue this Job options, a parallel application onto the nodes according to the information given in this window. If your node is participating in the parallel computation, your machine’s Pooch will direct the launch process or hold the job in its queue, depending on the job and the circumstances. If your machine is not participating in the computation, the job will be forwarded to the Pooch at node zero of the computation, and that Pooch becomes responsible for the job. If the job has not yet launched, you may inquire about this job’s status by accessing the job queue of the job’s node zero or using Job View in the Network Scan Window. After the job successfully launches, the nodes running the parallel job will report BUSY and the job will report Running in the Status column of the Network Scan Window until the job ends. Getting Info about a node will return additional details about the computation’s use of that node.
  

• Recent Items Drawer - Clicking on the recent button at the bottom of the Job Window will open a new drawer containing recent items. You can use this feature to recall recently used executables, files, or nodes.
  

The Recent File Lists folder contains the file lists of previously submitted jobs, each of which can be opened to access specific files. The Recent Node Lists folder contains the node lists of those previous submitted jobs, which can also be opened to recall specific nodes. The Remote Scan List displays the cached IP addresses used in the Remote Node Scan feature of the Network Scan Window. For your convenience, an icon at the top of this drawer contains the name and IP address information of your node. This drawer is available only in OS X 10.2 or later.

Variations of the Job window

The Job window offers two variations from the node list. The first is the ability to acquire nodes automatically from the cluster at launch time. This feature allows the executable to be launched on nodes as they become available. New in 1.6, the second is the ability to distribute a single-processor executable on a cluster, giving them a different integer for each instance of the executable. This feature gives you the ability to explore a parameter space using an executable not otherwise designed for parallel execution.

Automatically Acquire Nodes

• Acquire nodes or processors - When the Automatically Acquire Nodes option is enabled, selecting from these pop-up menus specifies how many nodes or processors Pooch will attempt to acquire just before launching the job. If available, nodes of different processor counts could be combined into a parallel job. Options such as Tasks per Computer, do apply. Pooch will add as many available local nodes as it needs to satisfy this request.
  
  
• Starting Node of the acquisition - When the Automatically Acquire Nodes option is enabled, the acquisition is performed by the node selected here. By default, the local node is selected. If another node is selected, the job will be forwarded to that node prior to launch. This pop-up menu is populated with the nodes previously used for the remote network scan feature of the Network Scan window. Adding a node from the Network Scan window to the Job window also sets this acquire setting.
  
  
• Acquire Options… - When the Automatically Acquire Nodes option is enabled, the acquisition will include the starting node if the Include Starting Node item is checked. Otherwise, the starting node may or may not be included. The acquisition depends on the number, status, and rating of the nodes on the network. The starting node can be selected if it helps satisfy the acquisition request. If the Count Is Required item is checked, the processor or node acquisition request becomes a minimum requirement, without which the job will not be launched and, if Queue this Job is selected, will be queued for a later attempt. In that case, the acquisition attempt will be repeated until these requirements are satisfied.
  
  

• Distribute From: To: - When the Grid job type is selected, these entries specify the range of integers Pooch will use for each instance of execution. The Job in the above figure shows that it will launch cases using every integer from 1 to 100, inclusive. Pooch will create a text file named “input” in the same directory as the executable containing that integer. By default, Pooch will also append that integer to the command line of the executable. To change that setting, use the Command-Line Arguments option. The %index argument will be replaced with the integer for that case.
  
  
• Step - With the Grid job type is selected, this pop-up menu specifies the step between cases. Pooch will start with the From entry and increase the integer by the Step selection. So, if 7 were selected above, Pooch will launch the executable with the integers 1, 8, 15, 22, and so on until case 99.
  
  
• Starting Node - Similar to the Starting Node selection of the the Automatically Acquire Nodes option, the acquisition of nodes will be performed by the node selected here.
  

The Node View displays the nodes discovered on the network, along with diagnostics and statistics about these nodes. This view is used to access nodes, query their status and health, and select them for parallel computational jobs.

The Job View retrieves from those nodes data about jobs that are queued, launching, running, or terminated. This view compiles data from these sources to display the condition and other statistics about parallel computing jobs.

New in 1.6, the Network view displays nodes in saved node lists, as well as remotely scanned networks in one large view. Each network of nodes can be revealed by clicking on the node list’s or network’s disclosure triangle.


Node View

When this window is in Node View, Pooch scans the network for available nodes and displays its results here. Once Pooch has finished scanning, you can use this window to select nodes for your computation. Double-clicking on a node moves it to the node list of the Job Window, which will open if not already present. Clicking the Add button while a node is selected will have the same effect. Nodes also present in the Job Window will appear in gray in the Network Scan Window.
Selecting a number from the pop-up menu of Add Best moves that many nodes that Pooch considers “best” to the Job Window. The selection excludes nodes that are already on the Job Window’s node list. The rating system Pooch uses to rank the nodes is described fully in the Network Scan Columns section below. This mechanism is designed to be more likely to select nodes that perform better than others and be less likely to select nodes that are busy or heavily loaded. Selecting the highest number from this menu selects all nodes that Pooch can communicate with and are not busy with a parallel job.
Normally, the Network Scan Window will scan the network again according to the Automatic Rescan specified in the Network menu. The Refresh button directs Pooch to rescan and refresh the list immediately. This window is resizable for large amounts of information.

- After selecting one node, you can use this pop-up button to get information about that node. The Get Node Info and Get Job Queue items invoke a Node Info Window. The Get Files items invokes a Finder-like window from which you can drag files to the Finder.
- The Search box at the top right of the Network Scan window accepts a search string to limit the displayed data. It compares the search string against the node and job data available in the list below and displays only those items that match. For example, if you type “G5”, it will show nodes that use a G5 processor. If you type “dual”, only those with two processors will appear. Other text will be compared against the names and other data to reveal appropriate matches. As with any search using text, overly specific search strings will yield little or no data, and overly general strings will produce excess. New in 1.6.

- The address box at the top middle of the window provides access to remote clusters of nodes, something like the address box in a web browser. (Revised in 1.6.) Pooch normally can only directly scan within its own local network neighborhood. This is the default scanning process. You may always return Pooch to this mode by selecting Local Network from this pop-up menu or typing “Local” in the box. Technically, unless your network administrators have set up your routers to support IP multicasting, this means that Pooch can only see other nodes in the same IP subnet. (This limitation is inherited from the Internet-standard Service Location Protocol implemented in Apple’s Network Services Location Manager and Apple’s Bonjour implementation.)
Entering an IP address in this box allows you to circumvent this limitation. Enter the address, in DNS (e.g., mymac.mydomain.com) or “dotted quad” (e.g., 192.1.2.34) form, of a Mac you know is running Pooch. Your local Pooch will then ask the far away Pooch to do its local scan and relay the results. Essentially, the Pooch on your Mac “borrows the nose” of the other Pooch. This feature allows you to scan for nodes on any other accessible subnet. This is useful for circumstances where, say, you want to access a chem.ucla.edu Mac from a physics.ucla.edu Mac. Selecting Local Network returns the network search to your local network.
Once you enter one address, Pooch will remember that address and make it available on the menu of the pop-up button for future use. As you accumulate more addresses, Pooch will re-sort the list in order of most recently accessed first.
The functionality of this feature extends well beyond just one domain, however. From your Mac, you may use this to access nodes on any subnet anywhere on the Internet. This means you can even access your cluster running Pooch from your home dial-up connection.
This feature is very powerful. With this power comes responsibility. There are security features in Pooch that will make unauthorized access without Pooch extraordinarily unlikely. These issues are discussed in the Security section.






Job View

When the Network Scan window is in Job View, it scans the network for nodes and accesses data, if present, about queued, launching, running, terminated, and aborted jobs and compiles that job data for display here. The root level of the list shows all the jobs, named according to their executable, found on the network. The job icon for each job is color coded as follows:

Icon Color Meaning
white A normal parallel computing job
blue A queued job (“on ice”)
yellow The job is being launched
green The job is running
gray The job has ended
white X on black The job was aborted

Opening the disclosure triangle displays the nodes that will be included in, are being used for, or were included in that job, depending on the state of the job. If possible, the information about a particular node will be queried directly, otherwise the data is derived from the data associated with the job.
This view correlates and compiles this data from all the nodes on the network. A variety of otherwise independent jobs may be accessed as far back as the Job View Access Time preference will permit. Since nodes used in one job can be reused for another one later, nodes will naturally appear more than once in multiple jobs. Although information such as the job ID, number of nodes and files, origin, and submission time should be consistent between nodes of a job, the process ID, start time, and end time could be different. If certain nodes of a job are not available, data about a node will be derived from the job data, if possible, residing on the other nodes. The Last Access and Determined Via columns are easy ways to tell whether or not the data are fresh.

Network View

In the Network View, the window organizes nodes into saved node lists followed by remote networks. Opening the disclosure triangle of a node lists displays the nodes it contains and includes those nodes for access. Opening a remote network triggers Pooch to access the remote node and query the nodes in its local area network, just like when using the address box as in the Node View. However, what is different is that you can have multiple networks open and accessible at once, and multiple saved node lists open as well. You may mix and match nodes from these multiple networks when selecting nodes for your parallel computing job. New in 1.6.

Network Pane

When the Network Scan window is initially opened, a pane splitter appears on the far left side of the window. Dragging that to the right opens a network pane, listing both saved node lists and remote networks. The remote networks shown are the same that was entered via the address box earlier, and they list networks in the same order, with the Local Network listed first. This pane gives another way to quickly select and scan a remote network, much like the left pane in OS X’s Finder windows.
Clicking on the plus sign below the Network Pane creates a new saved node lists. You may think of these as iTunes playlists, but for nodes. You may drag nodes from any network to these saved node lists, creating arbitrary groups of nodes useful for different kinds of parallel computing jobs. For example, you may have a group that you know is only available at night, or another set of nodes that are all G5s or dual-processor machines, but are on disparate, mixed networks or clusters. This gives you a way to group commonly used nodes together, allowing you to conveniently view, scan, and monitor these nodes as if they were together and include them in a new job in the Job window. Double-click a node list to scan them. When viewing a saved node list, select a node and press the delete key to remove them from a node list. The Network Pane and saved node lists are new in 1.6.

Network Scan Columns

The Network Scan Window displays information about each node Pooch queries. This information is shown in a spreadsheet-like format. This window is invoked using the columns button at the top of the Network Scan Window or the Show Columns… item of the Network Scan Columns submenu of the Network menu. The columns can also be added or removed using the Network Scan Columns submenu of the Network menu. You can drag a column at its header and resize it by clicking on its right edge. Clicking on a column header re-sorts the list according to that column.
Sometimes, if the node is running a computational intensive task, the Pooch on that node may not be able to respond immediately, delaying the appearance of this information. In that case, it probably should not be used for a new job.

Column Function
IP Address the “dotted quad” Internet Protocol address of this node
Machine Type the machine type, based on its ROMs
CPU Type the processor type (e.g., G3 or G4), including number of processors
Clock Speed the processor clock cycle speed in millions of cycles per second
OS Version the version of the operating system (e.g., 9.0.4 or 10.0)
Load the estimated load on the system in %. On OS 9, this item uses the amount of CPU time, in sixtieths of a second, each application has consumed according to the Process Manager approximately every ten seconds. On OS X, this item is calculated using the results of a call to the Unix “ps” command. Since the resolution is rather low and the process of measurement can influence the measurement (like Quantum Mechanics), this number can be somewhat inaccurate. It is intended, if the number is measurably nonzero, to hint that that this node is probably in use and should be avoided.
Free Memory the amount of contiguous free RAM available on this machine, which is the largest available space for a newly launched application. Updated in 1.7 to report more than 2 GB.
Free Disk Space the amount of free space on the drive on which this node’s Pooch resides
Achieved Performance measured achieved single-precision floating-point performance according to a benchmark based on code from the Power Fractal app. Automatically recognizes the Velocity Engine and SSE, and updated once per day. (not multiprocessor aware)
Peak Single-Precision measured single-precision floating-point performance of the FPU of this processor based on an IBM benchmark. Updated once per day. (not multiprocessor aware)
Peak Double-Precision measured double-precision floating-point performance of the FPU of this processor based on an IBM benchmark. Updated once per day. (not multiprocessor aware)
Peak Vector Float measured single-precision vector floating-point (vector float or vFloat) performance of the vector FPU (in the Velocity Engine or SSE) of this processor based on an IBM benchmark. Updated once per day. (not multiprocessor aware)
User Idle Time the time that has elapsed since Pooch last detected interaction from the user, such as moving the mouse or other activity
Rating a nonnegative real number describing Pooch’s rating of that node. This number is a function of the information Pooch has collected. If the node is busy, or Pooch has not successfully communicated with the node, the rating is zero. Otherwise, it is related to the above properties according to the following heuristic function:

where is Achieved Performance divided by 300 MFlops, is the load (from 0 to 1), is Free Memory divided by 32 MB, is Free Disk Space divided by 16 MB, and is User Idle Time divided by 15 minutes. is designed to be very low when the node is undesirable to use, such as when it is heavily loaded or is running out of memory or disk space. Note that, assuming load and memory space are non-issues, is approximately logarithmic with processor performance. Also, many of these variables can easily change at any moment, causing the rating to fluctuate. This rating function may change in future versions of Pooch. (To create and use your own rating, use the AppleScript interface described in Chapter V.)

Jobs Queued the number of jobs that are queued on that particular node
Current Job Name if the node is running a job, the name of the first parallel executable it is running
Last Access the time and date this data was accessed, according to that node’s clock
Pooch Version the version of Pooch that node is running
Job ID the job identification number assigned to that job
Node Count the number of nodes that job will use, is using, or had used
File Count the number of files supplied for that job, as submitted to Pooch
Process ID the process identification number of a particular node’s instance of the executable of a job when it is running or a job when it was running
Submission Time the time and date this job was originally submitted
Start Time the time and date a particular node’s instance of the executable of a job was first determined to be running
End Time the time and date a particular node’s instance of the executable of a job was first determined to be ended
Elapsed Time the amount of time a particular node’s instance of the executable of a job took that node
Job Origin the node that was the origin of the job
Determined Via the node that provided the information about this job or node

Finally, the Status column has a number of different possible displays.

Status Reading Meaning
attempting to connect to this node
a connection was established to Pooch at this node and security authorization is being approved. If the node is under heavy load, Pooch might not be getting enough CPU time to respond. On OS 9, writing your parallel app to give more background time (for example, using the checkesc function in MacMPI) would help.
access to Pooch at this node is in progress
access to Pooch at this node is almost done
Okay the Pooch at this node was successfully accessed and is not busy
BUSY the Pooch at this node was successfully accessed and is busy running an application launched by Pooch
(“breathing”) the Pooch at this node is being used for remote neighborhood access and is returning addresses of and/or accessing other nodes
retrieving job data
retrieving file and folder data
exchanging data or commands
Queued this job was successfully queued and is awaiting launch
Launching… Pooch is presently attempting to launch this job
Running this job was successfully launched and is running
Ended Pooch has determined that this job terminated
Aborted Pooch was used to kill this job and it is no longer running











Node Info Window

Selecting one node in the Job window or the Network Scan window allows you to access that node’s information. Much of the information on the left is also available in the columns of the Network Scan Window, with a few additions:

Item Function
DNS Name the IP name of this node according to the DNS network, if available
Total Memory the total memory available, including virtual memory (Updated 1.7)
The right side shows a list of running processes each with an approximate distribution of processor load. The determination of this information is OS specific. On OS 9, Pooch derives this information from sampling the Process Manager every ten seconds. On OS X, Pooch calls the Unix “ps” command, whose results can change at any moment and can be adversely influenced by the call to “ps”.
After selecting a process on this list, clicking Kill Process will direct the Pooch on that node, if it is running OS 9, to ask that process to quit. Applications that a user is presently using can respond to this request, and some applications ignore this request. If that node is running OS X, Pooch will use a “kill -9” command instead. However, in accordance with the Unix underpinnings of OS X, Pooch can only kill processes that Pooch has permission to kill.
Clicking on the pop-up menu will allow you to switch between Stats & Apps and Job Queue. In the Job Queue mode, this window will display parallel jobs in the queue on this node. The columns list the number of nodes and files selected in this job and the launch time of this job. If no launch time was selected, or if the launch time has passed, it will display Normal. Selecting one will allow you to kill that job using the Kill Job button.

Get Files window

Selecting a node in the Network Scan Window or the Job Window and selecting Get Files from the Node menu will have your Pooch access the Pooch on that node and access files there. It displays information about the files in a window much like a Finder window. You can drag files out of it to the Finder, you can double click on a folder to access its contents, and you can Command-click on the window title to pop up a menu to back out a directory. As a security feature, you can only access the folder in which the remote Pooch resides and any of its subdirectories (folder aliases will not resolve), and you can only get files out, not drag files in. This access is completely independent of Mac OS File Sharing.
Node Registration Schedule Dialog

This dialog allows you to select the time Pooch registers and deregisters itself on the network, which determines this node’s visibility by other Pooches. As seen in the above screen shot, you may set the schedule so that, on weekdays, this node is visible on the network at 5:15 pm, after you leave for home, then no longer is available for computation at 9 am when you arrive at work that morning. The Schedule Type pop-up menu can be set to Everyday, where the daily schedule will be the same every day, Weekdays & Weekends, where the schedule for weekends (Saturday and Sunday) is distinct from the schedule on Monday through Friday, and Weekly, where the schedule on each day of the week can be set separately. The Day pop-up menu selects which day you are editing, which depends on the Schedule Type setting.
For each day, the large circular dial is used to specify what portion of the day Pooch will register itself. The circle represents a 24-hour clock with midnight at the top and noon at the bottom. The highlighted sector of the circle indicates the portion of the day registration will occur. Dragging the mouse inside the circle selects times rounded to the nearest 15 minutes. Dragging outside the circle, or using the text fields, allows you to select any minute of the day.

• Log In…/Log Out - Opens a Cluster Log In window to initiate use of Pooch Pro after entering a user name and password
  

• Change Password… - Opens a Change Password Window where the user can enter and verify a new password for account log in.
  
  
• Show/Hide User Info - Toggles a User Info Window for the currently logged in user, showing statistics on the amount of compute time the user has consumed out of their assigned quota. See the User Administration Columns section for more detail on these fields.
  

• Migrate User Access… - Adds a reference describing this user’s account information, including password data, to the Job Window. The user may then choose nodes, just as with parallel computing jobs, where a new or updated copy of their user data will reside.
  
  
• Administrate Users… - Opens the User Administration Window (see the User Administration Window section)
  
  
• Update User Database - choosing from this submenu allows the distribution of this node’s user database to other nodes on the cluster. Assuming all nodes are available and running on the local subnet, the Automatically choice will have Pooch Pro automatically acquire those nodes for updating. The Manually… item adds the user database to the Job Window, making it possible to choose nodes that may not have been previously available or are outside the local subnet. Ideally, this is an operation that should be performed on all nodes of the cluster.
  
  
• Import Users… - Opens a file dialog to choose a text file from which Pooch Pro will interpret data to create new users and modify existing ones. This feature allows an administrator to generate a user database based on an external source or text file, then import this user data into Pooch Pro with one action. The data format must be Unix linefeed text (such as using “Make Plain Text” in TextEdit), and the first line contains tab-delimited headers followed by corresponding tab-delimited data. The import ends with the first blank line or at the end of the file. We recommend examining the output of Export Users for an example, although the column order does not matter to the import, nor do all columns demonstrated in export need to exist for import. “Password” is also a recognized column. New in 1.6.5.
  
  
• Export Users… - Opens a file dialog to choose the name and location of a new text file containing tab-delimited data about user settings, including CPU quota and rollover minutes, as well as calculated CPU time used and remaining for each user, parceled between quota versus rollover minutes. This text format should be straightforward to read by standard spreadsheet programs. These header fields are the header keywords used in Import Users. New in 1.6.5.
  

The User View displays all user accounts in the cluster, including statistical data about these users. This view is used to administer, create, edit, and delete user accounts.

The Group View lists all groups of user accounts on the cluster and the users they contain in a hierarchal format. This view is used to administer groups and organize which users they include.

User View

The User View of the User Administration Window is where user accounts can be created, edited, and deleted by selecting the account and clicking on the buttons at the bottom of the window.

Group View

The Group View of the User Administration Window is where groups can be created, edited, and deleted. Users can be dragged between groups here.

User Administration Columns

The User Administration Window displays information users and groups in a spreadsheet-like format. This window is invoked using the columns button at the top of the User Administration Window. You can drag a column at its header and resize it by clicking on its right edge. Clicking on a column header re-sorts the list according to that column.

Column Function
Name the full name of a user or group
Short Name the short name of a user (a.k.a. user name) or group. The ID number of that group or user is shown in parentheses.
Group the short name of the user’s group, with the group ID in parentheses
Compute Time Quota
the compute time allocated to a user. The quota is specified as a particular amount of time, summed over all nodes used by that user, allowed within a certain wall-clock time. For example, if a user is allocated five hours per day, then Pooch will allow that user’s jobs, in aggregate, to use up to five nodes one hour each, or one node for five hours, every day
Rollover Minutes Expiration
the expiration limit of this user’s rollover minutes. If a user does not use up their quota on a previous quota interval, the user may carry those minutes over to the next interval. However, those minutes will expire after the time specified here. Using the above example of a user quota set to five hours per day, if this rollover expiration is set to two days and the user did not use any time yesterday, then that user could use up to ten hours on the cluster today.
Maximum Job Duration
the wall-clock time limit of this user’s jobs. Jobs submitted by the user will be limited to running for the amount of time specified here.
Total Time Remaining
the sum of the compute time available to the user if that user were to start a job now. Pooch keeps track of jobs submitted by users compares that time against the policies specified by the quota and rollover minutes policy settings. The time left is displayed in this column.
Total Time Used the sum of the compute time used by the user within the quota and rollover minute time intervals
Quota Time Remaining
the sum of the compute time available to the user according to the compute time quota rule only
Quota Time Used the sum of the compute time used by the user within the quota time intervals
Rollover Time Remaining
the sum of the compute time available to the user due to rollover minutes only
Rollover Time Used the sum of the compute time used by the user outside the quota time interval but within the rollover minute expiration
User Flags the flags of a user or group, specifying user policy features, shown graphically. Their meanings are shown in the chart below.
User Flag Icon Meaning
this user or users of this group group are allowed to administrate on the cluster
this user or users of this group have a compute time quota limiting their allocation on the cluster
this user or users of this group have been allowed rollover minutes
this user or users of this group have been allowed to migrate their access to the cluster from node to node
this user or users of this group have been allowed to change their own password

Edit User Sheet

Editing a user via double-clicking or the Edit button invokes the Edit User Sheet.

The sliders set the compute time policy for this particular user. A user’s total compute quota can be limited to a certain amount of wall-clock node time per time interval, which can be a day, a week, a month, or a year. This time is the sum of all the time this user keeps any node or nodes busy, as tracked by Pooch. This calculation is compared against the quota specified in this dialog and the quota of this user’s group. In addition, the user may be allowed minutes to be “rolled over” from previous quota intervals. This feature allows users to combine previously unused minutes with their current quota for their compute time. Users’ individual jobs can also be limited to running for a specified amount of time using the Limit Job Duration slider. When creating a new user, a New User Sheet appears that is very similar to the Edit User Sheet. Unless one is entered, the default password given to new users is “pooch”, all lowercase. Once the short name and user ID is set, they cannot be changed without deleting the user.

Edit Group Sheet

Editing a group via double-clicking or the Edit button while in the Group View invokes the Edit User Sheet.

Like that for an individual users, the sliders set compute time policy, but instead of just a particular user, a policy can be set for all the users in this group at once. A user’s compute time is limited to either that user’s particular quota or the group’s, whichever is more limiting. This hierarchy applies individually to the rollover minutes and job duration limits as well. When creating a new group, a New Group Sheet appears that is very similar to the Edit Group Sheet. Once the short name and group ID are set, they cannot be changed without deleting the group.


AppleScript

Pooch Pro supports three AppleScript types regarding user functions. New in 1.6.5.

user noun -- a user of the cluster
group noun -- a user group of the cluster

The user record is data about the user, including settings specific to the user as well as calculated quota and rollover CPU time used. Similarly, a group record is data about a group. The units of the time-valued properties, such as quota or rollover time, are in minutes. Via an administrator account, these records can be accessed using the usual Standard Suite in AppleScript vocabulary. For example, to get a complete list of users, use the following command:
get every user
To create a new user, use make:
make new user with properties {{name:”Test User”, user name:“testuser”, has quota:yes, quota:10000, group ID:301}}
These capabilities are useful to set up and create a new user programmatically via AppleScript or a Unix script. If not all properties are provided, as in the make example, Pooch Pro will fill in the remaining fields with default values. Properties that return calculated time usage and remaining , of course, are ignored if fed into Pooch Pro.

login noun -- a user’s login session to the cluster

The login record is about the login state of Pooch. Data about the currently running user can be returned via the get command, while delete can log out the user. To log in from AppleScript, use make:
make new login with properties {{user:{user name:“testuser”}, password:”pooch”}}

…

--
make new node at j with properties nodesearch

Be creative!

launch job -- job to launch: required

The launch command directs Pooch to submit a job that you pass by reference. For example,
launch myjob
would launch a job that you originally made using set myjob to make new job.

bark

This command makes Pooch bark. Try it and listen for yourself.


Additional Reading

Documentation about AppleScript in general is available in print and on the web.

Derrick Schneider (with Hans Handsen & Tim Holmes), The Tao of AppleScript, 2nd edition, (BMUG and Hayden Books, Indianapolis, Indiana, USA, 1994).

Apple’s official AppleScript web site http://applescript.apple.com/

MacScripter - an independent web site with links, information, and resources, including numerous examples, related to scripting on the Mac http://www.macscripter.net/

Apple’s AppleScript mailing list http://www.lists.apple.com/applescript-users

• uses Open Transport TCP/IP networking for communications
  
• uses Data Browser APIs to display information about nodes
  
• uses three separate windows, split off from the LDM dialog some would call “cockpit-like”
  
• uses Service Location Protocol (SLP), through the Network Services Location Manager, to post information about itself and discover other nodes on a network
  

• become one application. Pooch is, in a sense, schizophrenic. It has numerous different interacting programs inside that enable it to respond to many different possible requests at once.
  
• run anywhere on any hard drive. The AppleEvent to start the Launch Puppy was no longer necessary. Since Pooch was running anyway, it knows where it is.
  
• continuously monitor information about the system. Rather than rely on side-effects, it could keep track of running jobs, or load averages, or performance benchmarks, etc., itself and report such information to a querying Pooch at any time without disturbing a user, if present.
  
• maintain a job queue. Because Pooch runs continuously, it can retain a queue, initiate a parallel job at any specified time, and make decisions about the situation as it arises.
  
• be accessible over the Internet. TCP/IP, even with SLP, aren’t enough to do all of what AppleTalk does. So I added the Remote Node Search feature to extend the reach of SLP to other subnets. But this has the consequence that anyone on the Internet can access the nodes, leading to the addition of security features in Pooch. And the nature of these features, relying on registration names, was to allow the user never to remember passwords, a convenience we had in LDM.
  
• radically improved, streamlined, and standards-compliant AppleScript support, allowing for Pooch to be directed by queuing systems, from OS X’s Unix command line, or by other applications.
  
• the ability to launch jobs that use other MPI’s for their message passing, in addition to those using MacMPI. This exemplifies how the best of the Mac is being combined with the best of Unix.
  
• and more. We have features in mind for the future of Pooch.
  

• Universal Binary for running on mixed clusters of Intel- and PowerPC-Macs
  
• Remote job, file, and folder retrieval support, even through proxy nodes
  
• New Job file format support, including saving and loading job data
  
• Head node setting to access and control clusters with Linux-style topologies
  
• Enhancements to the AppleEvent interface for job and user data
  
• Automatic detection and retry of preferred IP address of remote nodes
  
• Pooch Pro automatic user login using Keychain services
  
• Other features, enhancements, bug fixes, and updates
  

• Updates to utilization of technologies in Mac OS X 10.4 “Tiger”
  
• Enhancements to the command-line interface
  
• Pooch Pro supports import and export User Data via text files
  
• Pooch Pro enables access to user data and login state via AppleScript
  
• Other feature enhancements, bug fixes, and adaptations to changes in OS X
  

• Utilization of new technologies in Mac OS X 10.4 “Tiger”:
  
• Automator - Incorporate Pooch actions into workflows
  
• Dashboard - View cluster status and activity in an aesthetic environment
  
• Spotlight - Locate data in Pooch jobs via the system
  
• Xgrid - Pooch makes Xgrid nodes accessible to its users
  
• Massively renovated Network Scan window, following cues from iTunes, Finder, and Safari, including support for user-defined node lists in their own movable Network pane, a multipurpose action pop-up menu, an address box, an all-new Network view mode, and even a Search mechanism
  
• Extended AppleScript fidelity, including exposing job data acquired on the cluster
  
• Support for grid-style jobs, specifying arbitrary argument ranges for identical executables
  
• Revised queuing system with a centralized queue for all users on the system
  
• Revisions to adapt to adjustments in OS X 10.4 “Tiger”, particularly the StartupItem mechanisms
  
• Support for a new web-based interface
  
• Other feature enhancements, bug fixes, and adaptations to changes in OS X
  

• Support for jobs using LAM/MPI on local TCP/IP-based networks
  
• Support for mpich-gm, enabling Pooch to launch jobs on clusters connected using Myrinet hardware
  
• Forwarding a job via another node, such as a “head node”, to submit jobs to nodes behind a firewall
  
• Automatic output retrieval system, detecting and returning new and modified files once the job that wrote them is finished
  
• Better optimized and more reliable proxy address access
  
• Limiting access to a node from a specific set of IP addresses
  
• Choosing a preferred primary address if there are multiple
  
• Other minor feature enhancements and bug fixes
  

• The debut of Pooch Pro, introducing:
  
• User, group, and administrative account system, including secure password log in
  
• Quota and time limit-based management of cluster resources, including rollover minutes
  
• User database management with Unix-style user and group organization
  
• User associated job tracking and job history database
  
• A new modern, graphically-based user administration interface
  
• Other minor feature enhancements and bug fixes
  

• Revised, renamed, and reorganized main menus for greater clarity and consistency with the OS X user-interface guidelines
  
• New proxy connection support for access behind a firewall when using the Remote Node Scan feature
  
• New user-specified control over port number selection range for compatibility with firewalls
  
• Enhanced node selection the Job View and the Recent Items drawer of the Job Window
  
• Updated Pooch Preferences window reflecting new features and new behaviors
  
• Other minor feature enhancements and bug fixes
  

• A new queuing and scheduling system for retaining jobs until specific conditions are met integrated with:
  
• A new job tracking system designed to track the progress and execution of jobs and retain historical data about terminated jobs
  
• An enhanced and updated graphical user interface that includes the new “brushed metal” look available in OS X 10.3 and later.
  
• The Node Scan Window is now the Network Scan Window, divided into a Node View and a new Job View mode to scan the entire network for queued, launching, running, terminated, and aborted jobs and display statistics about these jobs
  
• An updated Node Info Window displaying additional data and utilizing tabbed viewing and consistency with the OS X user-interface guidelines
  
• New drawers for the Job Window: the Recent Items drawer displays and recalls recently used files and nodes, and nodes of the remote node scan cache, and the Options drawer accesses all the options of the job
  
• An “Automatically Acquire Nodes” feature so jobs can automatically acquire nodes given a minimum number of nodes or processors to acquire starting at any specified node
  
• An updated, antialiased Start Time dialog for the Job Window
  
• A new Pooch Preferences window, accessible from the Pooch menu, featuring toolbar-style access to preferences in Pooch
  
• Enhancements to preferences and settings
  
• New installation choices, triggered by the option key, in the Pooch Installer
  
• A variety of minor bug fixes
  

• Support for launching parallel jobs on nodes while they are logged out. This new capability is appropriate for the new Compute Node Xserve and for running on administered Macs such as in a student lab.
  
• Support for a new suite of command-line utilities
  
• Improved job support for Unix access
  

• Support for launching multiple tasks per physical node, making it possible to use the same parallel communications API for parallel computing both within a box and outside the box
  
• Registration, discovery, and resolution via Rendezvous, a.k.a. ZeroConfig
  
• Pooch Lite - a special version of Pooch with no user interface useful for running on administered Macs such as at a student lab
  

• Support for jobs compiled with mpich and MPI-Pro
  
• Support for Cocoa apps and other bundle-based applications
  
• Complete support for Unix-based executables, including Mach-O executables and Unix scripts
  
• Complete support for Unix-style permissions, processes monitoring, process kills
  
• Registration of nodes on the network can now be scheduled
  
• Recently selected nodes and files can be recalled
  

Pooch and this document are Copyright © 2001-6 Dauger Research, Inc.
Macintosh, Mac OS, and Mac OS X are trademarks of Apple Computer, Inc.

Last Update: May 15, 2006

http://exodus.physics.ucla.edu/appleseed/dev/

Both C and Fortran versions are available with corresponding header files. An introduction to MPI, some basic examples of MPI programming, and links to references on MPI are available on the site as well. The following information is derived from the above link. Although MacMPI is only a subset of MPI-1, Dauger Research, Inc., recommends its use because of its long history of reliability on the Mac OS, its wide flexibility compiling in different environments, and its extremely helpful diagnostics.

Compiling MacMPI_X.f with the Absoft Pro Fortran v7.0 compiler in OS X’s Terminal

Download MacMPI_X.f and mpif.h and include them in the same directory as your Fortran source. Compile MacMPI_X using:

f77 -O -c MacMPI_X.f

which generates MacMPI_X.o. To compile your code, you will need to link with MacMPI_X.o and the Carbon libraries. For example, depending on if you are using Fortran 77 or Fortran90/95 to compile test.f, you would use commands like these:

f77 -O test.f MacMPI_X.o /System/Library/Frameworks/Carbon.framework/Carbon
f95 -O test.f MacMPI_X.o /System/Library/Frameworks/Carbon.framework/Carbon

These commands create a Mach-O executable, which Pooch should recognize. By default, the Absoft compiler on OS X creates executables with a 512 kB stack. If your application needs more, you may wish to use the -s flag or the limit command.

Compiling MacMPI_X.f with the Absoft Pro Fortran v7.0 compiler on OS 9

Again, you will need to download MacMPI_X.f and mpif.h into the directory where your source is located. Compile MacMPI_X using:

f77 -O -c MacMPI_X.f

which generates an object file named MacMPI_X.f.o. To compile your main code, test.f in this example, in Fortran 77 or Fortran 90, use commands like these:

f77 -O test.f MacMPI_X.f.o
f90 -O test.f MacMPI_X.f.o

This version of the Absoft compiler on OS 9 will create a Carbon application by default, which should be executable on both OS 9 and X. Pooch should be able to recognize and launch this application.

Compiling MacMPI_X.c with Metrowerks CodeWarrior Pro 6 for both OS 9 and X

There are two major options to using MacMPI_X.c in CodeWarrior: 1. using the Standard C Console window; and 2. creating a Macintosh application. In most cases where you are porting an ANSI C-compliant code from another platform, you would probably want to use the Standard C Console. A Macintosh application (the Power Fractal app and Parallel Fractal Demo are examples) would need to know how to organize menus, windows, and so forth.

Standard Console C

If your C source code is standard ANSI C (i.e., this code is multiplatform and uses ANSI C calls like fprintf and scanf), you should start creating your project by selecting the Mac OS C Stationery category. Under the Standard Console > Carbon category, select the “Std C Console Carbon” stationery. Add your source as you normally would.  Then add MacMPI_X.c.  Be sure mpi.h is in your source directory as well.
There are a few settings that should be set for the best behavior of your executable. In the Target Settings Panel named "PPC Target", edit the 'SIZE' Flags to use localAndRemoteHLEvents. Also in the same panel, be sure to set the Preferred Heap Size so that your code will have enough available memory. In addition, your code will need to edit certain run-time console flags. Before your main() code, add “#include <SIOUX.h>”, and at the top of your main() code add these two lines:

SIOUXSettings.asktosaveonclose=0;
SIOUXSettings.autocloseonquit=1;

This will have the app quit when it falls out of main(), otherwise, the apps will wait for user input before quitting, locking up the remote machines forever.
In addition, if you don't already have one, you may wish to add a call to printf prior to calling MPI_Init(). It appears to be necessary for proper initialization of the app's runtime environment, without which a crash may occur.

Mac OS Toolbox C

If your C source code is a Macintosh C application (i.e., your C calls Macintosh Toolbox routines exclusively), then create your project using the Mac OS C Stationery category. Under the Mac OS Toolbox category, select the “MacOS Toolbox Carbon” stationery. Add your source as you normally would, then add MacMPI_X.c as well. Since MacMPI relies on ANSI C routines, confirm that the stationery included CodeWarrior's ANSI libraries in your project. Again, in the Target Settings Panel named "PPC Target", edit the 'SIZE' Flags to use localAndRemoteHLEvents. And, when you write your code, be sure to have your remote apps (node ID > 0) quit without direct human interaction. It would also be helpful to have your app's event loop respond correctly to Quit AppleEvents, so Pooch can kill them remotely, if necessary.
Also, you may wish to set the monitor flag of MacMPI_X to 0, which will turn off the MacMPI status window. If you find your event loop and windows conflicting with MacMPI, this change may help.

Compiling MacMPI_X.c with the GNU cc compiler through OS X’s Terminal

In order to use cc, you must install the Mac OS X Developer Tools from the Dev Tools CD. This CD should have accompanied your OS X User Install CD but is also available for download from the Apple Developer web site. Be sure to download MacMPI_X.c and mpi.h into the directory where your source is located. To compile your application, in the case of test.c, from the Terminal window, compile the MacMPI_X.c code and link with the Carbon library and include files using this one-line command:

cc test.c MacMPI_X.c /System/Library/Carbon.framework/Carbon -I /Developer/Headers/FlatCarbon

This command creates a Mach-O executable, which Pooch should recognize and be able to launch.

Compiling MacMPI_X.c in a Cocoa application on OS X

Create a Cocoa application using the Project Builder on OS X. Download MacMPI_X.c and mpi.h into your source directory. Include MacMPI_X.c and Carbon.frameworks in your project. Because MacMPI_X expects to read the nodelist_ip file using fopen, and this file is generally placed in the same directory where the Cocoa bundle application resides, it is necessary to set the default directory to the directory of the application very early in the code (before calling MPI_Init). To do this, add the following code (thanks to Steve Hayman of Apple Canada) to the beginning of main() in main.m:

NSString *path = [[NSBundle mainBundle] bundlePath];
char cpath[1024];

[path getCString:cpath];
{char*lastSlash, *tp;

for(lastSlash=tp=cpath; tp=strchr(tp, '/'); lastSlash=tp++) ;
lastSlash[1]=0; //specifies the parent of the bundle directory
}
chdir(cpath);

When your code calls MPI_Init, MacMPI should then be able to locate the node list information. This executable should be recognized and launched by version 1.2 and later of Pooch.

mpich

mpich is an open source implementation of the MPI standard, and it is used extensively on Linux-based clusters. By 2002, it was ported to Mac OS X. The following information was derived from the mpich documentation.
In order for mpich to work with Pooch, some minor modifications to mpich had to be made. The latest mpich distribution (v1.2.4 as of this writing) came from:

http://www-unix.mcs.anl.gov/mpi/mpich/

Under open-source license, the version of mpich modified for Pooch by Dauger Research, Inc., is available from the Dauger Research web site at:

http://daugerresearch.com/pooch/mpich/

The modification allows Pooch to inform mpich which TCP port it should use. Details on the changes can be found in the Read Me files and source code. This version of mpich should compile precisely as the mpich documentation describes. That is, follow steps 1 through 3 on pages 4 and 5 in mpichman-chp4.pdf.
In summary, cd to the mpich-1.2.4 directory that was created after decompressing and un-tar-ing the mpich archive. We recommend extracting the archive to a directory where you have full read-write-execute access, such as your home directory (e.g., /Users/yourusername/). Then use the following command to specify the mpich libraries in the mpich-1.2.4 directory of /Users/yourusername/ and sense various features of your computer:

./configure --prefix=/Users/yourusername/mpich-1.2.4 |& tee c.log

(You may use another directory if you wish.) Note: if you are using Absoft’s Fortran 90, you might want to make sure the .a files in the /Applications/Absoft/lib/ are up to date (e.g., use ranlib) and use the --disable-f90modules flag when using ./configure:

./configure --prefix=/Users/yourusername/mpich-1.2.4 --disable-f90modules |& tee c.log

Then make mpich using:

make |& tee make.log

This step may take many minutes as it compiles all of mpich. A very large amount of output will be created.
To compile your C code, you may use the mpicc command residing in the bin directory of the mpich library directory:

./bin/mpicc -o test.out test.c

Pooch should recognize the resulting executable. IMPORTANT: Be sure to select “mpich” from the Job Type submenu of the Options… pop-up on the Job Window. Pooch should then be able to launch your mpich executable.
Please note that using this modified mpich with Pooch DOES NOT require:

• NFS or Network File System - a mechanism for many computers to have identical access to the same file and directory structure over a network
  
• rsh or ssh - the ability to remotely log into machines at a command-line level
  
• the machines.xxx file - a file containing a static list of host names
  
• mpirun - mpich’s default mechanism for launching jobs, which normally needs the above features
  
• all nodes to have access to the mpich libraries
  

http://www.mpi-softtech.com/

MPI/Pro is a trademark of MSTI. Some of the people there have been involved with the MPI standard since its beginning. They provide a commercial impetus to the performance and quality of their MPI implementation.
To install MPI/Pro, you may use the its installer package. No special modifications or configuration is needed for MPI/Pro to work with Pooch. Also, configuring inetd.conf or .rhost files is not necessary when using MPI/Pro with Pooch. Once you have finished installating MPI-Pro, you may compile your C code using the following command:

cc -o test.out test.c -lmpipro -lpthread -lm

Pooch should recognize the resulting executable. IMPORTANT: Be sure to select “MPI/Pro” from the Job Options pop-up on the Job Window. Pooch should then be able to launch your executable. (Thanks goes to Bobby Hunter of MSTI for his insight into MPI/Pro.) Again, using NFS, rsh, inetd.conf files, .rhosts files, or mpirun is not necessary.

mpich-gm

mpich-gm is a version of ANL’s mpich for modified to use Myricom’s Myrinet hardware interface. The Mac OS X version of mpich-gm is available here:

http://www.myri.com/scs/

Myrinet is a trademark of Myricom. No modification of their distribution was required.
After installing the gm libraries and drivers on all nodes with Myrinet hardware, you may use the the following configure line to install mpich-gm:

./configure --with-device=ch_gm -prefix=/dir/for/gm --enable-sharedlib

then the usual “make” and “make install” commands. Also, configuring host files is not necessary when using mpich-gm with Pooch. Be sure that all dylib’s, or dynamic libraries, created by this mpich are deleted. By removing these dylib’s, you need install mpich-gm only on the machine you use to compile your code. Once you have finished installating mpich, you may compile your C code using its mpicc command:

mpicc -o test.out test.c

Pooch should recognize the resulting executable. IMPORTANT: Be sure to select “mpich-gm” from the Job Type option in the Job Window. Pooch should then be able to launch your executable on a Mac cluster connected using Myrinet hardware. Many thanks goes to Prof. John Huelsenbeck of UCSD for his support and help. As before, using shared storage (NFS, etc.), ssh, rsh, inetd.conf files, .rhosts files, or mpirun is not necessary.

LAM/MPI

LAM/MPI is an open-source MPI implementation created and supported at the Pervasive Technology Labs at Indiana Unviersity. The original Mac OS X version of LAM is available here:

http://www.lam-mpi.org/

With the help of Dr. Jeff Squyres there, we have produced a modified version of LAM that operates with Pooch available here:

http://daugerresearch.com/pooch/lam/

To install this LAM, you may use the the following configure line:

./configure --prefix=/usr/local/lamPooch --with-boot=pooch

If you don’t have a fortran compiler installed, you will need to add --without-fc. If you want a “dual-use” LAM that will operate normally and be able to be used with Pooch, remove the --with-boot=pooch argument. After that, use the usual “make” and “make install” commands. This places the LAM binaries in /usr/local/lamPooch, where Pooch can find it. Configuring host files or other static data is not necessary when using this LAM/MPI with Pooch. Because LAM’s run time environment (RTE) executables are needed for LAM to run, you will need to repeat the above LAM installation process for every node on your cluster.
Once you have finished installating LAM, you may compile your C code using its mpicc command:

/usr/local/lamPooch/bin/mpicc -o test.out test.c

Pooch should recognize the resulting executable. IMPORTANT: Be sure to select “LAM/MPI” from the Job Type option in the Job Window. Pooch should then be able to launch your executable on a Mac cluster whose nodes have the above LAM executables installed. As always, using shared storage (NFS, etc.), ssh, rsh, inetd.conf files, .rhosts files, or mpirun is not required.

¹ Also operates on OS 9. See the Introduction for system requirements.

² This contrasts with distributed computing, such as SETI@Home, in which the pieces of its computation are all but completely isolated from one another.

³ As of version 1.2, Pooch can recognize and launch a wide variety of applications, including Classic apps, CFM-based Carbon apps, bundle-based Carbon apps, Cocoa apps, Mach-O executables, Unix scripts, and AppleScript apps. In version 1.7, Pooch supports launching Universal Binaries.

⁴ Unix permissions will be preserved only when copying between OS X machines.

⁵ For more about the different types of parallel computing, see http://daugerresearch.com/pooch/parallelzoology.html