Multiprocessing.h

Go to the documentation of this file.

 
#ifndef __MULTIPROCESSING__
#define __MULTIPROCESSING__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = power
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#define MPCopyrightNotice "Copyright © 1995-2001 Apple Computer, Inc.\n"
#define MPLibraryName "MPLibrary"
#define MPLibraryCName MPLibraryName
#define MPLibraryPName "\p" MPLibraryName
#define MP_API_Version "2.4"
 
   enum
   {
      MPLibrary_MajorVersion =
          2, /*< ! When these change be sure to update the build versions*/
      MPLibrary_MinorVersion =
          4, /*< !  used in the startup check in MPInitializeAPI!*/
      MPLibrary_Release = 1,
      MPLibrary_DevelopmentRevision = 1
   };
 
   typedef struct OpaqueMPProcessID *MPProcessID;
   typedef struct OpaqueMPTaskID *MPTaskID;
   typedef struct OpaqueMPQueueID *MPQueueID;
   typedef struct OpaqueMPSemaphoreID *MPSemaphoreID;
   typedef struct OpaqueMPCriticalRegionID *MPCriticalRegionID;
   typedef struct OpaqueMPTimerID *MPTimerID;
   typedef struct OpaqueMPEventID *MPEventID;
   typedef struct OpaqueMPAddressSpaceID *MPAddressSpaceID;
   typedef struct OpaqueMPNotificationID *MPNotificationID;
   typedef struct OpaqueMPCoherenceID *MPCoherenceID;
   typedef struct OpaqueMPCpuID *MPCpuID;
   typedef struct OpaqueMPAreaID *MPAreaID;
   typedef struct OpaqueMPConsoleID *MPConsoleID;
   typedef struct OpaqueMPOpaqueID *MPOpaqueID;
 
   enum
   {
      kOpaqueAnyID = 0,
      kOpaqueProcessID = 1,
      kOpaqueTaskID = 2,
      kOpaqueTimerID = 3,
      kOpaqueQueueID = 4,
      kOpaqueSemaphoreID = 5,
      kOpaqueCriticalRegionID = 6,
      kOpaqueCpuID = 7,
      kOpaqueAddressSpaceID = 8,
      kOpaqueEventID = 9,
      kOpaqueCoherenceID = 10,
      kOpaqueAreaID = 11,
      kOpaqueNotificationID = 12,
      kOpaqueConsoleID = 13
   };
 
   typedef UInt32 MPOpaqueIDClass;
 
   enum
   {
      kMPNoID = kInvalidID
   };
 
   typedef OptionBits MPTaskOptions;
   typedef UInt32 TaskStorageIndex;
   typedef UInt32 TaskStorageValue;
   typedef ItemCount MPSemaphoreCount;
   typedef UInt32 MPTaskWeight;
   typedef UInt32 MPEventFlags;
   typedef UInt32 MPExceptionKind;
   typedef UInt32 MPTaskStateKind;
   typedef UInt32 MPPageSizeClass;
 
   enum
   {
      kDurationImmediate = 0L,
      kDurationForever = 0x7FFFFFFF,
      kDurationMillisecond = 1,
      kDurationMicrosecond = -1
   };
 
   ItemCount MPProcessors(void);
 
   ItemCount MPProcessorsScheduled(void);
 
   enum
   {
      kMPCreateTaskTakesAllExceptionsMask = 1L << 1,
      kMPCreateTaskNotDebuggableMask = 1L << 2,
      kMPCreateTaskValidOptionsMask =
          kMPCreateTaskTakesAllExceptionsMask | kMPCreateTaskNotDebuggableMask
   };
 
   typedef CALLBACK_API_C(OSStatus, TaskProc)(void *parameter);
 
   OSStatus MPCreateTask(TaskProc entryPoint, void *parameter, ByteCount stackSize,
                         MPQueueID notifyQueue, void *terminationParameter1,
                         void *terminationParameter2, MPTaskOptions options,
                         MPTaskID *task );
 
   OSStatus MPTerminateTask(MPTaskID task, OSStatus terminationStatus);
 
   OSStatus MPSetTaskWeight(MPTaskID task, MPTaskWeight weight);
 
   Boolean MPTaskIsPreemptive(MPTaskID taskID );
 
   void MPExit(OSStatus status);
 
   void MPYield(void);
 
   MPTaskID MPCurrentTaskID(void);
 
   OSStatus MPSetTaskType(MPTaskID task, OSType taskType);
 
   OSStatus MPAllocateTaskStorageIndex(TaskStorageIndex *index);
 
   OSStatus MPDeallocateTaskStorageIndex(TaskStorageIndex index);
 
   OSStatus MPSetTaskStorageValue(TaskStorageIndex index, TaskStorageValue value);
 
   TaskStorageValue MPGetTaskStorageValue(TaskStorageIndex index);
 
   OSStatus MPCreateQueue(MPQueueID *queue);
 
   OSStatus MPDeleteQueue(MPQueueID queue);
 
   OSStatus MPNotifyQueue(MPQueueID queue, void *param1, void *param2, void *param3);
 
   OSStatus MPWaitOnQueue(MPQueueID queue, void **param1, 
                          void **param2,                  
                          void **param3,                  
                          Duration timeout);
 
   OSStatus MPSetQueueReserve(MPQueueID queue, ItemCount count);
 
   OSStatus MPCreateSemaphore(MPSemaphoreCount maximumValue, MPSemaphoreCount initialValue,
                              MPSemaphoreID *semaphore);
 
   OSStatus MPDeleteSemaphore(MPSemaphoreID semaphore);
 
   OSStatus MPSignalSemaphore(MPSemaphoreID semaphore);
 
   OSStatus MPWaitOnSemaphore(MPSemaphoreID semaphore, Duration timeout);
 
