WineASIO
/
wineasio
mirror of https://github.com/wineasio/wineasio
1
0
Fork 0
Code Releases 3 Activity
ASIO to JACK driver for WINE
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
15 Commits
2 Branches
1.1MB
Tree: 1b63dc1d25
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1b63dc1d25'
${ noResults }
wineasio/pThreadUtilities.h

204 lines
7.4KB
Raw Blame History 

  1. /*

  2. 	Copyright:	© Copyright 2002 Apple Computer, Inc. All rights

  3. 			reserved.

  4. 

  5. 	Disclaimer:	IMPORTANT:  This Apple software is supplied to

  6. 			you by Apple Computer, Inc.  ("Apple") in

  7. 			consideration of your agreement to the

  8. 			following terms, and your use, installation,

  9. 			modification or redistribution of this Apple

  10. 			software constitutes acceptance of these

  11. 			terms.  If you do not agree with these terms,

  12. 			please do not use, install, modify or

  13. 			redistribute this Apple software.

  14. 

  15. 			In consideration of your agreement to abide by

  16. 			the following terms, and subject to these

  17. 			terms, Apple grants you a personal,

  18. 			non-exclusive license, under AppleÕs

  19. 			copyrights in this original Apple software

  20. 			(the "Apple Software"), to use, reproduce,

  21. 			modify and redistribute the Apple Software,

  22. 			with or without modifications, in source

  23. 			and/or binary forms; provided that if you

  24. 			redistribute the Apple Software in its

  25. 			entirety and without modifications, you must

  26. 			retain this notice and the following text and

  27. 			disclaimers in all such redistributions of the

  28. 			Apple Software.  Neither the name, trademarks,

  29. 			service marks or logos of Apple Computer,

  30. 			Inc. may be used to endorse or promote

  31. 			products derived from the Apple Software

  32. 			without specific prior written permission from

  33. 			Apple.  Except as expressly stated in this

  34. 			notice, no other rights or licenses, express

  35. 			or implied, are granted by Apple herein,

  36. 			including but not limited to any patent rights

  37. 			that may be infringed by your derivative works

  38. 			or by other works in which the Apple Software

  39. 			may be incorporated.

  40. 

  41. 			The Apple Software is provided by Apple on an

  42. 			"AS IS" basis.  APPLE MAKES NO WARRANTIES,

  43. 			EXPRESS OR IMPLIED, INCLUDING WITHOUT

  44. 			LIMITATION THE IMPLIED WARRANTIES OF

  45. 			NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS

  46. 			FOR A PARTICULAR PURPOSE, REGARDING THE APPLE

  47. 			SOFTWARE OR ITS USE AND OPERATION ALONE OR IN

  48. 			COMBINATION WITH YOUR PRODUCTS.

  49. 

  50. 			IN NO EVENT SHALL APPLE BE LIABLE FOR ANY

  51. 			SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL

  52. 			DAMAGES (INCLUDING, BUT NOT LIMITED TO,

  53. 			PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

  54. 			LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

  55. 			INTERRUPTION) ARISING IN ANY WAY OUT OF THE

  56. 			USE, REPRODUCTION, MODIFICATION AND/OR

  57. 			DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER

  58. 			CAUSED AND WHETHER UNDER THEORY OF CONTRACT,

  59. 			TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY

  60. 			OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED

  61. 			OF THE POSSIBILITY OF SUCH DAMAGE.

  62. */

  63. /* pThreadUtilities.h */

  64. 

  65. #ifndef __PTHREADUTILITIES_H__

  66. #define __PTHREADUTILITIES_H__

  67. 

  68. #import "pthread.h"

  69. #import <CoreServices/../Frameworks/CarbonCore.framework/Headers/MacTypes.h>

  70. 

  71. #define THREAD_SET_PRIORITY			0

  72. #define THREAD_SCHEDULED_PRIORITY		1

  73. 

  74. #include <mach/mach_error.h>

  75. #include <mach/thread_policy.h>

  76. #include <mach/thread_act.h>

  77. #include <CoreAudio/HostTime.h>

  78. 

  79. static inline UInt32

  80. _getThreadPriority(pthread_t inThread, int inWhichPriority)

  81. {

  82.     thread_basic_info_data_t	threadInfo;

  83.     policy_info_data_t		thePolicyInfo;

  84.     unsigned int		count;

  85.     

  86.     // get basic info

  87.     count = THREAD_BASIC_INFO_COUNT;

  88.     thread_info (pthread_mach_thread_np (inThread), THREAD_BASIC_INFO,

  89. 		 (thread_info_t)&threadInfo, &count);

  90. 

  91.     switch (threadInfo.policy) {

  92.         case POLICY_TIMESHARE:

  93.             count = POLICY_TIMESHARE_INFO_COUNT;

  94.             thread_info(pthread_mach_thread_np (inThread),

  95. 			THREAD_SCHED_TIMESHARE_INFO,

  96. 			(thread_info_t)&(thePolicyInfo.ts), &count);

  97.             if (inWhichPriority == THREAD_SCHEDULED_PRIORITY) {

  98.                 return thePolicyInfo.ts.cur_priority;

  99.             } else {

  100.                 return thePolicyInfo.ts.base_priority;

  101.             }

  102.         break;

  103.         

  104.         case POLICY_FIFO:

  105.             count = POLICY_FIFO_INFO_COUNT;

  106.             thread_info(pthread_mach_thread_np (inThread),

  107. 			THREAD_SCHED_FIFO_INFO,

  108. 			(thread_info_t)&(thePolicyInfo.fifo), &count);

  109.             if ( (thePolicyInfo.fifo.depressed)

  110. 		 && (inWhichPriority == THREAD_SCHEDULED_PRIORITY) ) {

  111.                 return thePolicyInfo.fifo.depress_priority;

  112.             }

  113.             return thePolicyInfo.fifo.base_priority;

  114.         break;

  115.         

  116.         case POLICY_RR:

  117.             count = POLICY_RR_INFO_COUNT;

  118.             thread_info(pthread_mach_thread_np (inThread),

  119. 			THREAD_SCHED_RR_INFO,

  120. 			(thread_info_t)&(thePolicyInfo.rr), &count);

  121.             if ( (thePolicyInfo.rr.depressed)

  122. 		 && (inWhichPriority == THREAD_SCHEDULED_PRIORITY) ) {

  123.                 return thePolicyInfo.rr.depress_priority;

  124.             }

  125.             return thePolicyInfo.rr.base_priority;

  126.         break;

  127.     }

  128.     

  129.     return 0;

  130. }

  131. 

  132. // returns the thread's priority as it was last set by the API

  133. static inline UInt32

  134. getThreadSetPriority(pthread_t inThread)

  135. {

  136.     return _getThreadPriority (inThread, THREAD_SET_PRIORITY);

  137. }

  138. 

  139. // returns the thread's priority as it was last scheduled by the Kernel

  140. static inline UInt32

  141. getThreadScheduledPriority(pthread_t inThread)

  142. {

  143.     return _getThreadPriority (inThread, THREAD_SCHEDULED_PRIORITY);

  144. }

  145. 

  146. 

  147. static inline void

  148. setThreadToPriority(pthread_t inThread, UInt32 inPriority, Boolean inIsFixed,

  149. 		    UInt64 inHALIOProcCycleDurationInNanoseconds)

  150. {

  151. 	if (inPriority == 96)

  152. 	{

  153.             // REAL-TIME / TIME-CONSTRAINT THREAD

  154.             thread_time_constraint_policy_data_t	theTCPolicy;

  155.             UInt64					theComputeQuanta;

  156.             UInt64					thePeriod;

  157.             UInt64					thePeriodNanos;

  158. 		

  159.             thePeriodNanos = inHALIOProcCycleDurationInNanoseconds;

  160.             theComputeQuanta = AudioConvertNanosToHostTime ( thePeriodNanos * 0.15 );

  161.             thePeriod = AudioConvertNanosToHostTime (thePeriodNanos);

  162.         

  163.             theTCPolicy.period = thePeriod;

  164.             theTCPolicy.computation = theComputeQuanta;

  165.             theTCPolicy.constraint = thePeriod;

  166.             theTCPolicy.preemptible = true;

  167.             thread_policy_set (pthread_mach_thread_np(inThread),

  168. 			       THREAD_TIME_CONSTRAINT_POLICY,

  169. 			       (thread_policy_t)&theTCPolicy,

  170. 			       THREAD_TIME_CONSTRAINT_POLICY_COUNT);

  171. 	} else {

  172.             // OTHER THREADS

  173.             thread_extended_policy_data_t		theFixedPolicy;

  174.             thread_precedence_policy_data_t		thePrecedencePolicy;

  175.             SInt32					relativePriority;

  176.         

  177.             // [1] SET FIXED / NOT FIXED

  178.             theFixedPolicy.timeshare = !inIsFixed;

  179.             thread_policy_set (pthread_mach_thread_np(inThread),

  180. 			       THREAD_EXTENDED_POLICY,

  181. 			       (thread_policy_t)&theFixedPolicy,

  182. 			       THREAD_EXTENDED_POLICY_COUNT);

  183.         

  184.             // [2] SET PRECEDENCE N.B.: We expect that if thread A

  185.             // created thread B, and the program wishes to change the

  186.             // priority of thread B, then the call to change the

  187.             // priority of thread B must be made by thread A.  This

  188.             // assumption allows us to use pthread_self() to correctly

  189.             // calculate the priority of the feeder thread (since

  190.             // precedency policy's importance is relative to the

  191.             // spawning thread's priority.)

  192.             relativePriority = inPriority -

  193. 		    getThreadSetPriority (pthread_self());

  194.         

  195.             thePrecedencePolicy.importance = relativePriority;

  196.             thread_policy_set (pthread_mach_thread_np(inThread),

  197. 			       THREAD_PRECEDENCE_POLICY,

  198. 			       (thread_policy_t)&thePrecedencePolicy,

  199. 			       THREAD_PRECEDENCE_POLICY_COUNT);

  200. 	}

  201. }

  202. 

  203. #endif	/* __PTHREADUTILITIES_H__ */