/********************************************************************************************************************************/ /* Created: 30-Mar-2010 17:29:42 by OpenVMS SDL EV3-3 */ /* Source: 30-MAR-2010 17:29:21 $1$DGA7274:[STARLET_H.SRC]PPL$ROUTINES.SDI;1 */ /********************************************************************************************************************************/ /*** MODULE ppl$routines ***/ #ifndef __PPL_ROUTINES_LOADED #define __PPL_ROUTINES_LOADED 1 #pragma __nostandard /* This file uses non-ANSI-Standard features */ #pragma __member_alignment __save #pragma __nomember_alignment #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __save /* Save the previously-defined required ptr size */ #pragma __required_pointer_size __short /* And set ptr size default to 32-bit pointers */ #endif #ifdef __cplusplus extern "C" { #define __unknown_params ... #define __optional_params ... #else #define __unknown_params #define __optional_params ... #endif #ifndef __struct #if !defined(__VAXC) #define __struct struct #else #define __struct variant_struct #endif #endif #ifndef __union #if !defined(__VAXC) #define __union union #else #define __union variant_union #endif #endif /**************************************************************************** */ /* * */ /* COPYRIGHT (c) 1988 BY * */ /* DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASSACHUSETTS. * */ /* ALL RIGHTS RESERVED. * */ /* * */ /* THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED * */ /* ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE * */ /* INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER * */ /* COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY * */ /* OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY * */ /* TRANSFERRED. * */ /* * */ /* THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE * */ /* AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT * */ /* CORPORATION. * */ /* * */ /* DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS * */ /* SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. * */ /* * */ /* * */ /**************************************************************************** */ /* PPL$ADJUST_SEMAPHORE_MAXIMUM */ /* */ /* Adjust a Semaphore Maximum */ /* */ /* The Adjust a Semaphore Maximum routine increments or decrements the maximum */ /* associated with a semaphore. */ /* */ #define ppl$adjust_semaphore_maximum PPL$ADJUST_SEMAPHORE_MAXIMUM #ifdef __NEW_STARLET unsigned int ppl$adjust_semaphore_maximum( unsigned int *semaphore_id, short int *amount); #else /* __OLD_STARLET */ unsigned int ppl$adjust_semaphore_maximum(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$ADJUST_QUORUM */ /* */ /* Adjust Barrier Quorum */ /* */ /* The Adjust Barrier Quorum routine increments or decrements the quorum */ /* associated with a barrier. */ /* */ #define ppl$adjust_quorum PPL$ADJUST_QUORUM #ifdef __NEW_STARLET unsigned int ppl$adjust_quorum( unsigned int *barrier_id, short int *amount); #else /* __OLD_STARLET */ unsigned int ppl$adjust_quorum(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$AWAIT_EVENT */ /* */ /* Await Event Occurrence */ /* */ /* The Await Event Occurrence routine blocks the caller until an event */ /* occurs. */ /* */ #define ppl$await_event PPL$AWAIT_EVENT #ifdef __NEW_STARLET unsigned int ppl$await_event( unsigned int *event_id, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$await_event(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$CREATE_APPLICATION */ /* */ /* Form or Join a PPL$ Application */ /* */ /* The Form or Join a PPL$ Application routine informs the PPL$ facility */ /* that the calling process is forming or joining a parallel application. */ /* */ #define ppl$create_application PPL$CREATE_APPLICATION #ifdef __NEW_STARLET unsigned int ppl$create_application( __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$create_application(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$CREATE_BARRIER */ /* */ /* Create a Barrier */ /* */ /* The Create a Barrier routine creates and initializes a */ /* barrier, and returns the barrier identifier. */ /* You use the barrier identifier to perform all operations on that */ /* barrier. */ /* */ #define ppl$create_barrier PPL$CREATE_BARRIER #ifdef __NEW_STARLET unsigned int ppl$create_barrier( unsigned int *barrier_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$create_barrier(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$CREATE_EVENT */ /* */ /* Create an Event */ /* */ /* The Create an Event routine creates an arbitrary user-defined event */ /* and returns the event identifier. You use the event identifier to */ /* perform all operations on that event. */ /* */ #define ppl$create_event PPL$CREATE_EVENT #ifdef __NEW_STARLET unsigned int ppl$create_event( unsigned int *event_id, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$create_event(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$CREATE_SPIN_LOCK */ /* */ /* Create Spin Lock */ /* */ /* The Create Spin Lock routine creates and initializes a simple (spin) */ /* lock, and returns the lock identifier. You use that lock identifier to */ /* get and free the lock. */ /* */ #define ppl$create_spin_lock PPL$CREATE_SPIN_LOCK #ifdef __NEW_STARLET unsigned int ppl$create_spin_lock( unsigned int *lock_id, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$create_spin_lock(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$CREATE_SHARED_MEMORY */ /* */ /* Create Shared Memory */ /* */ /* The Create Shared Memory routine creates (if necessary) and maps a */ /* section of memory that can be shared by multiple processes. */ /* */ #define ppl$create_shared_memory PPL$CREATE_SHARED_MEMORY #ifdef __NEW_STARLET unsigned int ppl$create_shared_memory( void *section_name, unsigned int memory_area [], __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$create_shared_memory(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$CREATE_WORK_QUEUE */ /* */ /* Create a Work Queue */ /* */ /* The Create a Work Queue routine creates and initializes a work queue, and */ /* returns the work queue identifier. */ /* */ #define ppl$create_work_queue PPL$CREATE_WORK_QUEUE #ifdef __NEW_STARLET unsigned int ppl$create_work_queue( unsigned int *queue_id, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$create_work_queue(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$CREATE_SEMAPHORE */ /* */ /* Create a Semaphore */ /* */ /* The Create a Semaphore routine creates and initializes a */ /* semaphore with a waiting queue, and returns the semaphore identifier. */ /* You use the semaphore identifier to perform all operations on that */ /* semaphore. */ /* */ #define ppl$create_semaphore PPL$CREATE_SEMAPHORE #ifdef __NEW_STARLET unsigned int ppl$create_semaphore( unsigned int *semaphore_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$create_semaphore(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$CREATE_VM_ZONE */ /* */ /* Create a New Virtual Memory Zone */ /* */ /* The Create a New Virtual Memory Zone routine creates a new storage */ /* zone, according to specified arguments, which is available to all */ /* participants in the application. */ /* */ #define ppl$create_vm_zone PPL$CREATE_VM_ZONE #ifdef __NEW_STARLET unsigned int ppl$create_vm_zone( unsigned int *zone_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$create_vm_zone(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$DELETE_APPLICATION */ /* */ /* Delete a PPL$ Application */ /* */ /* The Delete a PPL$ Application routine marks all shared memory for */ /* deletion and prevents additional processes from joining the application. */ /* */ #define ppl$delete_application PPL$DELETE_APPLICATION #ifdef __NEW_STARLET unsigned int ppl$delete_application(void); #else /* __OLD_STARLET */ unsigned int ppl$delete_application(void); #endif /* #ifdef __NEW_STARLET */ /* PPL$DECREMENT_SEMAPHORE */ /* */ /* Decrement a Semaphore */ /* */ /* The Decrement a Semaphore routine waits for a semaphore to have a */ /* value greater than 0, then decrements the value */ /* by 1 to indicate the allocation of a resource. */ /* */ #define ppl$decrement_semaphore PPL$DECREMENT_SEMAPHORE #ifdef __NEW_STARLET unsigned int ppl$decrement_semaphore( unsigned int *semaphore_id, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$decrement_semaphore(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$DISABLE_EVENT */ /* */ /* Disable Asynchronous Notification of an Event */ /* */ /* The Disable Asynchronous Notification of an Event routine disables delivery to a */ /* process of notification of an event by either AST or signal. */ /* */ #define ppl$disable_event PPL$DISABLE_EVENT #ifdef __NEW_STARLET unsigned int ppl$disable_event( unsigned int *event_id); #else /* __OLD_STARLET */ unsigned int ppl$disable_event(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$DELETE_WORK_ITEM */ /* */ /* Delete a Work Queue Item */ /* */ /* The Delete a Work Queue Item routine deletes a work item from a work */ /* queue. */ /* */ #define ppl$delete_work_item PPL$DELETE_WORK_ITEM #ifdef __NEW_STARLET unsigned int ppl$delete_work_item( unsigned int *queue_id, unsigned int work_item, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$delete_work_item(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$DELETE_SHARED_MEMORY */ /* */ /* Delete Shared Memory */ /* */ /* The Delete Shared Memory routine deletes or unmaps from a global */ /* section that you created using the PPL$CREATE_SHARED_MEMORY routine. */ /* Optionally, this routine writes the contents of the global section to */ /* disk before deleting the section. */ /* */ #define ppl$delete_shared_memory PPL$DELETE_SHARED_MEMORY #ifdef __NEW_STARLET unsigned int ppl$delete_shared_memory( void *section_name, __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$delete_shared_memory(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$DELETE_WORK_QUEUE */ /* */ /* Delete a Work Queue */ /* */ /* The Delete a Work Queue routine deletes the specified work queue, and releases */ /* any storage associated with it. */ /* */ #define ppl$delete_work_queue PPL$DELETE_WORK_QUEUE #ifdef __NEW_STARLET unsigned int ppl$delete_work_queue( __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$delete_work_queue(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$ENABLE_EVENT_AST */ /* */ /* Enable AST Notification of an Event */ /* */ /* The Enable AST Notification of an Event routine specifies the address of */ /* an AST routine (and optionally an argument to that routine) to be delivered */ /* when an event occurs. */ /* */ #define ppl$enable_event_ast PPL$ENABLE_EVENT_AST #ifdef __NEW_STARLET unsigned int ppl$enable_event_ast( unsigned int *event_id, int (*astadr)(void), __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$enable_event_ast(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$ENABLE_EVENT_SIGNAL */ /* */ /* Enable Signal Notification of an Event */ /* */ /* The Enable Signal Notification of an Event routine specifies a */ /* condition value to be signaled when the event occurs. */ /* */ #define ppl$enable_event_signal PPL$ENABLE_EVENT_SIGNAL #ifdef __NEW_STARLET unsigned int ppl$enable_event_signal( unsigned int *event_id, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$enable_event_signal(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$FLUSH_SHARED_MEMORY */ /* */ /* Flush Shared Memory */ /* */ /* The Flush Shared Memory routine writes (flushes) to disk the contents */ /* of a global section that you created using the PPL$CREATE_SHARED_MEMORY */ /* routine. Only pages that have been modified are flushed to disk. */ /* */ #define ppl$flush_shared_memory PPL$FLUSH_SHARED_MEMORY #ifdef __NEW_STARLET unsigned int ppl$flush_shared_memory( void *section_name, __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$flush_shared_memory(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$FIND_OBJECT_ID */ /* */ /* Find Object Identification */ /* */ /* Given the name of a spin lock, semaphore, barrier, event, work queue, */ /* or shared memory zone, the Find Object Identification routine returns */ /* the identifier of the object associated with the name you specify. */ /* */ #define ppl$find_object_id PPL$FIND_OBJECT_ID #ifdef __NEW_STARLET unsigned int ppl$find_object_id( unsigned int *object_id, void *object_name); #else /* __OLD_STARLET */ unsigned int ppl$find_object_id(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$FIND_SYNCH_ELEMENT_ID */ /* */ /* Find */ /* */ /* Given the name of a spin lock, semaphore, barrier, or event, the */ /* Find Synchronization Element Identification routine returns the */ /* identifier of the associated synchronization element. */ /* */ #define ppl$find_synch_element_id PPL$FIND_SYNCH_ELEMENT_ID #ifdef __NEW_STARLET unsigned int ppl$find_synch_element_id( unsigned int *element_id, void *element_name); #else /* __OLD_STARLET */ unsigned int ppl$find_synch_element_id(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$GET_INDEX */ /* */ /* Get Index of a Participant */ /* */ /* The Get Index of a Participant routine returns an index that is unique */ /* within the application. A value of zero signifies the participant that */ /* formed the application. The other participants in the application */ /* always return an index greater than zero. */ /* */ #define ppl$get_index PPL$GET_INDEX #ifdef __NEW_STARLET unsigned int ppl$get_index( unsigned int *participant_index); #else /* __OLD_STARLET */ unsigned int ppl$get_index(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$INSERT_WORK_ITEM */ /* */ /* Insert a Work Queue Item */ /* */ /* The Insert a Work Queue Item routine inserts a work item into the specified work */ /* queue. */ /* */ #define ppl$insert_work_item PPL$INSERT_WORK_ITEM #ifdef __NEW_STARLET unsigned int ppl$insert_work_item( unsigned int *queue_id, unsigned int work_item, __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$insert_work_item(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$INCREMENT_SEMAPHORE */ /* */ /* Increment a Semaphore */ /* */ /* The Increment a Semaphore routine increments the value of the semaphore */ /* by 1, analogous to the signal protocol. If any other participants */ /* are blocked on a call to PPL$DECREMENT_SEMAPHORE for this semaphore, */ /* one is removed from the queue and awakened. */ /* The semaphore must have been created by PPL$CREATE_SEMAPHORE. */ /* */ #define ppl$increment_semaphore PPL$INCREMENT_SEMAPHORE #ifdef __NEW_STARLET unsigned int ppl$increment_semaphore( unsigned int *semaphore_id); #else /* __OLD_STARLET */ unsigned int ppl$increment_semaphore(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$INDEX_TO_PID */ /* */ /* Convert Participant Index to VMS PID */ /* */ /* The Convert Participant Index to VMS PID routine returns the VMS PID */ /* of the process associated with the specified index. */ /* */ #define ppl$index_to_pid PPL$INDEX_TO_PID #ifdef __NEW_STARLET unsigned int ppl$index_to_pid( unsigned int *participant_index, unsigned int *pid); #else /* __OLD_STARLET */ unsigned int ppl$index_to_pid(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$INITIALIZE */ /* */ /* Initialize the PPL$ Facility */ /* */ /* The Initialize the PPL$ Facility routine informs the PPL$ facility that the */ /* caller is forming or joining the parallel application. Calling this */ /* routine is optional, because PPL$ initializes itself at the */ /* first call to a PPL$ routine. */ /* */ #define ppl$initialize PPL$INITIALIZE #ifdef __NEW_STARLET unsigned int ppl$initialize( __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$initialize(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$PID_TO_INDEX */ /* */ /* Convert VMS PID to Participant Index */ /* */ /* The Convert VMS PID to Participant Index routine returns the PPL$-defined */ /* participant index of the process associated with the */ /* specified VMS PID. */ /* */ #define ppl$pid_to_index PPL$PID_TO_INDEX #ifdef __NEW_STARLET unsigned int ppl$pid_to_index( unsigned int *pid, unsigned int *participant_index); #else /* __OLD_STARLET */ unsigned int ppl$pid_to_index(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$READ_BARRIER */ /* */ /* Read a Barrier */ /* */ /* The Read a Barrier routine returns the specified barrier's current quorum and */ /* the number of participants currently waiting (blocked) at the barrier. The */ /* barrier must have been created by PPL$CREATE_BARRIER. */ /* */ #define ppl$read_barrier PPL$READ_BARRIER #ifdef __NEW_STARLET unsigned int ppl$read_barrier( unsigned int *barrier_id, short int *quorum, short int *waiters); #else /* __OLD_STARLET */ unsigned int ppl$read_barrier(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$READ_EVENT */ /* */ /* Read an Event State */ /* */ /* The Read an Event State routine returns the current state of the specified */ /* event. */ /* The state can be not_occurred or not_occurred. */ /* */ #define ppl$read_event PPL$READ_EVENT #ifdef __NEW_STARLET unsigned int ppl$read_event( unsigned int *event_id, unsigned int *occurred); #else /* __OLD_STARLET */ unsigned int ppl$read_event(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$READ_SEMAPHORE */ /* */ /* Read Semaphore Values */ /* */ /* The Read Semaphore Values routine returns the current or */ /* maximum values, or both, of the specified counting semaphore. */ /* The semaphore must have been created by */ /* PPL$CREATE_SEMAPHORE. */ /* */ #define ppl$read_semaphore PPL$READ_SEMAPHORE #ifdef __NEW_STARLET unsigned int ppl$read_semaphore( unsigned int *semaphore_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$read_semaphore(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$RELEASE_SPIN_LOCK */ /* */ /* Release Spin Lock */ /* */ /* The Release Spin Lock routine relinquishes the spin lock by clearing the */ /* bit representing the lock. The lock must have been created by */ /* PPL$CREATE_SPIN_LOCK. */ /* */ #define ppl$release_spin_lock PPL$RELEASE_SPIN_LOCK #ifdef __NEW_STARLET unsigned int ppl$release_spin_lock( unsigned int *lock_id); #else /* __OLD_STARLET */ unsigned int ppl$release_spin_lock(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$RESET_EVENT */ /* */ /* Reset an Event */ /* */ /* The Reset an Event routine resets an event's state to */ /* not_occurred. */ /* */ #define ppl$reset_event PPL$RESET_EVENT #ifdef __NEW_STARLET unsigned int ppl$reset_event( unsigned int *event_id); #else /* __OLD_STARLET */ unsigned int ppl$reset_event(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$REMOVE_WORK_ITEM */ /* */ /* Remove a Work Queue Item */ /* */ /* The Remove a Work Queue Item routine removes the next item in order from a work */ /* queue. */ /* */ #define ppl$remove_work_item PPL$REMOVE_WORK_ITEM #ifdef __NEW_STARLET unsigned int ppl$remove_work_item( unsigned int *queue_id, unsigned int *work_item, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$remove_work_item(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$READ_SPIN_LOCK */ /* */ /* Read a Spin Lock State */ /* */ /* The Read a Spin Lock State routine returns the current state of a spin */ /* lock. The state can be not_seized or not_seized. */ /* */ #define ppl$read_spin_lock PPL$READ_SPIN_LOCK #ifdef __NEW_STARLET unsigned int ppl$read_spin_lock( unsigned int *lock_id, unsigned int *seized); #else /* __OLD_STARLET */ unsigned int ppl$read_spin_lock(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$READ_WORK_QUEUE */ /* */ /* Read a Work Queue */ /* */ /* The Read a Work Queue routine returns information about a work queue. */ /* */ #define ppl$read_work_queue PPL$READ_WORK_QUEUE #ifdef __NEW_STARLET unsigned int ppl$read_work_queue( unsigned int *queue_id, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$read_work_queue(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$SET_SEMAPHORE_MAXIMUM */ /* */ /* Set a Semaphore Maximum */ /* */ /* The Set a Semaphore Maximum routine dynamically sets the maximum value of a */ /* semaphore. */ /* */ #define ppl$set_semaphore_maximum PPL$SET_SEMAPHORE_MAXIMUM #ifdef __NEW_STARLET unsigned int ppl$set_semaphore_maximum( unsigned int *semaphore_id, short int *semaphore_maximum); #else /* __OLD_STARLET */ unsigned int ppl$set_semaphore_maximum(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$SPAWN */ /* */ /* Initiate Parallel Execution */ /* */ /* The Initiate Parallel Execution routine executes code in parallel */ /* with the caller by creating one or more subordinate threads of execution */ /* (VMS subprocesses). */ /* */ #define ppl$spawn PPL$SPAWN #ifdef __NEW_STARLET unsigned int ppl$spawn( unsigned int *copies, __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$spawn(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$SET_QUORUM */ /* */ /* Set Barrier Quorum */ /* */ /* The Set Barrier Quorum routine dynamically sets a value for the */ /* specified barrier's quorum. */ /* */ #define ppl$set_quorum PPL$SET_QUORUM #ifdef __NEW_STARLET unsigned int ppl$set_quorum( unsigned int *barrier_id, short int *quorum); #else /* __OLD_STARLET */ unsigned int ppl$set_quorum(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$STOP */ /* */ /* Stop a Participant */ /* */ /* The Stop a Participant routine terminates the execution of the specified */ /* participant in this application. */ /* */ #define ppl$stop PPL$STOP #ifdef __NEW_STARLET unsigned int ppl$stop( unsigned int *participant_index); #else /* __OLD_STARLET */ unsigned int ppl$stop(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$SEIZE_SPIN_LOCK */ /* */ /* Seize Spin Lock */ /* */ /* The Seize Spin Lock routine retrieves a simple (spin) lock by waiting in a */ /* spin loop until the lock is free. The lock must have been created by */ /* PPL$CREATE_SPIN_LOCK.…/* */ /* */ #define ppl$seize_spin_lock PPL$SEIZE_SPIN_LOCK #ifdef __NEW_STARLET unsigned int ppl$seize_spin_lock( unsigned int *lock_id, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$seize_spin_lock(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$TERMINATE */ /* */ /* Abort PPL$ Participation */ /* */ /* The Abort PPL$ Participation routine ends the caller's */ /* participation in the application prematurely---that is, at some time */ /* before the caller actually completes its execution. */ /* */ #define ppl$terminate PPL$TERMINATE #ifdef __NEW_STARLET unsigned int ppl$terminate( __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$terminate(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$TRIGGER_EVENT */ /* */ /* Trigger an Event */ /* */ /* The Trigger an Event routine causes the event's state to become */ /* occurred. You control whether all pending actions for */ /* the event are processed (made to occur), or just one is processed. */ /* A pending action can be an AST, a signal (condition), or a wakeup. */ /* */ #define ppl$trigger_event PPL$TRIGGER_EVENT #ifdef __NEW_STARLET unsigned int ppl$trigger_event( unsigned int *event_id, __optional_params ); #else /* __OLD_STARLET */ unsigned int ppl$trigger_event(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$UNIQUE_NAME */ /* */ /* Produce a Unique Name */ /* */ /* The Produce a Unique Name routine returns an application-unique name. */ /* A system-unique string specific to the calling application is appended */ /* to the string specified by the user. */ /* The resulting name is identical for all participants in */ /* the application, but different from those for all other applications on that */ /* system. */ /* */ #define ppl$unique_name PPL$UNIQUE_NAME #ifdef __NEW_STARLET unsigned int ppl$unique_name( void *name_string, void *resultant_string, __optional_params); #else /* __OLD_STARLET */ unsigned int ppl$unique_name(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* PPL$WAIT_AT_BARRIER */ /* */ /* Synchronize at a Barrier */ /* */ /* The Synchronize at a Barrier routine causes the caller to */ /* wait at the specified barrier. */ /* The barrier is in effect from the time the first participant calls */ /* PPL$WAIT_AT_BARRIER until each member of the */ /* quorum has issued the call. At that time, the wait concludes and */ /* all are released for further execution. */ /* */ #define ppl$wait_at_barrier PPL$WAIT_AT_BARRIER #ifdef __NEW_STARLET unsigned int ppl$wait_at_barrier( unsigned int *barrier_id); #else /* __OLD_STARLET */ unsigned int ppl$wait_at_barrier(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #pragma __member_alignment __restore #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __restore /* Restore the previously-defined required ptr size */ #endif #ifdef __cplusplus } #endif #pragma __standard #endif /* __PPL_ROUTINES_LOADED */