2 * Copyright (c) 2000-2010 Apple Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
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.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
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.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
32 * Mach Operating System
33 * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
34 * All Rights Reserved.
36 * Permission to use, copy, modify and distribute this software and its
37 * documentation is hereby granted, provided that both the copyright
38 * notice and this permission notice appear in all copies of the
39 * software, derivative works or modified versions, and any portions
40 * thereof, and that both notices appear in supporting documentation.
42 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
43 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
44 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
46 * Carnegie Mellon requests users of this software to return to
48 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
49 * School of Computer Science
50 * Carnegie Mellon University
51 * Pittsburgh PA 15213-3890
53 * any improvements or extensions that they make and grant Carnegie Mellon
54 * the rights to redistribute these changes.
60 * Author: Avadis Tevanian, Jr.
63 * Priority related scheduler bits.
66 #include <mach/boolean.h>
67 #include <mach/kern_return.h>
68 #include <mach/machine.h>
69 #include <kern/host.h>
70 #include <kern/mach_param.h>
71 #include <kern/sched.h>
72 #include <sys/kdebug.h>
74 #include <kern/thread.h>
75 #include <kern/processor.h>
76 #include <kern/ledger.h>
77 #include <machine/machparam.h>
78 #include <kern/machine.h>
80 #ifdef CONFIG_MACH_APPROXIMATE_TIME
81 #include <machine/commpage.h> /* for commpage_update_mach_approximate_time */
85 #include <kern/monotonic.h>
86 #endif /* MONOTONIC */
88 static void sched_update_thread_bucket(thread_t thread
);
91 * thread_quantum_expire:
93 * Recalculate the quantum and priority for a thread.
99 thread_quantum_expire(
100 timer_call_param_t p0
,
101 timer_call_param_t p1
)
103 processor_t processor
= p0
;
104 thread_t thread
= p1
;
108 uint64_t ignore1
, ignore2
;
110 assert(processor
== current_processor());
111 assert(thread
== current_thread());
113 KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED
, MACH_SCHED_QUANTUM_EXPIRED
) | DBG_FUNC_START
, 0, 0, 0, 0, 0);
115 SCHED_STATS_QUANTUM_TIMER_EXPIRATION(processor
);
118 * We bill CPU time to both the individual thread and its task.
120 * Because this balance adjustment could potentially attempt to wake this very
121 * thread, we must credit the ledger before taking the thread lock. The ledger
122 * pointers are only manipulated by the thread itself at the ast boundary.
124 * TODO: This fails to account for the time between when the timer was armed and when it fired.
125 * It should be based on the system_timer and running a thread_timer_event operation here.
127 ledger_credit(thread
->t_ledger
, task_ledgers
.cpu_time
, thread
->quantum_remaining
);
128 ledger_credit(thread
->t_threadledger
, thread_ledgers
.cpu_time
, thread
->quantum_remaining
);
129 if (thread
->t_bankledger
) {
130 ledger_credit(thread
->t_bankledger
, bank_ledgers
.cpu_time
,
131 (thread
->quantum_remaining
- thread
->t_deduct_bank_ledger_time
));
133 thread
->t_deduct_bank_ledger_time
= 0;
135 ctime
= mach_absolute_time();
137 #ifdef CONFIG_MACH_APPROXIMATE_TIME
138 commpage_update_mach_approximate_time(ctime
);
142 mt_sched_update(thread
);
143 #endif /* MONOTONIC */
148 * We've run up until our quantum expiration, and will (potentially)
149 * continue without re-entering the scheduler, so update this now.
151 processor
->last_dispatch
= ctime
;
152 thread
->last_run_time
= ctime
;
155 * Check for fail-safe trip.
157 if ((thread
->sched_mode
== TH_MODE_REALTIME
|| thread
->sched_mode
== TH_MODE_FIXED
) &&
158 !(thread
->sched_flags
& TH_SFLAG_PROMOTED_MASK
) &&
159 !(thread
->options
& TH_OPT_SYSTEM_CRITICAL
)) {
160 uint64_t new_computation
;
162 new_computation
= ctime
- thread
->computation_epoch
;
163 new_computation
+= thread
->computation_metered
;
164 if (new_computation
> max_unsafe_computation
) {
165 KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED
, MACH_FAILSAFE
)|DBG_FUNC_NONE
,
166 (uintptr_t)thread
->sched_pri
, (uintptr_t)thread
->sched_mode
, 0, 0, 0);
168 thread
->safe_release
= ctime
+ sched_safe_duration
;
170 sched_thread_mode_demote(thread
, TH_SFLAG_FAILSAFE
);
175 * Recompute scheduled priority if appropriate.
177 if (SCHED(can_update_priority
)(thread
))
178 SCHED(update_priority
)(thread
);
180 SCHED(lightweight_update_priority
)(thread
);
182 if (thread
->sched_mode
!= TH_MODE_REALTIME
)
183 SCHED(quantum_expire
)(thread
);
185 processor_state_update_from_thread(processor
, thread
);
188 * This quantum is up, give this thread another.
190 processor
->first_timeslice
= FALSE
;
192 thread_quantum_init(thread
);
194 /* Reload precise timing global policy to thread-local policy */
195 thread
->precise_user_kernel_time
= use_precise_user_kernel_time(thread
);
198 * Since non-precise user/kernel time doesn't update the state/thread timer
199 * during privilege transitions, synthesize an event now.
201 if (!thread
->precise_user_kernel_time
) {
202 timer_switch(PROCESSOR_DATA(processor
, current_state
),
204 PROCESSOR_DATA(processor
, current_state
));
205 timer_switch(PROCESSOR_DATA(processor
, thread_timer
),
207 PROCESSOR_DATA(processor
, thread_timer
));
211 processor
->quantum_end
= ctime
+ thread
->quantum_remaining
;
214 * Context switch check
216 * non-urgent flags don't affect kernel threads, so upgrade to urgent
217 * to ensure that rebalancing and non-recommendation kick in quickly.
220 ast_t check_reason
= AST_QUANTUM
;
221 if (thread
->task
== kernel_task
)
222 check_reason
|= AST_URGENT
;
224 if ((preempt
= csw_check(processor
, check_reason
)) != AST_NONE
)
228 * AST_KEVENT does not send an IPI when setting the AST,
229 * to avoid waiting for the next context switch to propagate the AST,
230 * the AST is propagated here at quantum expiration.
232 ast_propagate(thread
);
234 thread_unlock(thread
);
236 timer_call_quantum_timer_enter(&processor
->quantum_timer
, thread
,
237 processor
->quantum_end
, ctime
);
239 /* Tell platform layer that we are still running this thread */
240 urgency
= thread_get_urgency(thread
, &ignore1
, &ignore2
);
241 machine_thread_going_on_core(thread
, urgency
, 0, 0, ctime
);
242 machine_switch_perfcontrol_state_update(QUANTUM_EXPIRY
, ctime
,
245 #if defined(CONFIG_SCHED_TIMESHARE_CORE)
246 sched_timeshare_consider_maintenance(ctime
);
247 #endif /* CONFIG_SCHED_TIMESHARE_CORE */
249 #if __arm__ || __arm64__
250 if (thread
->sched_mode
== TH_MODE_REALTIME
)
251 sched_consider_recommended_cores(ctime
, thread
);
252 #endif /* __arm__ || __arm64__ */
254 KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED
, MACH_SCHED_QUANTUM_EXPIRED
) | DBG_FUNC_END
, preempt
, 0, 0, 0, 0);
258 * sched_set_thread_base_priority:
260 * Set the base priority of the thread
261 * and reset its scheduled priority.
263 * This is the only path to change base_pri.
265 * Called with the thread locked.
268 sched_set_thread_base_priority(thread_t thread
, int priority
)
270 assert(priority
>= MINPRI
);
273 if (thread
->sched_mode
== TH_MODE_REALTIME
)
274 assert(priority
<= BASEPRI_RTQUEUES
);
276 assert(priority
< BASEPRI_RTQUEUES
);
278 int old_base_pri
= thread
->base_pri
;
279 thread
->base_pri
= priority
;
281 if ((thread
->state
& TH_RUN
) == TH_RUN
) {
282 assert(thread
->last_made_runnable_time
!= THREAD_NOT_RUNNABLE
);
283 ctime
= mach_approximate_time();
284 thread
->last_basepri_change_time
= ctime
;
286 assert(thread
->last_basepri_change_time
== THREAD_NOT_RUNNABLE
);
287 assert(thread
->last_made_runnable_time
== THREAD_NOT_RUNNABLE
);
291 * Currently the perfcontrol_attr depends on the base pri of the
292 * thread. Therefore, we use this function as the hook for the
293 * perfcontrol callout.
295 if (thread
== current_thread() && old_base_pri
!= priority
) {
297 ctime
= mach_approximate_time();
299 machine_switch_perfcontrol_state_update(PERFCONTROL_ATTR_UPDATE
,
300 ctime
, PERFCONTROL_CALLOUT_WAKE_UNSAFE
, thread
);
302 sched_update_thread_bucket(thread
);
304 thread_recompute_sched_pri(thread
, FALSE
);
308 * thread_recompute_sched_pri:
310 * Reset the scheduled priority of the thread
311 * according to its base priority if the
312 * thread has not been promoted or depressed.
314 * This is the standard way to push base_pri changes into sched_pri,
315 * or to recalculate the appropriate sched_pri after clearing
316 * a promotion or depression.
318 * Called at splsched with the thread locked.
321 thread_recompute_sched_pri(
323 boolean_t override_depress
)
327 if (thread
->sched_mode
== TH_MODE_TIMESHARE
)
328 priority
= SCHED(compute_timeshare_priority
)(thread
);
330 priority
= thread
->base_pri
;
332 if ((!(thread
->sched_flags
& TH_SFLAG_PROMOTED_MASK
) || (priority
> thread
->sched_pri
)) &&
333 (!(thread
->sched_flags
& TH_SFLAG_DEPRESSED_MASK
) || override_depress
)) {
334 set_sched_pri(thread
, priority
);
339 sched_default_quantum_expire(thread_t thread __unused
)
342 * No special behavior when a timeshare, fixed, or realtime thread
343 * uses up its entire quantum
347 #if defined(CONFIG_SCHED_TIMESHARE_CORE)
350 * lightweight_update_priority:
352 * Update the scheduled priority for
353 * a timesharing thread.
355 * Only for use on the current thread.
357 * Called with the thread locked.
360 lightweight_update_priority(thread_t thread
)
362 assert(thread
->runq
== PROCESSOR_NULL
);
363 assert(thread
== current_thread());
365 if (thread
->sched_mode
== TH_MODE_TIMESHARE
) {
369 thread_timer_delta(thread
, delta
);
372 * Accumulate timesharing usage only
373 * during contention for processor
376 if (thread
->pri_shift
< INT8_MAX
)
377 thread
->sched_usage
+= delta
;
379 thread
->cpu_delta
+= delta
;
381 priority
= sched_compute_timeshare_priority(thread
);
384 * Adjust the scheduled priority like thread_recompute_sched_pri,
385 * except with the benefit of knowing the thread is on this core.
387 if ((!(thread
->sched_flags
& TH_SFLAG_PROMOTED_MASK
) || (priority
> thread
->sched_pri
)) &&
388 (!(thread
->sched_flags
& TH_SFLAG_DEPRESSED_MASK
)) &&
389 priority
!= thread
->sched_pri
) {
391 thread
->sched_pri
= priority
;
393 KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED
, MACH_SCHED_CHANGE_PRIORITY
),
394 (uintptr_t)thread_tid(thread
),
397 0, /* eventually, 'reason' */
404 * Define shifts for simulating (5/8) ** n
406 * Shift structures for holding update shifts. Actual computation
407 * is usage = (usage >> shift1) +/- (usage >> abs(shift2)) where the
408 * +/- is determined by the sign of shift 2.
415 #define SCHED_DECAY_TICKS 32
416 static struct shift_data sched_decay_shifts
[SCHED_DECAY_TICKS
] = {
417 {1,1},{1,3},{1,-3},{2,-7},{3,5},{3,-5},{4,-8},{5,7},
418 {5,-7},{6,-10},{7,10},{7,-9},{8,-11},{9,12},{9,-11},{10,-13},
419 {11,14},{11,-13},{12,-15},{13,17},{13,-15},{14,-17},{15,19},{16,18},
420 {16,-19},{17,22},{18,20},{18,-20},{19,26},{20,22},{20,-22},{21,-27}
424 * sched_compute_timeshare_priority:
426 * Calculate the timesharing priority based upon usage and load.
428 extern int sched_pri_decay_band_limit
;
430 #ifdef CONFIG_EMBEDDED
433 sched_compute_timeshare_priority(thread_t thread
)
435 int decay_amount
= (thread
->sched_usage
>> thread
->pri_shift
);
436 int decay_limit
= sched_pri_decay_band_limit
;
438 if (thread
->base_pri
> BASEPRI_FOREGROUND
) {
439 decay_limit
+= (thread
->base_pri
- BASEPRI_FOREGROUND
);
442 if (decay_amount
> decay_limit
) {
443 decay_amount
= decay_limit
;
446 /* start with base priority */
447 int priority
= thread
->base_pri
- decay_amount
;
449 if (priority
< MAXPRI_THROTTLE
) {
450 if (thread
->task
->max_priority
> MAXPRI_THROTTLE
) {
451 priority
= MAXPRI_THROTTLE
;
452 } else if (priority
< MINPRI_USER
) {
453 priority
= MINPRI_USER
;
455 } else if (priority
> MAXPRI_KERNEL
) {
456 priority
= MAXPRI_KERNEL
;
462 #else /* CONFIG_EMBEDDED */
465 sched_compute_timeshare_priority(thread_t thread
)
467 /* start with base priority */
468 int priority
= thread
->base_pri
- (thread
->sched_usage
>> thread
->pri_shift
);
470 if (priority
< MINPRI_USER
)
471 priority
= MINPRI_USER
;
472 else if (priority
> MAXPRI_KERNEL
)
473 priority
= MAXPRI_KERNEL
;
478 #endif /* CONFIG_EMBEDDED */
481 * can_update_priority
483 * Make sure we don't do re-dispatches more frequently than a scheduler tick.
485 * Called with the thread locked.
491 if (sched_tick
== thread
->sched_stamp
)
500 * Perform housekeeping operations driven by scheduler tick.
502 * Called with the thread locked.
508 uint32_t ticks
, delta
;
510 ticks
= sched_tick
- thread
->sched_stamp
;
513 thread
->sched_stamp
+= ticks
;
515 thread
->pri_shift
= sched_pri_shifts
[thread
->th_sched_bucket
];
517 /* If requested, accelerate aging of sched_usage */
518 if (sched_decay_usage_age_factor
> 1)
519 ticks
*= sched_decay_usage_age_factor
;
522 * Gather cpu usage data.
524 thread_timer_delta(thread
, delta
);
525 if (ticks
< SCHED_DECAY_TICKS
) {
527 * Accumulate timesharing usage only
528 * during contention for processor
531 if (thread
->pri_shift
< INT8_MAX
)
532 thread
->sched_usage
+= delta
;
534 thread
->cpu_usage
+= delta
+ thread
->cpu_delta
;
535 thread
->cpu_delta
= 0;
537 struct shift_data
*shiftp
= &sched_decay_shifts
[ticks
];
539 if (shiftp
->shift2
> 0) {
540 thread
->cpu_usage
= (thread
->cpu_usage
>> shiftp
->shift1
) +
541 (thread
->cpu_usage
>> shiftp
->shift2
);
542 thread
->sched_usage
= (thread
->sched_usage
>> shiftp
->shift1
) +
543 (thread
->sched_usage
>> shiftp
->shift2
);
545 thread
->cpu_usage
= (thread
->cpu_usage
>> shiftp
->shift1
) -
546 (thread
->cpu_usage
>> -(shiftp
->shift2
));
547 thread
->sched_usage
= (thread
->sched_usage
>> shiftp
->shift1
) -
548 (thread
->sched_usage
>> -(shiftp
->shift2
));
551 thread
->cpu_usage
= thread
->cpu_delta
= 0;
552 thread
->sched_usage
= 0;
556 * Check for fail-safe release.
558 if ((thread
->sched_flags
& TH_SFLAG_FAILSAFE
) &&
559 mach_absolute_time() >= thread
->safe_release
) {
560 sched_thread_mode_undemote(thread
, TH_SFLAG_FAILSAFE
);
564 * Recompute scheduled priority if appropriate.
566 if (thread
->sched_mode
== TH_MODE_TIMESHARE
) {
567 int priority
= sched_compute_timeshare_priority(thread
);
570 * Adjust the scheduled priority like thread_recompute_sched_pri,
571 * except without setting an AST.
573 if ((!(thread
->sched_flags
& TH_SFLAG_PROMOTED_MASK
) || (priority
> thread
->sched_pri
)) &&
574 (!(thread
->sched_flags
& TH_SFLAG_DEPRESSED_MASK
)) &&
575 priority
!= thread
->sched_pri
) {
577 boolean_t removed
= thread_run_queue_remove(thread
);
579 thread
->sched_pri
= priority
;
581 KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED
, MACH_SCHED_CHANGE_PRIORITY
),
582 (uintptr_t)thread_tid(thread
),
585 0, /* eventually, 'reason' */
589 thread_run_queue_reinsert(thread
, SCHED_TAILQ
);
596 #endif /* CONFIG_SCHED_TIMESHARE_CORE */
600 * TH_BUCKET_RUN is a count of *all* runnable non-idle threads.
601 * Each other bucket is a count of the runnable non-idle threads
602 * with that property.
604 volatile uint32_t sched_run_buckets
[TH_BUCKET_MAX
];
607 sched_incr_bucket(sched_bucket_t bucket
)
609 assert(bucket
>= TH_BUCKET_FIXPRI
&&
610 bucket
<= TH_BUCKET_SHARE_BG
);
612 hw_atomic_add(&sched_run_buckets
[bucket
], 1);
616 sched_decr_bucket(sched_bucket_t bucket
)
618 assert(bucket
>= TH_BUCKET_FIXPRI
&&
619 bucket
<= TH_BUCKET_SHARE_BG
);
621 assert(sched_run_buckets
[bucket
] > 0);
623 hw_atomic_sub(&sched_run_buckets
[bucket
], 1);
626 /* TH_RUN & !TH_IDLE controls whether a thread has a run count */
629 sched_run_incr(thread_t thread
)
631 assert((thread
->state
& (TH_RUN
|TH_IDLE
)) == TH_RUN
);
633 uint32_t new_count
= hw_atomic_add(&sched_run_buckets
[TH_BUCKET_RUN
], 1);
635 sched_incr_bucket(thread
->th_sched_bucket
);
641 sched_run_decr(thread_t thread
)
643 assert((thread
->state
& (TH_RUN
|TH_IDLE
)) != TH_RUN
);
645 sched_decr_bucket(thread
->th_sched_bucket
);
647 uint32_t new_count
= hw_atomic_sub(&sched_run_buckets
[TH_BUCKET_RUN
], 1);
653 sched_update_thread_bucket(thread_t thread
)
655 sched_bucket_t old_bucket
= thread
->th_sched_bucket
;
656 sched_bucket_t new_bucket
= TH_BUCKET_RUN
;
658 switch (thread
->sched_mode
) {
660 case TH_MODE_REALTIME
:
661 new_bucket
= TH_BUCKET_FIXPRI
;
664 case TH_MODE_TIMESHARE
:
665 if (thread
->base_pri
> BASEPRI_UTILITY
)
666 new_bucket
= TH_BUCKET_SHARE_FG
;
667 else if (thread
->base_pri
> MAXPRI_THROTTLE
)
668 new_bucket
= TH_BUCKET_SHARE_UT
;
670 new_bucket
= TH_BUCKET_SHARE_BG
;
674 panic("unexpected mode: %d", thread
->sched_mode
);
678 if (old_bucket
!= new_bucket
) {
679 thread
->th_sched_bucket
= new_bucket
;
680 thread
->pri_shift
= sched_pri_shifts
[new_bucket
];
682 if ((thread
->state
& (TH_RUN
|TH_IDLE
)) == TH_RUN
) {
683 sched_decr_bucket(old_bucket
);
684 sched_incr_bucket(new_bucket
);
690 * Set the thread's true scheduling mode
691 * Called with thread mutex and thread locked
692 * The thread has already been removed from the runqueue.
694 * (saved_mode is handled before this point)
697 sched_set_thread_mode(thread_t thread
, sched_mode_t new_mode
)
699 assert(thread
->runq
== PROCESSOR_NULL
);
703 case TH_MODE_REALTIME
:
704 case TH_MODE_TIMESHARE
:
708 panic("unexpected mode: %d", new_mode
);
712 thread
->sched_mode
= new_mode
;
714 sched_update_thread_bucket(thread
);
718 * Demote the true scheduler mode to timeshare (called with the thread locked)
721 sched_thread_mode_demote(thread_t thread
, uint32_t reason
)
723 assert(reason
& TH_SFLAG_DEMOTED_MASK
);
724 assert((thread
->sched_flags
& reason
) != reason
);
726 if (thread
->policy_reset
)
729 if (thread
->sched_flags
& TH_SFLAG_DEMOTED_MASK
) {
730 /* Another demotion reason is already active */
731 thread
->sched_flags
|= reason
;
735 assert(thread
->saved_mode
== TH_MODE_NONE
);
737 boolean_t removed
= thread_run_queue_remove(thread
);
739 thread
->sched_flags
|= reason
;
741 thread
->saved_mode
= thread
->sched_mode
;
743 sched_set_thread_mode(thread
, TH_MODE_TIMESHARE
);
745 thread_recompute_priority(thread
);
748 thread_run_queue_reinsert(thread
, SCHED_TAILQ
);
752 * Un-demote the true scheduler mode back to the saved mode (called with the thread locked)
755 sched_thread_mode_undemote(thread_t thread
, uint32_t reason
)
757 assert(reason
& TH_SFLAG_DEMOTED_MASK
);
758 assert((thread
->sched_flags
& reason
) == reason
);
759 assert(thread
->saved_mode
!= TH_MODE_NONE
);
760 assert(thread
->sched_mode
== TH_MODE_TIMESHARE
);
761 assert(thread
->policy_reset
== 0);
763 thread
->sched_flags
&= ~reason
;
765 if (thread
->sched_flags
& TH_SFLAG_DEMOTED_MASK
) {
766 /* Another demotion reason is still active */
770 boolean_t removed
= thread_run_queue_remove(thread
);
772 sched_set_thread_mode(thread
, thread
->saved_mode
);
774 thread
->saved_mode
= TH_MODE_NONE
;
776 thread_recompute_priority(thread
);
779 thread_run_queue_reinsert(thread
, SCHED_TAILQ
);