#define MPCreateBinarySemaphore(semaphore) MPCreateSemaphore(1, 1, (semaphore))
 
   OSStatus MPCreateCriticalRegion(MPCriticalRegionID *criticalRegion);
 
   OSStatus MPDeleteCriticalRegion(MPCriticalRegionID criticalRegion);
 
   OSStatus MPEnterCriticalRegion(MPCriticalRegionID criticalRegion, Duration timeout);
 
   OSStatus MPExitCriticalRegion(MPCriticalRegionID criticalRegion);
 
   OSStatus
   MPCreateEvent(MPEventID *event);
 
   OSStatus MPDeleteEvent(MPEventID event);
 
   OSStatus MPSetEvent(MPEventID event, MPEventFlags flags);
 
   OSStatus
   MPWaitForEvent(MPEventID event, MPEventFlags *flags, 
                  Duration timeout);
 
   OSStatus MPCreateNotification(MPNotificationID *notificationID);
 
   OSStatus MPDeleteNotification(MPNotificationID notificationID);
 
   OSStatus MPModifyNotification(MPNotificationID notificationID, MPOpaqueID anID,
                                 void *notifyParam1, void *notifyParam2,
                                 void *notifyParam3);
 
   OSStatus MPModifyNotificationParameters(MPNotificationID notificationID,
                                           MPOpaqueIDClass kind, void *notifyParam1,
                                           void *notifyParam2, void *notifyParam3);
 
   OSStatus MPCauseNotification(MPNotificationID notificationID);
 
   enum
   {
      kMPPreserveTimerIDMask = 1L << 0,
      kMPTimeIsDeltaMask = 1L << 1,
      kMPTimeIsDurationMask = 1L << 2
   };
 
   OSStatus MPDelayUntil(AbsoluteTime *expirationTime);
 
#if CALL_NOT_IN_CARBON
   OSStatus
   MPDelayUntilSys(AbsoluteTime *expirationTime);
 
