![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mk_sp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to mk_sp.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: *
25: */
26:
27: /***
28: *** ??? The following lines were picked up when code was incorporated
29: *** into this file from `kern/syscall_subr.c.' These should be moved
30: *** with the code if it moves again. Otherwise, they should be trimmed,
31: *** based on the files included above.
32: ***/
33:
34: #include <mach/boolean.h>
35: #include <mach/thread_switch.h>
36: #include <ipc/ipc_port.h>
37: #include <ipc/ipc_space.h>
38: #include <kern/counters.h>
39: #include <kern/ipc_kobject.h>
40: #include <kern/processor.h>
41: #include <kern/sched.h>
42: #include <kern/sched_prim.h>
43: #include <kern/spl.h>
44: #include <kern/task.h>
45: #include <kern/thread.h>
46: #include <kern/ast.h>
47: #include <mach/policy.h>
48:
49: #include <kern/syscall_subr.h>
50: #include <mach/mach_host_server.h>
51: #include <mach/mach_syscalls.h>
52:
53: /***
54: *** ??? End of lines picked up when code was incorporated
55: *** into this file from `kern/syscall_subr.c.'
56: ***/
57:
58: #include <kern/sf.h>
59: #include <kern/mk_sp.h>
60: #include <kern/misc_protos.h>
61: #include <kern/spl.h>
62: #include <kern/sched.h>
63: #include <kern/sched_prim.h>
64: #include <kern/assert.h>
65: #include <kern/thread.h>
66: #include <mach/mach_host_server.h>
67:
68: /* Forwards */
69: void _mk_sp_thread_depress_priority(
70: sf_object_t policy,
71: mach_msg_timeout_t depress_time);
72:
73: /***
74: *** ??? The next two files supply the prototypes for `thread_set_policy()'
75: *** and `thread_policy.' These routines cannot stay here if they are
76: *** exported Mach system calls.
77: ***/
78: #include <mach/thread_act_server.h>
79: #include <mach/host_priv_server.h>
80:
81: /*
82: * Vector containing standard scheduling policy operations
83: */
84: sp_ops_t mk_sp_ops = {
85: _mk_sp_init,
86: _mk_sp_enable_processor_set,
87: _mk_sp_disable_processor_set,
88: _mk_sp_enable_processor,
89: _mk_sp_disable_processor,
90: _mk_sp_thread_update_mpri,
91: _mk_sp_thread_unblock,
92: _mk_sp_thread_done,
93: _mk_sp_thread_begin,
94: _mk_sp_thread_dispatch,
95: _mk_sp_thread_attach,
96: _mk_sp_thread_detach,
97: _mk_sp_thread_processor,
98: _mk_sp_thread_processor_set,
99: _mk_sp_thread_set,
100: _mk_sp_thread_get,
101: _mk_sp_db_print_sched_stats,
102: _mk_sp_swtch_pri,
103: _mk_sp_thread_switch,
104: _mk_sp_thread_depress_abort,
105: _mk_sp_thread_depress_timeout,
106: _mk_sp_task_attach,
107: _mk_sp_task_detach,
108: _mk_sp_task_policy,
109: _mk_sp_task_set_policy,
110: _mk_sp_task_set_sched,
111: _mk_sp_task_get_sched,
112: _mk_sp_thread_runnable,
113: _mk_sp_alarm_expired
114: };
115:
116: /* Forwards */
117: kern_return_t thread_policy_common(
118: thread_t thread,
119: int policy,
120: int data,
121: processor_set_t pset);
122:
123: void _mk_sp_thread_dump(
124: sched_thread_t thread);
125:
126: /*
127: * Local variables
128: */
129: #ifdef MACH_ASSERT
130: boolean_t mk_sp_first_thread = TRUE;
131: #endif /* MACH_ASSERT */
132:
133: /*
134: * Counters to monitor policy-related events
135: */
136: mach_counter_t c_mk_sp_init = 0,
137: c_mk_sp_enable_processor_set = 0,
138: c_mk_sp_disable_processor_set = 0,
139: c_mk_sp_enable_processor = 0,
140: c_mk_sp_disable_processor = 0,
141: c_mk_sp_thread_update_mpri = 0,
142: c_mk_sp_thread_unblock = 0,
143: c_mk_sp_thread_done = 0,
144: c_mk_sp_thread_begin = 0,
145: c_mk_sp_thread_dispatch = 0,
146: c_mk_sp_thread_attach = 0,
147: c_mk_sp_thread_detach = 0,
148: c_mk_sp_thread_processor = 0,
149: c_mk_sp_thread_processor_set = 0,
150: c_mk_sp_thread_set = 0,
151: c_mk_sp_thread_get = 0,
152: c_mk_sp_db_print_sched_stats = 0,
153: c_mk_sp_swtch_pri = 0,
154: c_mk_sp_thread_switch = 0,
155: c_mk_sp_thread_depress_abort = 0,
156: c_mk_sp_thread_depress_timeout = 0,
157: c_mk_sp_task_attach = 0,
158: c_mk_sp_task_detach = 0,
159: c_mk_sp_task_policy = 0,
160: c_mk_sp_task_set_policy = 0,
161: c_mk_sp_task_set_sched = 0,
162: c_mk_sp_task_get_sched = 0,
163: c_mk_sp_thread_runnable = 0,
164: c_mk_sp_alarm_expired = 0;
165:
166: /*
167: * Table to convert computed priorities into allocated priority range.
168: */
169: int convert_pri[NRQS];
170:
171: /*
172: * Lowest (normal -- i.e., not idle and not depressed) priority
173: */
174: int lpri = -1;
175:
176: natural_t min_quantum_ms;
177:
178: /*
179: * Standard operations for MK Scheduling Policy
180: */
181:
182: sf_return_t
183: _mk_sp_init(
184: sf_object_t policy,
185: int policy_id,
186: int priority_mask_length,
187: sf_priority_mask_t priority_mask)
188: {
189: int i;
190: int first_metapri;
191: int last_metapri;
192:
193: counter(c_mk_sp_init++);
194:
195: /*
196: * Initialize fields in the structure
197: */
198: policy->policy_id = policy_id;
199: policy->priority_mask_length = priority_mask_length;
200: policy->priority_mask = *priority_mask;
201: /*** ??? should something more dynamic be done here for mask? ***/
202: policy->sched_attributes_size = sizeof (mk_sp_attribute_struct_t);
203: policy->sched_info_size = sizeof (mk_sp_info_struct_t);
204:
205: /*
206: * Initialize table that maps computed priority values into
207: * allocated metapriority values.
208: */
209:
210: /* Find first metapriority value allocated to this policy */
211: first_metapri = MAXPRI - ffsbit(priority_mask->bitmap);
212: /*** ??? how to test for no set bits? ***/
213:
214: /* Map computed priorities higher than this to first metapriority */
215: for (i = MAXPRI; i > first_metapri; i--)
216: convert_pri[i] = first_metapri;
217:
218: /* For each remaining computed priority value... */
219: for (i = first_metapri; i >= 0; i--) {
220: /* ... is it a metapriority value assigned to this policy ?*/
221: if (testbit(MAXPRI - i, priority_mask->bitmap)) {
222: /* Yes; just use it */
223: convert_pri[i] = i;
224: last_metapri = i;
225: }
226: else {
227: /* No, bump it up to the last value assigned */
228: convert_pri[i] = last_metapri;
229: }
230: }
231:
232: /* Remember lowest "normal" priority available to this policy */
233: lpri = convert_pri[LPRI];
234:
235: min_quantum_ms = (1000 / hz) * min_quantum;
236:
237: #if 0
238: /* Initialize operation entries in "jump table" */
239: /***
240: *** ??? These must be done elsewhere. Otherwise, there is a
241: *** circularity: How does the framework find this init operation?
242: ***/
243: policy->sp_ops = mk_sp_ops;
244:
245: policy->sp_ops.sp_enable_processor_set = sp_mk_enable_processor_set;
246: policy->sp_ops.sp_disable_processor_set = sp_mk_disable_processor_set;
247: policy->sp_ops.sp_enable_processor = sp_mk_enable_processor;
248: policy->sp_ops.sp_disable_processor = sp_mk_disable_processor;
249: policy->sp_ops.sp_thread_unblock = sp_mk_thread_unblock;
250: policy->sp_ops.sp_thread_done = sp_mk_thread_done;
251: policy->sp_ops.sp_thread_begin = sp_mk_thread_begin;
252: policy->sp_ops.sp_thread_attach = sp_mk_thread_attach;
253: policy->sp_ops.sp_thread_detach = sp_mk_thread_detach;
254: policy->sp_ops.sp_thread_processor = sp_mk_thread_processor;
255: policy->sp_ops.sp_thread_processor_set = sp_mk_thread_processor_set;
256: policy->sp_ops.sp_thread_set = sp_mk_thread_set;
257: policy->sp_ops.sp_thread_get = sp_mk_thread_get;
258: policy->sp_ops.sp_db_print_sched_stats = sp_mk_db_print_sched_stats;
259: #endif
260:
261: return(SF_SUCCESS);
262: }
263:
264: sf_return_t
265: _mk_sp_enable_processor_set(
266: sf_object_t policy,
267: processor_set_t processor_set)
268: {
269: kern_return_t result;
270:
271: counter(c_mk_sp_enable_processor_set++);
272:
273: result = processor_set_policy_enable(processor_set, policy->policy_id);
274: assert(result == KERN_SUCCESS);
275:
276: return(SF_SUCCESS);
277: }
278:
279: sf_return_t
280: _mk_sp_disable_processor_set(
281: sf_object_t policy,
282: processor_set_t processor_set)
283: {
284: kern_return_t result;
285:
286: counter(c_mk_sp_disable_processor_set++);
287:
288: result = processor_set_policy_disable(
289: processor_set, policy->policy_id, TRUE);
290: assert(result == KERN_SUCCESS);
291:
292: return(SF_SUCCESS);
293: }
294:
295: sf_return_t
296: _mk_sp_enable_processor(
297: sf_object_t policy,
298: processor_t processor)
299: {
300: counter(c_mk_sp_enable_processor++);
301:
302: panic("not yet implemented???");
303:
304: return(SF_FAILURE);
305: }
306:
307: sf_return_t
308: _mk_sp_disable_processor(
309: sf_object_t policy,
310: processor_t processor)
311: {
312: counter(c_mk_sp_disable_processor++);
313:
314: panic("not yet implemented???");
315:
316: return(SF_FAILURE);
317: }
318:
319: sf_return_t
320: _mk_sp_thread_update_mpri(
321: sf_object_t policy,
322: sched_thread_t thread)
323: {
324: mk_sp_info_t sp_info;
325:
326: counter(c_mk_sp_thread_update_mpri++);
327:
328: /* get pointer to scheduling policy-specific data */
329: assert(thread->sp_info != SP_INFO_NULL);
330: sp_info = (mk_sp_info_t)thread->sp_info;
331:
332: if (sp_info->sched_stamp != sched_tick)
333: update_priority(thread);
334:
335: return(SF_SUCCESS);
336: }
337:
338: sf_return_t
339: _mk_sp_thread_unblock(
340: sf_object_t policy,
341: sched_thread_t thread)
342: {
343: mk_sp_info_t sp_info;
344:
345: counter(c_mk_sp_thread_unblock++);
346:
347: /* get pointer to scheduling policy-specific data */
348: assert(thread->sp_info != SP_INFO_NULL);
349: sp_info = (mk_sp_info_t)thread->sp_info;
350:
351: counter(sp_info->c_mk_sp_thread_unblock++);
352:
353: /*
354: * The following assert is removed because we're hacking the
355: * MK_SP_BLOCKED bit and removing it early to get SMP to work
356: * with this gosh darned scheduler. The whole danged thing is lousy and
357: * needs to be removed. Hopefully for now, no one tries to
358: * unblock a really runnable guy - HACKALERT!!!
359: */
360:
361: /* check for legal thread states */
362: #if 0
363: assert(sp_info->th_state == MK_SP_BLOCKED ||
364: sp_info->th_state == MK_SP_ATTACHED); /* ??? work to remove*/
365: #endif
366: /* indicate thread is now runnable */
367: sp_info->th_state = MK_SP_RUNNABLE;
368:
369: /* place thread at end of appropriate run queue */
370: thread_setrun(thread, TRUE, TAIL_Q);
371:
372: return(SF_SUCCESS);
373: }
374:
375: sf_return_t
376: _mk_sp_thread_done(
377: sf_object_t policy,
378: sched_thread_t old_thread)
379: {
380: processor_t myprocessor = cpu_to_processor(cpu_number());
381: mk_sp_info_t sp_info;
382:
383: counter(c_mk_sp_thread_done++);
384:
385: /*
386: * A running thread is being taken off a processor:
387: *
388: * - update the thread's `unconsumed_quantum' field
389: * - update the thread's state field
390: */
391:
392: /* get pointer to scheduling policy-specific data */
393: assert(old_thread->sp_info != SP_INFO_NULL);
394: sp_info = (mk_sp_info_t)old_thread->sp_info;
395:
396: counter(sp_info->c_mk_sp_thread_done++);
397: assert((sp_info->c_mk_sp_thread_done
398: == sp_info->c_mk_sp_thread_begin + 1) ||
399: (sp_info->c_mk_sp_thread_done
400: == sp_info->c_mk_sp_thread_begin));
401:
402: sp_info->unconsumed_quantum = myprocessor->quantum;
403:
404: /* check thread's current state */
405: assert(mk_sp_first_thread || (sp_info->th_state & MK_SP_RUNNABLE));
406: #ifdef MACH_ASSERT
407: mk_sp_first_thread = FALSE;
408: #endif /* MACH_ASSERT */
409:
410: /* update thread's state field based on reason for stopping now */
411: /*** ??? is this condition correct? should it be more selective? ***/
412: /*** ??? if ((old_thread->reason != AST_NONE) ||
413: (old_thread->wait_event != NO_EVENT)) { ***/
414: if (old_thread->state & TH_WAIT) {
415: sp_info->th_state = MK_SP_BLOCKED;
416: }
417:
418: return(SF_SUCCESS);
419: }
420:
421: sf_return_t
422: _mk_sp_thread_begin(
423: sf_object_t policy,
424: sched_thread_t thread)
425: {
426:
427: processor_t myprocessor = cpu_to_processor(cpu_number());
428: processor_set_t pset;
429: mk_sp_info_t sp_info;
430:
431: counter(c_mk_sp_thread_begin++);
432:
433: pset = myprocessor->processor_set;
434: /*
435: * The designated thread is about to begin execution:
436: *
437: * - update the processor's `quantum' field
438: */
439:
440: /* get pointer to scheduling policy-specific data */
441: assert(thread->sp_info != SP_INFO_NULL);
442: sp_info = (mk_sp_info_t)thread->sp_info;
443:
444: counter(sp_info->c_mk_sp_thread_begin++);
445: assert((sp_info->c_mk_sp_thread_done
446: == sp_info->c_mk_sp_thread_begin) ||
447: (sp_info->c_mk_sp_thread_done + 1
448: == sp_info->c_mk_sp_thread_begin));
449:
450: /* check for legal thread state */
451: assert(sp_info->th_state == MK_SP_RUNNABLE);
452:
453: if (thread->policy & (POLICY_RR|POLICY_FIFO))
454: myprocessor->quantum = sp_info->unconsumed_quantum;
455: else
456: myprocessor->quantum = (thread->bound_processor ?
457: min_quantum : pset->set_quantum);
458:
459: return(SF_SUCCESS);
460: }
461:
462: sf_return_t
463: _mk_sp_thread_dispatch(
464: sf_object_t policy,
465: sched_thread_t old_thread)
466: {
467: mk_sp_info_t sp_info;
468:
469: counter(c_mk_sp_thread_dispatch++);
470:
471: /* get pointer to scheduling policy-specific data */
472: assert(old_thread->sp_info != SP_INFO_NULL);
473: sp_info = (mk_sp_info_t)old_thread->sp_info;
474:
475: counter(sp_info->c_mk_sp_thread_dispatch++);
476:
477: if (sp_info->th_state & MK_SP_RUNNABLE) {
478: if (old_thread->reason & AST_QUANTUM) {
479: thread_setrun(old_thread, FALSE, TAIL_Q);
480: sp_info->unconsumed_quantum = sp_info->sched_data;
481: }
482: else
483: thread_setrun(old_thread, FALSE, HEAD_Q);
484: }
485:
486: if (sp_info->th_state & MK_SP_ATTACHED) {
487: /* indicate thread is now runnable */
488: sp_info->th_state = MK_SP_RUNNABLE;
489:
490: /* place thread at end of appropriate run queue */
491: thread_setrun(old_thread, FALSE, TAIL_Q);
492: }
493:
494: return(SF_SUCCESS);
495: }
496:
497: /*
498: * Thread must already be locked.
499: */
500: sf_return_t
501: _mk_sp_thread_attach(
502: sf_object_t policy,
503: sched_thread_t thread)
504: {
505: mk_sp_info_t sp_info;
506:
507: counter(c_mk_sp_thread_attach++);
508:
509: /* Make sure there is a place for policy-specific state */
510: assert(thread->sp_info != SP_INFO_NULL);
511:
512: sp_info = (mk_sp_info_t)thread->sp_info;
513: sp_info->th_state = MK_SP_ATTACHED;
514: /*** ??? Do these need to be done here? ***/
515: /*** ??? If so, could fill from template for speed -- maybe ***/
516: sp_info->priority = MINPRI; /*** ??? ***/
517: sp_info->max_priority = BASEPRI_USER;
518: /*** ??? sp_info->sched_pri =
519: (later - compute_priority); (for now, at least) ***/
520: sp_info->sched_data = 0;
521: sp_info->policy = policy->policy_id; /*** ??? ***/
522: sp_info->depress_priority = -1;
523: sp_info->cpu_usage = 0;
524: sp_info->sched_usage = 0;
525: sp_info->sched_stamp = 0; /*** ??? ***/
526: sp_info->unconsumed_quantum = 0; /*** ??? ***/
527:
528: #ifdef MACH_ASSERT
529: sp_info->c_mk_sp_thread_attach = 1;
530: sp_info->c_mk_sp_thread_detach = 0;
531: sp_info->c_mk_sp_thread_begin = 0;
532: sp_info->c_mk_sp_thread_done = 0;
533: sp_info->c_mk_sp_thread_dispatch = 0;
534: sp_info->c_mk_sp_thread_unblock = 0;
535: sp_info->c_mk_sp_thread_set = 0;
536: sp_info->c_mk_sp_thread_get = 0;
537: #endif /* MACH_ASSERT */
538:
539: /* Reflect this policy in thread data structure */
540: thread->policy = policy->policy_id;
541:
542: return(SF_SUCCESS);
543: }
544:
545: /*
546: * Check to make sure that thread is removed from run
547: * queues and active execution; and clean up the
548: * policy-specific data structure for thread.
549: *
550: * Thread must already be locked.
551: */
552: sf_return_t
553: _mk_sp_thread_detach(
554: sf_object_t policy,
555: sched_thread_t thread)
556: {
557: mk_sp_info_t sp_info;
558: struct run_queue *rq;
559:
560: assert(thread->policy == policy->policy_id);
561:
562: counter(c_mk_sp_thread_detach++);
563: /* get pointer to scheduling policy-specific data */
564: assert(thread->sp_info != SP_INFO_NULL);
565: sp_info = (mk_sp_info_t)thread->sp_info;
566:
567: counter(sp_info->c_mk_sp_thread_detach++);
568:
569: /* make sure that the thread has stopped executing */
570: /*** ??? look at machine's version of RUN bit, too? ***/
571: /***
572: *** Fix for SMP case.
573: ***/
574:
575: /* make sure that the thread is no longer on any run queue */
576: if (thread->runq != RUN_QUEUE_NULL) {
577: rq = rem_runq(thread);
578: if (rq == RUN_QUEUE_NULL) {
579: panic("mk_sp_thread_detach: missed thread");
580: }
581: }
582:
583: /* (optionally) clear policy-specific data structure for the thread */
584:
585: if (sp_info->depress_priority >= 0) {
586: sp_info->priority = sp_info->depress_priority;
587: sp_info->depress_priority = -1;
588: if (thread_call_cancel(&thread->depress_timer))
589: thread_call_enter(&thread->depress_timer);
590: }
591:
592: /* clear the thread's policy field */
593: thread->policy = POLICY_NULL;
594:
595: return(SF_SUCCESS);
596: }
597:
598: sf_return_t
599: _mk_sp_thread_processor(
600: sf_object_t policy,
601: sched_thread_t *thread,
602: processor_t processor)
603: {
604: counter(c_mk_sp_thread_processor++);
605:
606: panic("not yet implemented???");
607:
608: return(SF_FAILURE);
609: }
610:
611: sf_return_t
612: _mk_sp_thread_processor_set(
613: sf_object_t policy,
614: sched_thread_t thread,
615: processor_set_t processor_set)
616: {
617: counter(c_mk_sp_thread_processor_set++);
618:
619: pset_add_thread(processor_set, thread);
620:
621: return(SF_SUCCESS);
622: }
623:
624: sf_return_t
625: _mk_sp_thread_set(
626: sf_object_t policy,
627: sched_thread_t thread,
628: sp_attributes_t policy_attributes)
629: {
630: mk_sp_info_t sp_info;
631: mk_sp_attributes_t attributes;
632:
633: counter(c_mk_sp_thread_set++);
634:
635: /* check that attributes are for this policy */
636: assert(policy_attributes->policy_id == policy->policy_id);
637:
638: attributes = (mk_sp_attributes_t)policy_attributes;
639:
640: /* get pointer to scheduling policy-specific data */
641: assert(thread->sp_info != SP_INFO_NULL);
642: sp_info = (mk_sp_info_t)thread->sp_info;
643:
644: counter(sp_info->c_mk_sp_thread_set++);
645:
646: /* update scheduling parameters */
647: sp_info->priority = attributes->priority;
648: sp_info->max_priority = attributes->max_priority;
649: sp_info->sched_data = attributes->sched_data;
650: sp_info->unconsumed_quantum = attributes->unconsumed_quantum;
651:
652: /*
653: * No check is needed against the pset limit. If the task could raise
654: * its priority above the limit, then it must have had permisssion.
655: */
656:
657: /*
658: * Determine thread's state. (It may be an "older" thread
659: * that has just been associated with this policy.)
660: */
661: if (thread->state & TH_WAIT) {
662: sp_info->th_state = MK_SP_BLOCKED;
663: }
664:
665: /* recompute priority */
666: sp_info->sched_stamp = sched_tick;
667: compute_priority(thread, TRUE);
668:
669: return(SF_SUCCESS);
670: }
671:
672: sf_return_t
673: _mk_sp_thread_get(
674: sf_object_t policy,
675: sched_thread_t thread,
676: sp_attributes_t policy_attributes,
677: sp_attributes_size_t size)
678: /*
679: * Assumes that thread is locked.
680: */
681: /***
682: *** ??? Does it assume `splsched()'?
683: ***/
684: {
685: mk_sp_info_t sp_info;
686: mk_sp_attributes_t attributes;
687:
688: counter(c_mk_sp_thread_get++);
689:
690: /* check size of attribute structure provided by caller */
691: if (policy->sched_attributes_size > size)
692: return(SF_FAILURE);
693:
694: attributes = (mk_sp_attributes_t)policy_attributes;
695:
696:
697: /* get pointer to scheduling policy-specific data */
698: assert(thread->sp_info != SP_INFO_NULL);
699: sp_info = (mk_sp_info_t)thread->sp_info;
700:
701: counter(sp_info->c_mk_sp_thread_get++);
702:
703: /* copy scheduling attributes */
704: attributes->policy_id = policy->policy_id;
705: attributes->priority = sp_info->priority;
706: attributes->max_priority = sp_info->max_priority;
707: attributes->sched_data = sp_info->sched_data;
708: attributes->unconsumed_quantum = sp_info->unconsumed_quantum;
709:
710: return(SF_SUCCESS);
711: }
712:
713: int
714: _mk_sp_db_print_sched_stats(
715: sf_object_t policy,
716: sched_thread_t thread)
717: {
718: mk_sp_info_t sp_info;
719:
720: counter(c_mk_sp_db_print_sched_stats++);
721:
722: /* get pointer to scheduling policy-specific data */
723: assert(thread->sp_info != SP_INFO_NULL);
724: sp_info = (mk_sp_info_t)thread->sp_info;
725:
726: /* print one field -- `sched_pri' */
727: return (thread->sched_pri);
728: }
729:
730: /*
731: * thread_priority:
732: *
733: * Set priority (and possibly max priority) for thread.
734: */
735: kern_return_t
736: thread_priority(
737: thread_act_t thr_act,
738: int priority,
739: boolean_t set_max)
740: {
741: kern_return_t result;
742: thread_t thread;
743:
744: if (thr_act == THR_ACT_NULL)
745: return (KERN_INVALID_ARGUMENT);
746:
747: thread = act_lock_thread(thr_act);
748: if (thread == THREAD_NULL || invalid_pri(priority)) {
749: act_unlock_thread(thr_act);
750: return (KERN_INVALID_ARGUMENT);
751: }
752:
753: result = thread_priority_locked(thread, priority, set_max);
754: act_unlock_thread(thr_act);
755:
756: return (result);
757: }
758:
759: /*
760: * thread_priority_locked:
761: *
762: * Kernel-internal work function for thread_priority(). Called
763: * with thread "properly locked" to ensure synchrony with RPC
764: * (see act_lock_thread()).
765: */
766: kern_return_t
767: thread_priority_locked(
768: thread_t thread,
769: int priority,
770: boolean_t set_max)
771: {
772: kern_return_t result = KERN_SUCCESS;
773: mk_sp_info_t sched_info;
774: spl_t s;
775:
776: s = splsched();
777: thread_lock(thread);
778:
779: /* get pointer to scheduling policy-specific data */
780: assert(thread->sp_info != SP_INFO_NULL);
781: sched_info = (mk_sp_info_t)thread->sp_info;
782:
783: /*
784: * Check for violation of max priority
785: */
786: if (priority > sched_info->max_priority)
787: result = KERN_FAILURE;
788: else {
789: /*
790: * Set priorities. If a depression is in progress,
791: * change the priority to restore.
792: */
793: if (sched_info->depress_priority >= 0) {
794: sched_info->depress_priority = priority;
795: }
796: else {
797: sched_info->priority = priority;
798: compute_priority(thread, TRUE);
799:
800: /*
801: * If the current thread has changed its
802: * priority let the ast code decide whether
803: * a different thread should run.
804: */
805: if (thread == current_thread())
806: ast_on(AST_BLOCK);
807: }
808:
809: if (set_max)
810: sched_info->max_priority = priority;
811: }
812:
813: thread_unlock(thread);
814: splx(s);
815:
816: return(result);
817: }
818:
819: /*
820: * thread_set_own_priority:
821: *
822: * Internal use only; sets the priority of the calling thread.
823: * Will adjust max_priority if necessary.
824: */
825: void
826: thread_set_own_priority(
827: int priority)
828: {
829: thread_t thread = current_thread();
830: mk_sp_info_t sched_info;
831: spl_t s;
832:
833: s = splsched();
834: thread_lock(thread);
835:
836: /* get pointer to scheduling policy-specific data */
837: assert(thread->sp_info != SP_INFO_NULL);
838: sched_info = (mk_sp_info_t)thread->sp_info;
839:
840: if (priority > sched_info->max_priority)
841: sched_info->max_priority = priority;
842: sched_info->priority = priority;
843: compute_priority(thread, TRUE);
844:
845: thread_unlock(thread);
846: splx(s);
847: }
848:
849: /*
850: * thread_max_priority:
851: *
852: * Reset the max priority for a thread.
853: */
854: kern_return_t
855: thread_max_priority(
856: thread_act_t thr_act,
857: processor_set_t pset,
858: int max_priority)
859: {
860: thread_t thread;
861: kern_return_t result = KERN_SUCCESS;
862:
863: if (thr_act == THR_ACT_NULL)
864: return(KERN_INVALID_ARGUMENT);
865:
866: thread = act_lock_thread(thr_act);
867: if (thread == THREAD_NULL || pset == PROCESSOR_SET_NULL ||
868: invalid_pri(max_priority)) {
869: act_unlock_thread(thr_act);
870: return(KERN_INVALID_ARGUMENT);
871: }
872:
873: result = thread_max_priority_locked(thread, pset, max_priority);
874: act_unlock_thread(thr_act);
875:
876: return (result);
877: }
878:
879: /*
880: * thread_max_priority_locked:
881: *
882: * Work function for thread_max_priority.
883: *
884: * Called with all RPC-related locks held for thread (see
885: * act_lock_thread()).
886: */
887: kern_return_t
888: thread_max_priority_locked(
889: thread_t thread,
890: processor_set_t pset,
891: int max_priority)
892: {
893: kern_return_t result = KERN_SUCCESS;
894: mk_sp_info_t sched_info;
895: spl_t s;
896:
897: s = splsched();
898: thread_lock(thread);
899:
900: /* get pointer to scheduling policy-specific data */
901: assert(thread->sp_info != SP_INFO_NULL);
902: sched_info = (mk_sp_info_t)thread->sp_info;
903:
904: #if MACH_HOST
905: /*
906: * Check for wrong processor set.
907: */
908: if (pset != thread->processor_set)
909: result = KERN_FAILURE;
910: else {
911: #endif /* MACH_HOST */
912: sched_info->max_priority = max_priority;
913:
914: /*
915: * Reset priority if it violates new max priority
916: */
917: if (max_priority < sched_info->priority) {
918: sched_info->priority = max_priority;
919:
920: compute_priority(thread, TRUE);
921: }
922: else if (sched_info->depress_priority >= 0 &&
923: max_priority < sched_info->depress_priority)
924: sched_info->depress_priority = max_priority;
925: #if MACH_HOST
926: }
927: #endif /* MACH_HOST */
928:
929: thread_unlock(thread);
930: splx(s);
931:
932: return(result);
933: }
934:
935: /*
936: * thread_policy_common:
937: *
938: * Set scheduling policy for thread. If pset == PROCESSOR_SET_NULL,
939: * policy will be checked to make sure it is enabled.
940: */
941: kern_return_t
942: thread_policy_common(
943: thread_t thread,
944: int policy,
945: int data,
946: processor_set_t pset)
947: {
948: kern_return_t result = KERN_SUCCESS;
949: mk_sp_info_t sched_info;
950: register int temp;
951: spl_t s;
952:
953: if (thread == THREAD_NULL || invalid_policy(policy))
954: return(KERN_INVALID_ARGUMENT);
955:
956: s = splsched();
957: thread_lock(thread);
958:
959: /* get pointer to scheduling policy-specific data */
960: assert(thread->sp_info != SP_INFO_NULL);
961: sched_info = (mk_sp_info_t)thread->sp_info;
962:
963: /*
964: * Check if changing policy.
965: */
966: if (policy == thread->policy) {
967: /*
968: * Just changing data. This is meaningless for
969: * timeshareing, quantum for fixed priority (but
970: * has no effect until current quantum runs out).
971: */
972: if (policy == POLICY_FIFO || policy == POLICY_RR) {
973: temp = data * 1000;
974: if (temp % tick)
975: temp += tick;
976: sched_info->sched_data = temp/tick;
977: sched_info->unconsumed_quantum = temp/tick;
978: }
979: }
980: else {
981: /*
982: * Changing policy. Check if new policy is allowed.
983: */
984: if (pset == PROCESSOR_SET_NULL &&
985: (thread->processor_set->policies & policy) == 0) {
986: result = KERN_FAILURE;
987: }
988: else {
989: if (pset != thread->processor_set) {
990: result = KERN_FAILURE;
991: }
992: else {
993: /*
994: * Changing policy. Save data and calculate new
995: * priority.
996: */
997: thread->policy = policy;
998: sched_info->policy = policy;
999: if (policy == POLICY_FIFO || policy == POLICY_RR) {
1000: temp = data * 1000;
1001: if (temp % tick)
1002: temp += tick;
1003: sched_info->sched_data = temp/tick;
1004: sched_info->unconsumed_quantum = temp/tick;
1005: }
1006: compute_priority(thread, TRUE);
1007: }
1008: }
1009: }
1010:
1011: thread_unlock(thread);
1012: splx(s);
1013:
1014: return(result);
1015: }
1016:
1017: /*
1018: * thread_set_policy
1019: *
1020: * Set scheduling policy and parameters, both base and limit, for
1021: * the given thread. Policy can be any policy implemented by the
1022: * processor set, whether enabled or not.
1023: */
1024: kern_return_t
1025: thread_set_policy(
1026: thread_act_t thr_act,
1027: processor_set_t pset,
1028: policy_t policy,
1029: policy_base_t base,
1030: mach_msg_type_number_t base_count,
1031: policy_limit_t limit,
1032: mach_msg_type_number_t limit_count)
1033: {
1034: thread_t thread;
1035: int max, bas, dat;
1036: kern_return_t result = KERN_SUCCESS;
1037:
1038: if (thr_act == THR_ACT_NULL || pset == PROCESSOR_SET_NULL)
1039: return (KERN_INVALID_ARGUMENT);
1040:
1041: thread = act_lock_thread(thr_act);
1042: if (thread == THREAD_NULL) {
1043: act_unlock_thread(thr_act);
1044: return(KERN_INVALID_ARGUMENT);
1045: }
1046:
1047: if (pset != thread->processor_set) {
1048: act_unlock_thread(thr_act);
1049: return(KERN_FAILURE);
1050: }
1051:
1052: switch (policy) {
1053: case POLICY_RR:
1054: {
1055: policy_rr_base_t rr_base = (policy_rr_base_t) base;
1056: policy_rr_limit_t rr_limit = (policy_rr_limit_t) limit;
1057:
1058: if (base_count != POLICY_RR_BASE_COUNT ||
1059: limit_count != POLICY_RR_LIMIT_COUNT) {
1060: result = KERN_INVALID_ARGUMENT;
1061: break;
1062: }
1063: dat = rr_base->quantum;
1064: bas = rr_base->base_priority;
1065: max = rr_limit->max_priority;
1066: if (invalid_pri(bas) || invalid_pri(max)) {
1067: result = KERN_INVALID_ARGUMENT;
1068: break;
1069: }
1070: break;
1071: }
1072:
1073: case POLICY_FIFO:
1074: {
1075: policy_fifo_base_t fifo_base = (policy_fifo_base_t) base;
1076: policy_fifo_limit_t fifo_limit = (policy_fifo_limit_t) limit;
1077:
1078: if (base_count != POLICY_FIFO_BASE_COUNT ||
1079: limit_count != POLICY_FIFO_LIMIT_COUNT) {
1080: result = KERN_INVALID_ARGUMENT;
1081: break;
1082: }
1083: dat = 0;
1084: bas = fifo_base->base_priority;
1085: max = fifo_limit->max_priority;
1086: if (invalid_pri(bas) || invalid_pri(max)) {
1087: result = KERN_INVALID_ARGUMENT;
1088: break;
1089: }
1090: break;
1091: }
1092:
1093: case POLICY_TIMESHARE:
1094: {
1095: policy_timeshare_base_t ts_base =
1096: (policy_timeshare_base_t) base;
1097: policy_timeshare_limit_t ts_limit =
1098: (policy_timeshare_limit_t) limit;
1099:
1100: if (base_count != POLICY_TIMESHARE_BASE_COUNT ||
1101: limit_count != POLICY_TIMESHARE_LIMIT_COUNT) {
1102: result = KERN_INVALID_ARGUMENT;
1103: break;
1104: }
1105: dat = 0;
1106: bas = ts_base->base_priority;
1107: max = ts_limit->max_priority;
1108: if (invalid_pri(bas) || invalid_pri(max)) {
1109: result = KERN_INVALID_ARGUMENT;
1110: break;
1111: }
1112: break;
1113: }
1114:
1115: default:
1116: result = KERN_INVALID_POLICY;
1117: }
1118:
1119: if (result != KERN_SUCCESS) {
1120: act_unlock_thread(thr_act);
1121: return(result);
1122: }
1123:
1124: /*
1125: * We've already checked the inputs for thread_max_priority,
1126: * so it's safe to ignore the return value.
1127: */
1128: (void) thread_max_priority_locked(thread, pset, max);
1129: result = thread_priority_locked(thread, bas, FALSE);
1130: if (result == KERN_SUCCESS)
1131: result = thread_policy_common(thread, policy, dat, pset);
1132: act_unlock_thread(thr_act);
1133: return(result);
1134: }
1135:
1136:
1137: /*
1138: * thread_policy
1139: *
1140: * Set scheduling policy and parameters, both base and limit, for
1141: * the given thread. Policy must be a policy which is enabled for the
1142: * processor set. Change contained threads if requested.
1143: */
1144: kern_return_t
1145: thread_policy(
1146: thread_act_t thr_act,
1147: policy_t policy,
1148: policy_base_t base,
1149: mach_msg_type_number_t count,
1150: boolean_t set_limit)
1151: {
1152: thread_t thread;
1153: processor_set_t pset;
1154: mk_sp_info_t sched_info;
1155: kern_return_t result = KERN_SUCCESS;
1156: policy_limit_t limit;
1157: policy_rr_limit_data_t rr_limit;
1158: policy_fifo_limit_data_t fifo_limit;
1159: policy_timeshare_limit_data_t ts_limit;
1160: int limcount;
1161:
1162: if (thr_act == THR_ACT_NULL)
1163: return (KERN_INVALID_ARGUMENT);
1164:
1165: thread = act_lock_thread(thr_act);
1166: pset = thread->processor_set;
1167: if (thread == THREAD_NULL || pset == PROCESSOR_SET_NULL) {
1168: act_unlock_thread(thr_act);
1169: return(KERN_INVALID_ARGUMENT);
1170: }
1171:
1172: if (invalid_policy(policy) || (pset->policies & policy) == 0) {
1173: act_unlock_thread(thr_act);
1174: return(KERN_INVALID_POLICY);
1175: }
1176:
1177: /* get pointer to scheduling policy-specific data */
1178: assert(thread->sp_info != SP_INFO_NULL);
1179: sched_info = (mk_sp_info_t)thread->sp_info;
1180:
1181: if (set_limit) {
1182: /*
1183: * Set scheduling limits to base priority.
1184: */
1185: switch (policy) {
1186: case POLICY_RR:
1187: {
1188: policy_rr_base_t rr_base;
1189:
1190: if (count != POLICY_RR_BASE_COUNT) {
1191: result = KERN_INVALID_ARGUMENT;
1192: break;
1193: }
1194: limcount = POLICY_RR_LIMIT_COUNT;
1195: rr_base = (policy_rr_base_t) base;
1196: rr_limit.max_priority = rr_base->base_priority;
1197: limit = (policy_limit_t) &rr_limit;
1198: break;
1199: }
1200:
1201: case POLICY_FIFO:
1202: {
1203: policy_fifo_base_t fifo_base;
1204:
1205: if (count != POLICY_FIFO_BASE_COUNT) {
1206: result = KERN_INVALID_ARGUMENT;
1207: break;
1208: }
1209: limcount = POLICY_FIFO_LIMIT_COUNT;
1210: fifo_base = (policy_fifo_base_t) base;
1211: fifo_limit.max_priority = fifo_base->base_priority;
1212: limit = (policy_limit_t) &fifo_limit;
1213: break;
1214: }
1215:
1216: case POLICY_TIMESHARE:
1217: {
1218: policy_timeshare_base_t ts_base;
1219:
1220: if (count != POLICY_TIMESHARE_BASE_COUNT) {
1221: result = KERN_INVALID_ARGUMENT;
1222: break;
1223: }
1224: limcount = POLICY_TIMESHARE_LIMIT_COUNT;
1225: ts_base = (policy_timeshare_base_t) base;
1226: ts_limit.max_priority = ts_base->base_priority;
1227: limit = (policy_limit_t) &ts_limit;
1228: break;
1229: }
1230:
1231: default:
1232: result = KERN_INVALID_POLICY;
1233: break;
1234: }
1235:
1236: } else {
1237: /*
1238: * Use current scheduling limits. Ensure that the
1239: * new base priority will not exceed current limits.
1240: */
1241: switch (policy) {
1242: case POLICY_RR:
1243: {
1244: policy_rr_base_t rr_base;
1245:
1246: if (count != POLICY_RR_BASE_COUNT) {
1247: result = KERN_INVALID_ARGUMENT;
1248: break;
1249: }
1250: limcount = POLICY_RR_LIMIT_COUNT;
1251: rr_base = (policy_rr_base_t) base;
1252: if (rr_base->base_priority >
1253: sched_info->max_priority) {
1254: result = KERN_POLICY_LIMIT;
1255: break;
1256: }
1257: rr_limit.max_priority = sched_info->max_priority;
1258: limit = (policy_limit_t) &rr_limit;
1259: break;
1260: }
1261:
1262: case POLICY_FIFO:
1263: {
1264: policy_fifo_base_t fifo_base;
1265:
1266: if (count != POLICY_FIFO_BASE_COUNT) {
1267: result = KERN_INVALID_ARGUMENT;
1268: break;
1269: }
1270: limcount = POLICY_FIFO_LIMIT_COUNT;
1271: fifo_base = (policy_fifo_base_t) base;
1272: if (fifo_base->base_priority >
1273: sched_info->max_priority) {
1274: result = KERN_POLICY_LIMIT;
1275: break;
1276: }
1277: fifo_limit.max_priority = sched_info->max_priority;
1278: limit = (policy_limit_t) &fifo_limit;
1279: break;
1280: }
1281:
1282: case POLICY_TIMESHARE:
1283: {
1284: policy_timeshare_base_t ts_base;
1285:
1286: if (count != POLICY_TIMESHARE_BASE_COUNT) {
1287: result = KERN_INVALID_ARGUMENT;
1288: break;
1289: }
1290: limcount = POLICY_TIMESHARE_LIMIT_COUNT;
1291: ts_base = (policy_timeshare_base_t) base;
1292: if (ts_base->base_priority >
1293: sched_info->max_priority) {
1294: result = KERN_POLICY_LIMIT;
1295: break;
1296: }
1297: ts_limit.max_priority = sched_info->max_priority;
1298: limit = (policy_limit_t) &ts_limit;
1299: break;
1300: }
1301:
1302: default:
1303: result = KERN_INVALID_POLICY;
1304: break;
1305: }
1306:
1307: }
1308:
1309: act_unlock_thread(thr_act);
1310:
1311: if (result == KERN_SUCCESS)
1312: result = thread_set_policy(thr_act, pset,
1313: policy, base, count, limit, limcount);
1314:
1315: return(result);
1316: }
1317:
1318:
1319: /*
1320: * Define shifts for simulating (5/8)**n
1321: */
1322:
1323: shift_data_t wait_shift[32] = {
1324: {1,1},{1,3},{1,-3},{2,-7},{3,5},{3,-5},{4,-8},{5,7},
1325: {5,-7},{6,-10},{7,10},{7,-9},{8,-11},{9,12},{9,-11},{10,-13},
1326: {11,14},{11,-13},{12,-15},{13,17},{13,-15},{14,-17},{15,19},{16,18},
1327: {16,-19},{17,22},{18,20},{18,-20},{19,26},{20,22},{20,-22},{21,-27}};
1328:
1329: /*
1330: * do_priority_computation:
1331: *
1332: * Calculate new priority for thread based on its base priority plus
1333: * accumulated usage. PRI_SHIFT and PRI_SHIFT_2 convert from
1334: * usage to priorities. SCHED_SHIFT converts for the scaling
1335: * of the sched_usage field by SCHED_SCALE. This scaling comes
1336: * from the multiplication by sched_load (thread_timer_delta)
1337: * in sched.h. sched_load is calculated as a scaled overload
1338: * factor in compute_mach_factor (mach_factor.c).
1339: */
1340: #ifdef PRI_SHIFT_2
1341: #if PRI_SHIFT_2 > 0
1342: #define do_priority_computation(sp_info, pri) \
1343: MACRO_BEGIN \
1344: (pri) = (sp_info)->priority /* start with base priority */ \
1345: - ((sp_info)->sched_usage >> (PRI_SHIFT + SCHED_SHIFT)) \
1346: - ((sp_info)->sched_usage >> (PRI_SHIFT_2 + SCHED_SHIFT)); \
1347: if ((pri) < lpri) (pri) = lpri; \
1348: (pri) = convert_pri[(pri)]; \
1349: MACRO_END
1350: #else /* PRI_SHIFT_2 */
1351: #define do_priority_computation(sp_info, pri) \
1352: MACRO_BEGIN \
1353: (pri) = (sp_info)->priority /* start with base priority */ \
1354: - ((sp_info)->sched_usage >> (PRI_SHIFT + SCHED_SHIFT)) \
1355: + ((sp_info)->sched_usage >> (SCHED_SHIFT - PRI_SHIFT_2)); \
1356: if ((pri) < lpri) (pri) = lpri; \
1357: (pri) = convert_pri[(pri)]; \
1358: MACRO_END
1359: #endif /* PRI_SHIFT_2 */
1360: #else /* defined(PRI_SHIFT_2) */
1361: #define do_priority_computation(sp_info, pri) \
1362: MACRO_BEGIN \
1363: (pri) = (sp_info)->priority /* start with base priority */ \
1364: - ((sp_info)->sched_usage >> (PRI_SHIFT + SCHED_SHIFT)); \
1365: if ((pri) < lpri) (pri) = lpri; \
1366: (pri) = convert_pri[(pri)]; \
1367: MACRO_END
1368: #endif /* defined(PRI_SHIFT_2) */
1369:
1370: /*
1371: * compute_priority:
1372: *
1373: * Compute the effective priority of the specified thread.
1374: * The effective priority computation is as follows:
1375: *
1376: * Take the base priority for this thread and add
1377: * to it an increment derived from its cpu_usage.
1378: *
1379: * The thread *must* be locked by the caller.
1380: */
1381:
1382: void
1383: compute_priority(
1384: register thread_t thread,
1385: boolean_t resched)
1386: {
1387: mk_sp_info_t sp_info = (mk_sp_info_t)thread->sp_info;
1388: register int pri;
1389:
1390: /* make sure policy-specific data are present */
1391: assert(sp_info != SP_INFO_NULL);
1392:
1393: if (thread->policy == POLICY_TIMESHARE) {
1394: do_priority_computation(sp_info, pri);
1395: if (sp_info->depress_priority < 0)
1396: set_pri(thread, pri, resched);
1397: else
1398: sp_info->depress_priority = pri;
1399: }
1400: else
1401: set_pri(thread, sp_info->priority, resched);
1402: }
1403:
1404: /*
1405: * compute_my_priority:
1406: *
1407: * Version of compute priority for current thread or thread
1408: * being manipulated by scheduler (going on or off a runq).
1409: * Only used for priority updates. Policy or priority changes
1410: * must call compute_priority above. Caller must have thread
1411: * locked and know it is timesharing and not depressed.
1412: */
1413:
1414: void
1415: compute_my_priority(
1416: register thread_t thread)
1417: {
1418: mk_sp_info_t sp_info = (mk_sp_info_t)thread->sp_info;
1419: register int temp_pri;
1420:
1421: /* make sure policy-specific data are present */
1422: assert(thread->sp_info != SP_INFO_NULL);
1423:
1424: do_priority_computation(sp_info,temp_pri);
1425: assert(thread->runq == RUN_QUEUE_NULL);
1426: thread->sched_pri = temp_pri;
1427: }
1428:
1429: struct mk_sp_usage {
1430: natural_t cpu_delta, sched_delta;
1431: natural_t sched_tick, ticks;
1432: natural_t cpu_usage, sched_usage,
1433: aged_cpu, aged_sched;
1434: thread_t thread;
1435: } idled_info, loaded_info;
1436:
1437: /*
1438: * update_priority
1439: *
1440: * Cause the priority computation of a thread that has been
1441: * sleeping or suspended to "catch up" with the system. Thread
1442: * *MUST* be locked by caller. If thread is running, then this
1443: * can only be called by the thread on itself.
1444: */
1445: void
1446: update_priority(
1447: register thread_t thread)
1448: {
1449: mk_sp_info_t sp_info = (mk_sp_info_t)thread->sp_info;
1450: register unsigned int ticks;
1451: register shift_t shiftp;
1452:
1453: /* make sure policy-specific data are present */
1454: assert(sp_info != SP_INFO_NULL);
1455:
1456: ticks = sched_tick - sp_info->sched_stamp;
1457: assert(ticks != 0);
1458:
1459: /*
1460: * If asleep for more than 30 seconds forget all
1461: * cpu_usage, else catch up on missed aging.
1462: * 5/8 ** n is approximated by the two shifts
1463: * in the wait_shift array.
1464: */
1465: sp_info->sched_stamp += ticks;
1466: thread_timer_delta(thread);
1467: if (ticks > 30) {
1468: sp_info->cpu_usage = 0;
1469: sp_info->sched_usage = 0;
1470: }
1471: else {
1472: struct mk_sp_usage *sp_usage;
1473:
1474: sp_info->cpu_usage += thread->cpu_delta;
1475: sp_info->sched_usage += thread->sched_delta;
1476:
1477: if (thread->state & TH_IDLE)
1478: sp_usage = &idled_info;
1479: else
1480: if (thread == loaded_info.thread)
1481: sp_usage = &loaded_info;
1482: else
1483: sp_usage = NULL;
1484:
1485: if (sp_usage != NULL) {
1486: sp_usage->cpu_delta = thread->cpu_delta;
1487: sp_usage->sched_delta = thread->sched_delta;
1488: sp_usage->sched_tick = sp_info->sched_stamp;
1489: sp_usage->ticks = ticks;
1490: sp_usage->cpu_usage = sp_info->cpu_usage;
1491: sp_usage->sched_usage = sp_info->sched_usage;
1492: sp_usage->thread = thread;
1493: }
1494:
1495: shiftp = &wait_shift[ticks];
1496: if (shiftp->shift2 > 0) {
1497: sp_info->cpu_usage =
1498: (sp_info->cpu_usage >> shiftp->shift1) +
1499: (sp_info->cpu_usage >> shiftp->shift2);
1500: sp_info->sched_usage =
1501: (sp_info->sched_usage >> shiftp->shift1) +
1502: (sp_info->sched_usage >> shiftp->shift2);
1503: }
1504: else {
1505: sp_info->cpu_usage =
1506: (sp_info->cpu_usage >> shiftp->shift1) -
1507: (sp_info->cpu_usage >> -(shiftp->shift2));
1508: sp_info->sched_usage =
1509: (sp_info->sched_usage >> shiftp->shift1) -
1510: (sp_info->sched_usage >> -(shiftp->shift2));
1511: }
1512:
1513: if (sp_usage != NULL) {
1514: sp_usage->aged_cpu = sp_info->cpu_usage;
1515: sp_usage->aged_sched = sp_info->sched_usage;
1516: }
1517: }
1518: thread->cpu_delta = 0;
1519: thread->sched_delta = 0;
1520:
1521: /*
1522: * Recompute priority if appropriate.
1523: */
1524: if ( thread->policy == POLICY_TIMESHARE &&
1525: sp_info->depress_priority < 0 ) {
1526: register int new_pri;
1527: run_queue_t runq;
1528:
1529: do_priority_computation(sp_info, new_pri);
1530: runq = rem_runq(thread);
1531: thread->sched_pri = new_pri;
1532: if (runq != RUN_QUEUE_NULL)
1533: thread_setrun(thread, TRUE, TAIL_Q);
1534: }
1535: }
1536:
1537: /*
1538: * `mk_sp_swtch_pri()' attempts to context switch (logic in
1539: * thread_block no-ops the context switch if nothing would happen).
1540: * A boolean is returned that indicates whether there is anything
1541: * else runnable.
1542: *
1543: * This boolean can be used by a thread waiting on a
1544: * lock or condition: If FALSE is returned, the thread is justified
1545: * in becoming a resource hog by continuing to spin because there's
1546: * nothing else useful that the processor could do. If TRUE is
1547: * returned, the thread should make one more check on the
1548: * lock and then be a good citizen and really suspend.
1549: */
1550:
1551: void
1552: _mk_sp_swtch_pri(
1553: sf_object_t policy,
1554: int pri)
1555: {
1556: register thread_t self = current_thread();
1557:
1558: #ifdef lint
1559: pri++;
1560: #endif /* lint */
1561:
1562: counter(c_mk_sp_swtch_pri++);
1563: /*
1564: * XXX need to think about depression duration.
1565: * XXX currently using min quantum.
1566: */
1567: _mk_sp_thread_depress_priority(policy, min_quantum_ms);
1568:
1569: counter(c_swtch_pri_block++);
1570: thread_block((void (*)(void)) 0);
1571:
1572: _mk_sp_thread_depress_abort(policy, self);
1573: }
1574:
1575: /*
1576: * thread_switch:
1577: *
1578: * Context switch. User may supply thread hint.
1579: *
1580: * Fixed priority threads that call this get what they asked for
1581: * even if that violates priority order.
1582: */
1583: kern_return_t
1584: _mk_sp_thread_switch(
1585: sf_object_t policy,
1586: thread_act_t hint_act,
1587: int option,
1588: mach_msg_timeout_t option_time)
1589: {
1590: register thread_t self = current_thread();
1591: register processor_t myprocessor;
1592: mk_sp_info_t sp_info;
1593: int s;
1594:
1595: counter(c_mk_sp_thread_switch++);
1596:
1597: /*
1598: * Process option.
1599: */
1600: switch (option) {
1601:
1602: case SWITCH_OPTION_NONE:
1603: /*
1604: * Nothing to do.
1605: */
1606: break;
1607:
1608: case SWITCH_OPTION_DEPRESS:
1609: /*
1610: * Depress priority for a given time.
1611: */
1612: _mk_sp_thread_depress_priority(policy, option_time);
1613: break;
1614:
1615: case SWITCH_OPTION_WAIT:
1616: assert_wait_timeout(option_time, THREAD_ABORTSAFE);
1617: break;
1618:
1619: default:
1620: return (KERN_INVALID_ARGUMENT);
1621: }
1622:
1623: /*
1624: * Check and use thr_act hint if appropriate. It is not
1625: * appropriate to give a hint that shares the current shuttle.
1626: *
1627: * JMM - Is it really appropriate to give a hint that isn't
1628: * the top activation for a thread?
1629: */
1630: if (hint_act->thread != self) {
1631: register thread_t thread = hint_act->thread;
1632:
1633: /*
1634: * Check if the thread is in the right pset. Then
1635: * pull it off its run queue. If it
1636: * doesn't come, then it's not eligible.
1637: */
1638: if (thread) {
1639: s = splsched();
1640: thread_lock(thread);
1641:
1642: if ( thread->processor_set == self->processor_set &&
1643: rem_runq(thread) != RUN_QUEUE_NULL ) {
1644: /*
1645: * Hah, got it!!
1646: */
1647: if (thread->policy & (POLICY_FIFO|POLICY_RR)) {
1648: myprocessor = current_processor();
1649:
1650: assert(thread->sp_info != SP_INFO_NULL);
1651: sp_info = (mk_sp_info_t)thread->sp_info;
1652:
1653: myprocessor->quantum = sp_info->unconsumed_quantum;
1654: myprocessor->first_quantum = TRUE;
1655: }
1656: thread_unlock(thread);
1657: splx(s);
1658: act_unlock_thread(hint_act);
1659:
1660: counter(c_thread_switch_handoff++);
1661: thread_run((void(*)(void)) 0, thread);
1662:
1663: goto out;
1664: }
1665:
1666: thread_unlock(thread);
1667: splx(s);
1668: }
1669:
1670: act_unlock_thread(hint_act);
1671: }
1672:
1673: /*
1674: * No handoff hint supplied, or hint was wrong. Call thread_block() in
1675: * hopes of running something else. If nothing else is runnable,
1676: * thread_block will detect this. WARNING: thread_switch with no
1677: * option will not do anything useful if the thread calling it is the
1678: * highest priority thread (can easily happen with a collection
1679: * of timesharing threads).
1680: */
1681: mp_disable_preemption();
1682: myprocessor = current_processor();
1683: if ( option != SWITCH_OPTION_NONE ||
1684: myprocessor->processor_set->runq.count > 0 ||
1685: myprocessor->runq.count > 0 ) {
1686: myprocessor->first_quantum = FALSE;
1687: mp_enable_preemption();
1688:
1689: counter(c_thread_switch_block++);
1690: thread_block((void (*)(void)) 0);
1691: }
1692: else
1693: mp_enable_preemption();
1694:
1695: out:
1696: if (option == SWITCH_OPTION_WAIT)
1697: thread_cancel_timer();
1698: else if (option == SWITCH_OPTION_DEPRESS)
1699: _mk_sp_thread_depress_abort(policy, self);
1700:
1701: return (KERN_SUCCESS);
1702: }
1703:
1704: /*
1705: * mk_sp_thread_depress_priority
1706: *
1707: * Depress thread's priority to lowest possible for specified period.
1708: * Intended for use when thread wants a lock but doesn't know which
1709: * other thread is holding it. As with thread_switch, fixed
1710: * priority threads get exactly what they asked for. Users access
1711: * this by the SWITCH_OPTION_DEPRESS option to thread_switch. A Time
1712: * of zero will result in no timeout being scheduled.
1713: */
1714: void
1715: _mk_sp_thread_depress_priority(
1716: sf_object_t policy,
1717: mach_msg_timeout_t interval)
1718: {
1719: register thread_t self = current_thread();
1720: mk_sp_info_t sp_info;
1721: AbsoluteTime deadline;
1722: boolean_t release = FALSE;
1723: spl_t s;
1724:
1725: s = splsched();
1726: thread_lock(self);
1727:
1728: if (self->policy == policy->policy_id) {
1729: /* get pointer to scheduling policy-specific data */
1730: assert(self->sp_info != SP_INFO_NULL);
1731: sp_info = (mk_sp_info_t)self->sp_info;
1732:
1733: /*
1734: * If we haven't already saved the priority to be restored
1735: * (depress_priority), then save it.
1736: */
1737: if (sp_info->depress_priority < 0)
1738: sp_info->depress_priority = sp_info->priority;
1739: else if (thread_call_cancel(&self->depress_timer))
1740: release = TRUE;
1741:
1742: self->sched_pri = sp_info->priority = DEPRESSPRI;
1743:
1744: if (interval != 0) {
1745: clock_interval_to_deadline(
1746: interval, 1000*NSEC_PER_USEC, &deadline);
1747: thread_call_enter_delayed(&self->depress_timer, deadline);
1748: if (!release)
1749: self->ref_count++;
1750: else
1751: release = FALSE;
1752: }
1753: }
1754:
1755: thread_unlock(self);
1756: splx(s);
1757:
1758: if (release)
1759: thread_deallocate(self);
1760: }
1761:
1762: /*
1763: * mk_sp_thread_depress_timeout:
1764: *
1765: * Timeout routine for priority depression.
1766: */
1767: void
1768: _mk_sp_thread_depress_timeout(
1769: sf_object_t policy,
1770: register thread_t thread)
1771: {
1772: mk_sp_info_t sp_info;
1773: spl_t s;
1774:
1775: counter(c_mk_sp_thread_depress_timeout++);
1776:
1777: s = splsched();
1778: thread_lock(thread);
1779: if (thread->policy == policy->policy_id) {
1780: /* get pointer to scheduling policy-specific data */
1781: assert(thread->sp_info != SP_INFO_NULL);
1782: sp_info = (mk_sp_info_t)thread->sp_info;
1783:
1784: /*
1785: * If we lose a race with mk_sp_thread_depress_abort,
1786: * then depress_priority might be -1.
1787: */
1788: if ( sp_info->depress_priority >= 0 &&
1789: !thread_call_is_delayed(&thread->depress_timer, NULL) ) {
1790: sp_info->priority = sp_info->depress_priority;
1791: sp_info->depress_priority = -1;
1792: compute_priority(thread, FALSE);
1793: }
1794: else
1795: if (sp_info->depress_priority == -2) {
1796: /*
1797: * Thread was temporarily undepressed by thread_suspend, to
1798: * be redepressed in special_handler as it blocks. We need to
1799: * prevent special_handler from redepressing it, since depression
1800: * has timed out:
1801: */
1802: sp_info->depress_priority = -1;
1803: }
1804: }
1805: thread_unlock(thread);
1806: splx(s);
1807: }
1808:
1809: /*
1810: * mk_sp_thread_depress_abort:
1811: *
1812: * Prematurely abort priority depression if there is one.
1813: */
1814: kern_return_t
1815: _mk_sp_thread_depress_abort(
1816: sf_object_t policy,
1817: register thread_t thread)
1818: {
1819: mk_sp_info_t sp_info;
1820: kern_return_t result = KERN_SUCCESS;
1821: boolean_t release = FALSE;
1822: spl_t s;
1823:
1824: s = splsched();
1825: thread_lock(thread);
1826:
1827: if (thread->policy == policy->policy_id) {
1828: /* get pointer to scheduling policy-specific data */
1829: assert(thread->sp_info != SP_INFO_NULL);
1830: sp_info = (mk_sp_info_t)thread->sp_info;
1831:
1832: if (sp_info->depress_priority >= 0) {
1833: if (thread_call_cancel(&thread->depress_timer))
1834: release = TRUE;
1835: sp_info->priority = sp_info->depress_priority;
1836: sp_info->depress_priority = -1;
1837: compute_priority(thread, FALSE);
1838: }
1839: else
1840: result = KERN_NOT_DEPRESSED;
1841: }
1842:
1843: thread_unlock(thread);
1844: splx(s);
1845:
1846: if (release)
1847: thread_deallocate(thread);
1848:
1849: return (result);
1850: }
1851:
1852: /*
1853: * mk_sp_thread_runnable:
1854: *
1855: * Return TRUE iff policy believes thread is runnable
1856: */
1857: boolean_t
1858: _mk_sp_thread_runnable(
1859: sf_object_t policy,
1860: sched_thread_t thread)
1861: {
1862: mk_sp_info_t sp_info;
1863:
1864: counter(c_mk_sp_thread_runnable++);
1865:
1866: /* get pointer to scheduling policy-specific data */
1867: assert(thread->sp_info != SP_INFO_NULL);
1868: sp_info = (mk_sp_info_t)thread->sp_info;
1869:
1870: counter(sp_info->c_mk_sp_thread_runnable++);
1871:
1872: return (sp_info->th_state == MK_SP_RUNNABLE);
1873: }
1874:
1875: sf_return_t
1876: _mk_sp_alarm_expired(
1877: sf_object_t policy,
1878: long alarm_seqno,
1879: kern_return_t result,
1880: int alarm_type,
1881: mach_timespec_t wakeup_time,
1882: void *alarm_data)
1883: {
1884: counter(c_mk_sp_alarm_expired++);
1885:
1886: /* this should NEVER happen */
1887: assert(0);
1888:
1889: return (SF_FAILURE);
1890: }
1891:
1892:
1893: void
1894: _mk_sp_thread_dump(
1895: sched_thread_t thread) /* thread */
1896: {
1897: mk_sp_info_t sp_info;
1898: int count;
1899:
1900: /* get pointer to scheduling policy-specific data */
1901: assert(thread->sp_info != SP_INFO_NULL);
1902: sp_info = (mk_sp_info_t)thread->sp_info;
1903:
1904: /* dump the data in a pretty format */
1905: printf("\nthread shuttle(0x%x):\n", thread);
1906:
1907: printf("\tpolicy: ");
1908: switch(thread->policy) {
1909: case POLICY_TIMESHARE:
1910: printf("POLICY_TIMESHARE\n");
1911: break;
1912:
1913: case POLICY_RR:
1914: printf("POLICY_RR\n");
1915: break;
1916:
1917: case POLICY_FIFO:
1918: printf("POLICY_FIFO\n");
1919: break;
1920:
1921: default:
1922: printf("NOT an MK Standard Policy\n");
1923: return;
1924: }
1925:
1926: printf("\tth_state: ");
1927: if (sp_info->th_state == 0) {
1928: printf("NULL");
1929: }
1930: else {
1931: count = 0;
1932: if (sp_info->th_state & MK_SP_ATTACHED) {
1933: printf("MK_SP_ATTACHED ");
1934: count++;
1935: }
1936: if (sp_info->th_state & MK_SP_RUNNABLE) {
1937: if (count > 0) printf(" | ");
1938: printf("MK_SP_RUNNABLE ");
1939: count++;
1940: }
1941: if (sp_info->th_state & MK_SP_BLOCKED) {
1942: if (count > 0) printf(" | ");
1943: printf("MK_SP_BLOCKED ");
1944: count++;
1945: }
1946: }
1947: printf("\n");
1948:
1949: printf("\tpriority: %d\n", sp_info->priority);
1950: printf("\tmax_priority: %d\n", sp_info->max_priority);
1951: printf("\tsched_data: %d\n", sp_info->sched_data);
1952: printf("\tdepress_priority: %d\n", sp_info->depress_priority);
1953: printf("\tcpu_usage: %d\n", sp_info->cpu_usage);
1954: printf("\tsched_usage: %d\n", sp_info->sched_usage);
1955: printf("\tsched_stamp: %d\n", sp_info->sched_stamp);
1956: printf("\tunconsumed_quantum: %d\n", sp_info->unconsumed_quantum);
1957: printf("\tsched_pri: %d\n", thread->sched_pri);
1958:
1959: #ifdef MACH_ASSERT
1960: printf("\tc_mk_sp_thread_attach: %d\n",
1961: sp_info->c_mk_sp_thread_attach);
1962: printf("\tc_mk_sp_thread_detach: %d\n",
1963: sp_info->c_mk_sp_thread_detach);
1964: printf("\tc_mk_sp_thread_begin: %d\n",
1965: sp_info->c_mk_sp_thread_begin);
1966: printf("\tc_mk_sp_thread_done: %d\n",
1967: sp_info->c_mk_sp_thread_done);
1968: printf("\tc_mk_sp_thread_dispatch: %d\n",
1969: sp_info->c_mk_sp_thread_dispatch);
1970: printf("\tc_mk_sp_thread_unblock: %d\n",
1971: sp_info->c_mk_sp_thread_unblock);
1972: printf("\tc_mk_sp_thread_set: %d\n",
1973: sp_info->c_mk_sp_thread_set);
1974: printf("\tc_mk_sp_thread_get: %d\n",
1975: sp_info->c_mk_sp_thread_get);
1976: #endif /* MACH_ASSERT */
1977:
1978: return;
1979: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.