1/* 2 * Copyright (c) 2000-2007 Apple Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28 29#ifndef _MACH_THREAD_POLICY_H_ 30#define _MACH_THREAD_POLICY_H_ 31 32#include <mach/mach_types.h> 33 34/* 35 * These are the calls for accessing the policy parameters 36 * of a particular thread. 37 * 38 * The extra 'get_default' parameter to the second call is 39 * IN/OUT as follows: 40 * 1) if asserted on the way in it indicates that the default 41 * values should be returned, not the ones currently set, in 42 * this case 'get_default' will always be asserted on return; 43 * 2) if unasserted on the way in, the current settings are 44 * desired and if still unasserted on return, then the info 45 * returned reflects the current settings, otherwise if 46 * 'get_default' returns asserted, it means that there are no 47 * current settings due to other parameters taking precedence, 48 * and the default ones are being returned instead. 49 */ 50 51typedef natural_t thread_policy_flavor_t; 52typedef integer_t *thread_policy_t; 53 54/* 55kern_return_t thread_policy_set( 56 thread_t thread, 57 thread_policy_flavor_t flavor, 58 thread_policy_t policy_info, 59 mach_msg_type_number_t count); 60 61kern_return_t thread_policy_get( 62 thread_t thread, 63 thread_policy_flavor_t flavor, 64 thread_policy_t policy_info, 65 mach_msg_type_number_t *count, 66 boolean_t *get_default); 67*/ 68 69/* 70 * Defined flavors. 71 */ 72/* 73 * THREAD_STANDARD_POLICY: 74 * 75 * This is the standard (fair) scheduling mode, assigned to new 76 * threads. The thread will be given processor time in a manner 77 * which apportions approximately equal share to long running 78 * computations. 79 * 80 * Parameters: 81 * [none] 82 */ 83 84#define THREAD_STANDARD_POLICY 1 85 86struct thread_standard_policy { 87 natural_t no_data; 88}; 89 90typedef struct thread_standard_policy thread_standard_policy_data_t; 91typedef struct thread_standard_policy *thread_standard_policy_t; 92 93#define THREAD_STANDARD_POLICY_COUNT 0 94 95/* 96 * THREAD_EXTENDED_POLICY: 97 * 98 * Extended form of THREAD_STANDARD_POLICY, which supplies a 99 * hint indicating whether this is a long running computation. 100 * 101 * Parameters: 102 * 103 * timeshare: TRUE (the default) results in identical scheduling 104 * behavior as THREAD_STANDARD_POLICY. 105 */ 106 107#define THREAD_EXTENDED_POLICY 1 108 109struct thread_extended_policy { 110 boolean_t timeshare; 111}; 112 113typedef struct thread_extended_policy thread_extended_policy_data_t; 114typedef struct thread_extended_policy *thread_extended_policy_t; 115 116#define THREAD_EXTENDED_POLICY_COUNT ((mach_msg_type_number_t) \ 117 (sizeof (thread_extended_policy_data_t) / sizeof (integer_t))) 118 119/* 120 * THREAD_TIME_CONSTRAINT_POLICY: 121 * 122 * This scheduling mode is for threads which have real time 123 * constraints on their execution. 124 * 125 * Parameters: 126 * 127 * period: This is the nominal amount of time between separate 128 * processing arrivals, specified in absolute time units. A 129 * value of 0 indicates that there is no inherent periodicity in 130 * the computation. 131 * 132 * computation: This is the nominal amount of computation 133 * time needed during a separate processing arrival, specified 134 * in absolute time units. 135 * 136 * constraint: This is the maximum amount of real time that 137 * may elapse from the start of a separate processing arrival 138 * to the end of computation for logically correct functioning, 139 * specified in absolute time units. Must be (>= computation). 140 * Note that latency = (constraint - computation). 141 * 142 * preemptible: This indicates that the computation may be 143 * interrupted, subject to the constraint specified above. 144 */ 145 146#define THREAD_TIME_CONSTRAINT_POLICY 2 147 148struct thread_time_constraint_policy { 149 uint32_t period; 150 uint32_t computation; 151 uint32_t constraint; 152 boolean_t preemptible; 153}; 154 155typedef struct thread_time_constraint_policy \ 156 thread_time_constraint_policy_data_t; 157typedef struct thread_time_constraint_policy \ 158 *thread_time_constraint_policy_t; 159 160#define THREAD_TIME_CONSTRAINT_POLICY_COUNT ((mach_msg_type_number_t) \ 161 (sizeof (thread_time_constraint_policy_data_t) / sizeof (integer_t))) 162 163/* 164 * THREAD_PRECEDENCE_POLICY: 165 * 166 * This may be used to indicate the relative value of the 167 * computation compared to the other threads in the task. 168 * 169 * Parameters: 170 * 171 * importance: The importance is specified as a signed value. 172 */ 173 174#define THREAD_PRECEDENCE_POLICY 3 175 176struct thread_precedence_policy { 177 integer_t importance; 178}; 179 180typedef struct thread_precedence_policy thread_precedence_policy_data_t; 181typedef struct thread_precedence_policy *thread_precedence_policy_t; 182 183#define THREAD_PRECEDENCE_POLICY_COUNT ((mach_msg_type_number_t) \ 184 (sizeof (thread_precedence_policy_data_t) / sizeof (integer_t))) 185 186/* 187 * THREAD_AFFINITY_POLICY: 188 * 189 * This policy is experimental. 190 * This may be used to express affinity relationships 191 * between threads in the task. Threads with the same affinity tag will 192 * be scheduled to share an L2 cache if possible. That is, affinity tags 193 * are a hint to the scheduler for thread placement. 194 * 195 * The namespace of affinity tags is generally local to one task. However, 196 * a child task created after the assignment of affinity tags by its parent 197 * will share that namespace. In particular, a family of forked processes 198 * may be created with a shared affinity namespace. 199 * 200 * Parameters: 201 * tag: The affinity set identifier. 202 */ 203 204#define THREAD_AFFINITY_POLICY 4 205 206struct thread_affinity_policy { 207 integer_t affinity_tag; 208}; 209 210#define THREAD_AFFINITY_TAG_NULL 0 211 212typedef struct thread_affinity_policy thread_affinity_policy_data_t; 213typedef struct thread_affinity_policy *thread_affinity_policy_t; 214 215#define THREAD_AFFINITY_POLICY_COUNT ((mach_msg_type_number_t) \ 216 (sizeof (thread_affinity_policy_data_t) / sizeof (integer_t))) 217 218/* 219 * THREAD_BACKGROUND_POLICY: 220 */ 221 222#define THREAD_BACKGROUND_POLICY 5 223 224struct thread_background_policy { 225 integer_t priority; 226}; 227 228typedef struct thread_background_policy thread_background_policy_data_t; 229typedef struct thread_background_policy *thread_background_policy_t; 230 231#define THREAD_BACKGROUND_POLICY_COUNT ((mach_msg_type_number_t) \ 232 (sizeof (thread_background_policy_data_t) / sizeof (integer_t))) 233 234#endif /* _MACH_THREAD_POLICY_H_ */ 235