#endif /* CALL_NOT_IN_CARBON */
 
   OSStatus MPCreateTimer(MPTimerID *timerID);
 
   OSStatus MPDeleteTimer(MPTimerID timerID);
 
   OSStatus MPSetTimerNotify(MPTimerID timerID, MPOpaqueID anID, void *notifyParam1,
                             void *notifyParam2, void *notifyParam3);
 
   OSStatus MPArmTimer(MPTimerID timerID, AbsoluteTime *expirationTime, OptionBits options);
 
   OSStatus MPCancelTimer(MPTimerID timerID, AbsoluteTime *timeRemaining /*< can be NULL */);
 
   enum
   {
      kMPMaxAllocSize = 1024L * 1024 * 1024
   };
 
   enum
   {
      kMPAllocateDefaultAligned = 0,
      kMPAllocate8ByteAligned = 3,
      kMPAllocate16ByteAligned = 4,
      kMPAllocate32ByteAligned = 5,
      kMPAllocate1024ByteAligned = 10,
      kMPAllocate4096ByteAligned = 12,
      kMPAllocateMaxAlignment = 16,                         /*< Somewhat arbitrary limit on expectations.*/
      kMPAllocateAltiVecAligned = kMPAllocate16ByteAligned, /*< The P.C. name.*/
      kMPAllocateVMXAligned =
          kMPAllocateAltiVecAligned,    /*< The older, common name.*/
      kMPAllocateVMPageAligned = 254,   /*< Pseudo value, converted at runtime.*/
      kMPAllocateInterlockAligned = 255 /*< Pseudo value, converted at runtime.*/
   };
 
   enum
   {
      kMPAllocateClearMask = 0x0001, /*< Zero the allocated block.*/
      kMPAllocateGloballyMask =
          0x0002,                       /*< Allocate from the globally visible pool.*/
      kMPAllocateResidentMask = 0x0004, /*< Allocate from the RAM-resident pool.*/
      kMPAllocateNoGrowthMask = 0x0010, /*< Do not attempt to grow the pool.*/
      kMPAllocateNoCreateMask =
          0x0020 /*< Do not attempt to create the pool if it doesn't exist yet.*/
   };
 
   LogicalAddress MPAllocateAligned(ByteCount size, UInt8 alignment, OptionBits options);
 
   LogicalAddress MPAllocate(ByteCount size);
 
   void MPFree(LogicalAddress object);
 
   ByteCount MPGetAllocatedBlockSize(LogicalAddress object);
 
   void MPBlockCopy(LogicalAddress source, LogicalAddress destination, ByteCount size);
 
   void MPBlockClear(LogicalAddress address, ByteCount size);
 
   void MPDataToCode(LogicalAddress address, ByteCount size);
 
   enum
   {
      kMPTaskStateRegisters = 0, /*< The task general registers.*/
      kMPTaskStateFPU = 1,       /*< The task floating point registers*/
      kMPTaskStateVectors = 2,   /*< The task vector registers*/
      kMPTaskStateMachine = 3,   /*< The task machine registers*/
      kMPTaskState32BitMemoryException =
          4,                   /*< The task memory exception information for 32-bit CPUs.*/
      kMPTaskStateTaskInfo = 5 /*< Static and dynamic information about the task.*/
   };
 
   enum
   {
      kMPTaskPropagate = 0,  /*< The exception is propagated.*/
      kMPTaskResumeStep = 1, /*< The task is resumed and single step is enabled.*/
      kMPTaskResumeBranch =
          2,                      /*< The task is resumed and branch stepping is enabled.*/
      kMPTaskResumeMask = 0x0000, /*< The task is resumed.*/
      kMPTaskPropagateMask =
          1 << kMPTaskPropagate, /*< The exception is propagated.*/
      kMPTaskResumeStepMask =
          1
          << kMPTaskResumeStep, /*< The task is resumed and single step is enabled.*/
      kMPTaskResumeBranchMask =
          1 << kMPTaskResumeBranch /*< The task is resumed and branch stepping is
                                      enabled.*/
   };
 
   enum
   {
      kMPTaskBlocked = 0, /*< Task is blocked (queued on resource)*/
      kMPTaskReady = 1,   /*< Task is runnable*/
      kMPTaskRunning = 2  /*< Task is running*/
   };
 
   /*< For kMPTaskStateTaskInfo, the version of the MPTaskInfo structure
        requested.*/
   enum
   {
      kMPTaskInfoVersion = 3
   };
 
   struct MPTaskInfo
   {
      PBVersion version; /*< Version 3 of the data structure requested*/
 
      OSType name; /*< Task name*/
 
      OSType queueName; /*< Task's queue owner name*/
      UInt16 runState;  /*< Running, ready, blocked*/
      UInt16 lastCPU;   /*< Address of CPU where task previously ran*/
      UInt32 weight;    /*< Processing weight: 1 - 10,000*/
 
      MPProcessID processID; /*< Owning process ID*/
 
      AbsoluteTime cpuTime;      /*< Accumulated task time*/
      AbsoluteTime schedTime;    /*< Time when last scheduled*/
      AbsoluteTime creationTime; /*< Time when task created*/
 
      ItemCount codePageFaults; /*< Page faults from code execution*/
      ItemCount dataPageFaults; /*< Page faults from data access*/
      ItemCount preemptions;    /*< Number of times task was preempted*/
 
      MPCpuID cpuID;            /*< ID of CPU where task previously ran.*/
      MPOpaqueID blockedObject; /*< ID of blocked object.*/
      MPAddressSpaceID spaceID; /*< Address space ID of this task.*/
 
      LogicalAddress stackBase;  /*< Base of stack (lowest address).*/
      LogicalAddress stackLimit; /*< Stack limit (highest address).*/
      LogicalAddress stackCurr;  /*< Current stack address.*/
   };
 
   typedef struct MPTaskInfo MPTaskInfo;
 
   OSStatus MPSetExceptionHandler(MPTaskID task, MPQueueID exceptionQ);
 
   OSStatus MPDisposeTaskException(MPTaskID task, OptionBits action);
 
   OSStatus MPExtractTaskState(MPTaskID task, MPTaskStateKind kind, void *info);
 
   OSStatus MPSetTaskState(MPTaskID task, MPTaskStateKind kind, void *info);
 
   OSStatus MPThrowException(MPTaskID task, MPExceptionKind kind);
 
   typedef UInt32 MPDebuggerLevel;
   enum
   {
      kMPLowLevelDebugger = 0x00000000, /*< MacsBug-like*/
      kMPMidLevelDebugger = 0x10000000, /*< Jasik-like*/
      kMPHighLevelDebugger = 0x20000000 /*< Metrowerks-like*/
   };
 
   OSStatus MPRegisterDebugger(MPQueueID queue, MPDebuggerLevel level);
 
   OSStatus MPUnregisterDebugger(MPQueueID queue);
 
   typedef CALLBACK_API_C(void *, MPRemoteProcedure)(void *parameter);
 
   typedef UInt8 MPRemoteContext;
   enum
   {
      kMPAnyRemoteContext = 0,
      kMPOwningProcessRemoteContext = 1,
      kMPInterruptRemoteContext = 2,
      kMPAsyncInterruptRemoteContext = 3
   };
 
   void *MPRemoteCall(MPRemoteProcedure remoteProc, void *parameter,
                      MPRemoteContext context);
 
   Boolean _MPIsFullyInitialized(void);
 
   typedef CALLBACK_API_C(Boolean, MPIsFullyInitializedProc)(void);
#define kMPUnresolvedCFragSymbolAddress 0
#define MPLibraryIsLoaded()                      \
   (((UInt32)_MPIsFullyInitialized !=            \
     (UInt32)kMPUnresolvedCFragSymbolAddress) && \
    (_MPIsFullyInitialized()))
 
   void _MPLibraryVersion(const char **versionCString, /*< can be NULL */
                          UInt32 *major,               /*< can be NULL */
                          UInt32 *minor,               /*< can be NULL */
                          UInt32 *release,             /*< can be NULL */
                          UInt32 *revision);           /*< can be NULL */
 
#if CALL_NOT_IN_CARBON
#if CALL_NOT_IN_CARBON
   LogicalAddress _MPAllocateSys(ByteCount size);
 
   void *_MPRPC(MPRemoteProcedure remoteProc, void *parameter);
 
   Boolean _MPTaskIsToolboxSafe(MPTaskID task);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* CALL_NOT_IN_CARBON */
 
   Boolean _MPLibraryIsCompatible(const char *versionCString, UInt32 major, UInt32 minor,
                                  UInt32 release, UInt32 revision);
 
#define MPRPC _MPRPC
#define MPTaskIsToolboxSafe _MPTaskIsToolboxSafe
 
#if CALL_NOT_IN_CARBON
#ifndef MPIncludeDefunctServices
#define MPIncludeDefunctServices 1
#endif /* !defined(MPIncludeDefunctServices) */
 
#if MPIncludeDefunctServices
#if CALL_NOT_IN_CARBON
   void _MPDebugStr(ConstStr255Param msg);
 
   StringPtr _MPStatusPString(OSStatus status);
 
   const char *_MPStatusCString(OSStatus status);
 
#endif /* CALL_NOT_IN_CARBON */
 
#include <stdarg.h>
   typedef CALLBACK_API_C(void, MPPrintfHandler)(MPTaskID taskID,
                                                 const char *format, va_list args);
#if CALL_NOT_IN_CARBON
   void _MPInitializePrintf(MPPrintfHandler pfn);
 
   void _MPPrintf(const char *format, ...);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* MPIncludeDefunctServices */
 
#endif /* CALL_NOT_IN_CARBON */
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __MULTIPROCESSING__ */
 
struct CheckingAPIAvailability
{
};
 
struct TaskStateWarning
{
};