													TOPPERS Confidential
		TOPPERSץ ǥå
		ߥ塼ƥåǽ˴ؤ븡Ƥ

		: Ĺϡ̾Ųء
		ǽ: 2009ǯ1231

ΰդ

ΥɥȤϡTOPPERS奫ͥˤߥ塼ƥåǽλ
ͤȼˤĤƸƤΤǤ롥TOPPERS/ASPͥΥߥ塼ƥå
ǽĥ˴ؤ߷ץޤǤ롥

Ȥʤ

TOPPERS奫ͥˤƤϡǤϡITRON4.0ͤΥߥ塼ƥ
ǽͥٷѾץȥϥݡȤʤޤ̩ͥ
§Τߤ򥵥ݡȤάͥ浬§ϥݡȤʤΤȤ
롥

ITRON4.0ͤHRPͥͤ

ITRON4.0ͤHRPͥˤߥ塼ƥåλͤФơ
꤬ŦƤ롥ʤ򼨤ϡ褽ŦΤ
Ǥꡤν򼨤ΤǤϤʤ

λŦʦITRON4.0͡
----------------------------------------
ߥ塼ƥåǽѤƤΡchg_priưˤĤ

ITRONͽ"chg_pri"ˡʲεܤ뤫Ȼפޤ

֡Υӥ¹Ԥ̡оݥθͥ
١ͥ٤˰פƤˤϡνԤ

оݤȤʤ륿ͥپ¤⤷ϷѾץȥΥߥ塼ƥå
åƤ롢뤤ϲԤ֤ξǤ⡢嵭
ʤСꤵ줿ͥ٤Ǻ̤ͥѹɬפ
ΤǤ礦

λͤŬѤΤ硢ä˥ߥ塼ƥååƤ
ФơƱͥ٤Ǥ̤ͥ򲼤뤳ȼΤ
ߥ塼ƥåλѰտޤȿƤ褦˻פΤǤǡ
礦
----------------------------------------

λŦHRPͥ
----------------------------------------
ͥ٥Aǥѥåػߤ塤ͥ٥Bǥ֤
ʤʥǥѥåػߤʤΤǥڴϵʤˡθ˥
Aͥپ¤BƱߥ塼ƥåФploc_mtxȯԤơ
BƱͥ٤ޤǾ夬äͤ롥HRPͥǤϡA
B̤ͥ㤯ʤ롥θ塤AǥѥåĤ
ȡBڤ괹뤳Ȥˤʤꡤ¾оݤΥΤ¾
櫓ǤϤʤʤ롥
----------------------------------------

ʦITRON4.0͡
----------------------------------------
Ʊͥ٤ΥAȥB⤤ͥ٤äͥ
¥ߥ塼ƥåͤ롥Aߥ塼ƥåå
Bߥ塼ƥåԤäƤǡAߥ塼ƥå
ˡBߥ塼ƥååͥ٤夬ꡤ
Bڤ괹äƤޤAϢǼ¹Ԥʤ

ϡBͥ٤A㤤ˤⵯ롥

 塼Ūˤϡͥپ¥ߥ塼ƥåФԤ
ˤʤ뤳ȤϤʤΤǡϹθƤʤ

 AϢǼ¹ԤʤΤϡ礭ǤϤʤȤո⡥

̤ͥΰˤäƤϲǽʥ

(a) ͥ٤ΥAͥ٤ΥBAͥ٤Ʊͥ
٤äͥپ¥ߥ塼ƥåͤ롥Aߥ塼ƥ
åBߥ塼ƥåԤäƤǡA
ߥ塼ƥååˡBߥ塼ƥåå
ͥ٤夬롥̤ͥΰˤäƤϡBڤ괹äƤޤ

(b) Ʊͥ٤ΥAȥBƱͥ٤äͥ
¥ߥ塼ƥåͤ롥Aߥ塼ƥåå
Bߥ塼ƥåԤäƤǡAߥ塼ƥå
ˡ̤ͥΰˤäƤϡBڤ괹äƤޤ
----------------------------------------

ݣʦITRON4.0ͤޥץåĥ
----------------------------------------
ޥץåˤơץå1˥Aץå2ͥ٤
B1,B2,B3ͥ٤ι⤤C⤤ͥ٤
ͥپ¥ߥ塼ƥåͤ롥Aߥ塼ƥå
åB1,B2,B3ߥ塼ƥåԤäƤꡤץå2Ǥϥ
C¹ԤƤǡAߥ塼ƥåå
ˡB1ߥ塼ƥååͥ٤夬ꡤB1
괹äƤޤˡB2,B3⤤ͥ٤Ǽ¹Ԥ졤C
B1,B2,B3Υƥ륻ԤƤޤ
----------------------------------------

HRPͥ
----------------------------------------
HRPͥǤϡͥٷѾȼäƥθͥ٤Ѳˡ
ƱͥǤ̤ͥˤʦITRON4.0ͤǤϼ¸ȤƤ
ˡλͤˤϡΤ褦꤬롥

Ʊͥ٤ΥAȥB⤤ͥ٤äͥ
¥ߥ塼ƥåͤ롥A¹Ծ֡B¹
ǽ֤ǤȤ롥Aߥ塼ƥååθå
ȡA̤ͥƱͥǺȤʤꡤBڤ괹
Ƥޤ

ο񤤤ϡ٥μ¹ԤϤͥٵžˤʤȤͥ
پ¥ץȥȿ롥
----------------------------------------

ιͻ

򤹤뤿ˤϡͥپ¥ߥ塼ƥåå
ˡåԤ֤Υˤ˥ߥ塼ƥååƤϤʤ
Ȥˤʤ롥ʤåԤ֤ΥԤΤߤԤ
Υ˥塼뤵줿˥ߥ塼ƥååͥ٤
ѹԤФ褤POSIXΥߥ塼ƥåϡˤǼ٤
ΤȻפ롥

Τ褦˻ѹ硤rel_waiΰ䡤ॢȤΰ
ʤ롥ॢȤϡߥ塼ƥåԤˤĤʤԤ֤Ȥʤ
Ƥ֤ǤʤԤƼ˥塼뤵ΤԤäƤ
֤ޤư٤Ǥ롥ޤΥߥ󥰤rel_waiȯԤ줿
ΰ⡤ɤˤ뤫ƤȤɬפǤʤɤλͤ
ΩȹͤˡޤǤITRONͤƱ֥̿Ȥ
ʤä񤤤Ǥꡤ˱ƶڤֲǽ롥

Τ褦絬Ϥʻѹ򤱤뤿ˤϡ⤽⡤ͥپ¥ߥ塼
ƥåԤ֤ˤʤ褦ʻȤ侩Τ
Ϥʤξˤ̤ˤϿʤȤ»Ȥʳ
ʤȻפ롥ͥپ¥ߥ塼ƥåԤ֤ˤ
ʤɤͳǼ¹Ը򼺤ʤСͥپ¥ߥ塼ƥåФ
֤ˤʤⵯʤʥޥץåξˡΤᡤ
»ߤСξϵ餺ǤϤʤȤˤ
롥

桼ФƤϡͥپ¥ߥ塼ƥååˤploc_mtx
ȤȤ侩Сμ¤˲򤹤뤳ȤǤ롥

ޥץåξˤϡͥپ¥ߥ塼ƥå
¹Ը򼺤ʤƤ⡤ͥپ¥ߥ塼ƥåФԤ֤ˤʤ
롥ΤᡤݣΤ褦꤬򤱤ʤ

ΤȤޥץåξˤн褹ˤϡPOSIXμ
Ѥ뤷ʤΤȻפ뤬POSIXμˤˤϡߥ塼ƥå
ˤ٤ƤΥưФƤޤ˥Хإåɤ礭Ȥ
̤꤬롥

ɡޥץåξɤˡʤΤǤ롥

ʾꡤä˥ޥץåξˡϻĤäƤ뤬
ϡλͤǤʤȤ롥

ιͻ

ˤĤƤϡꤵ줿ˡȯ뤿ᡤ»Ȥ뤳
ȤϤǤ餫λͤθľɬפǤ롥

򤹤ˤϡʤȤ⡤ѹɬפǤ롥

ͥپ¥ߥ塼ƥåȤˤ꥿θͥ٤㤯
ʤˤϡƱͥǤ̤ͥǹˤ롥

ϡͥپ¥ߥ塼ƥåƼ¹ԤƤϡ㤯ʤ
ͥ٤Ʊͥ٤¾˼¹ԲǽˤʤäϤ
ꡤǤϺǹ̤ͥĤ٤ȹͤ뤿Ǥ롥

ͥپ¥ߥ塼ƥåȤˤ꥿θͥ٤Ѳ
ʤˤƱȤ뤬θͥ٤Ǽ¹Ծ֤ǤäȤ
ȤϡƱͥǤϺǹ̤ͥäƤȤˤʤʥǥѥå
α֤ξˡ̤ͥѲʤΤȤƤƱ̤Ȥʤ롥
ǥѥåα֤ξο񤤤ꤹ뤿ˡͥ
ǹȤ뤫ѹʤȤ뤫ϷƤɬפ롥

ͤñ㤵ͤȡüʾͥپ¥ߥ塼ƥå
Ȥˤ꥿θͥ٤㤯ʤˤǤΤߺǹ̤ͥȤ
ꡤǹ̤ͥȤǤ¤Ūˤ褤ȹͤ롥
ΤȤ顤λͤͭϤʰƤȤƽФƤ롥

ߥ塼ƥåǽˤ꥿θͥ٤ѲˤϡƱͥ
٤ΥǺǹ̤ͥȤʤ롥ͥ٤Ѳʤˤϡ
̤ͥѹʤ

ǡͥ٤Ѳ륿Ԥ֤ξο񤤤ꤹɬ
פ롥礵ʤ顤Ԥ֤ǡͥٽ
ˤĤʤƤˤϡƱͥ٤ΥǺǽˤΤ
Ǥ뤬Ԥ֤δ֤ޤ̤ͥݻΤϤꤹȤͤ
롥ޤ֤ѲƱˡͥ٤Ѳͤ
ɬפ롥

θơλͤȤ롥

ߥ塼ƥåǽˤ꥿θͥ٤Ѳΰϼ
̤Ȥ롥оݥӥȤ¹ԤǤ֤Ǥ
ˤϡƱͥ٤ΥǺǹ̤ͥȤʤ롥Ǥʤ
ˤϡƱͥ٤ΥǺ̤ͥȤʤ롥ͥ٤Ѳ
ʤˤϡ̤ͥѹʤ

оݥԤ֤ξο񤤤ϡ긷̩˵ꤹɬפ롥

ˡʣΥθͥ٤ƱѲˤϡθ
ͥ٤ѲˤäƷ̤ۤʤäƤ뤿ᡤͥ٤Ѳ
β뤳ȤɬפǤ롥

--------------------
λ꤬ͤʤȤǧ뤿θƤͥپ¥ߥ塼ƥå
ˤ

ͥپ¥ߥ塼ƥåԤ֤뤳Ȥʤ˳Ȥˤ
θͥ٤夬ˤϡޤǤθͥ٤Ǽ¹Ծ֤Ǥ
Ȥ顤ͥ٤Ʊͥ٤ĥ¾ˤʤȤˤ
ʥǥѥåα֤ξˡ̤ͥǹȤƤȤ
ƤƱ̤Ȥʤ롥

ͥپ¥ߥ塼ƥåԤ֤뤳Ȥʤ˳Ȥˤ
θͥ٤ѲʤˤϡޤǤθͥ٤Ǽ¹Ծ
ǤäȤ顤ƱͥǤϺǹ̤ͥäƤȤˤʤʥǥ
ѥåα֤ξˡ̤ͥǹȤƤѲʤΤ
ƤƱ̤Ȥʤ롥

ͥپ¥ߥ塼ƥåԤ֤Ԥ졤ͥپ¥ߥ塼ƥ
ϡ»ȤƤ뤳Ȥ顤ɤΤ褦˷Ƥ

--------------------

¾ιͻ

»ߤ뤳ȤǤϤʤȤȡˤĤ
⡤ǥѥåػߤʻѤ̤ˤϿʤȤФ褤
¾ˡrot_rdqʻѤˤϡ餫»ߤʤФʤ
ʤ

ˤĤƤ⡤١ͥ٤ѹʻѤ̤ˤϿ
ʤȤ⤢뤬Τ褦˻ͤ⤢롥

chg_priǥΥ١ͥ٤ѹΰϼ̤Ȥ롥
ݥ١ͥ٤ѹξ֤ǥߥ塼ƥåͳǥ١
ͥ٤Ʊ⤤ͥ٤ѾƤˤϡͥ٤
ѲʤƱͥ٤ΥǺǹ̤ͥȤʤꡤͥ٤
Ѳʤʤ̤ͥѲʤʳξˤϡƱͥ٤
Ǻ̤ͥȤʤ롥

ǡͥٷѾߥ塼ƥå򥵥ݡȤʤˤϡΤȤ
롥å뤳ȤǤͥپ¥ߥ塼ƥåξͥ
٤ϡΥѹΥ١ͥ٤Ʊ⤤Τᡤ
ͥپ¥ߥ塼ƥååƤˤϡɬ֥ߥ塼ƥå
ͳǥ١ͥ٤Ʊ⤤ͥ٤ѾƤסĤޤꡤ
֥ߥ塼ƥåͳǥ١ͥ٤Ʊ⤤ͥ٤Ѿ
פϡͥپ¥ߥ塼ƥååƤפȰפ롥
ˡͥپ¥ߥ塼ƥååƤˤϡchg_priǥ
Υ١ͥѹƤ⡤Υθͥ٤Ѳ뤳ȤϤʤ

ʾΤȤ顤νͤϡ̤˴ñ뤳ȤǤ롥

chg_priǥΥ١ͥ٤ѹΰϼ̤Ȥ롥
ݥͥپ¥ߥ塼ƥååƤʤ硤Ʊͥ
ΥǺ̤ͥȤʤ롥ʳξˤϡоݥθ
ͥ٤ѹ뤳ȤϤʤ̤ͥѹʤ

chg_priεǽҡʴϢʬΤߡ

----------------------------------------------------------------------
оݥٻ߾֤ǤʤˤϡоݥΥ١ͥ٤tskpri
ǻꤷͥ٤ѹ롥ȼäơоݥθͥ٤
롥

оݥͥپ¥ߥ塼ƥååƤʤˤϡ
Ԥ롥оݥ¹ԤǤ֤ξˤϡƱͥ٤Υ
Ǻ̤ͥȤʤ롥оݥԤ֤ǡͥٽ
ԤˤĤʤƤˤϡоݥѹθͥ٤˽
ơԤǤνѹ롥ԤƱͥ٤Υ
ˤϡоݥνϤǺǸˤʤ롥

оݥͥپ¥ߥ塼ƥååƤˤϡоݥ
θͥ٤ѹ뤳ȤϤʤ̤ͥѹʤ
----------------------------------------------------------------------

ASPͥؤμ

֥åȥߥ塼ƥå֥å

ߥ塼ƥåǽ¸뤿Υǡ¤Ȥơߥ塼ƥå
ʥߥ塼ƥåԤäƤ륿Υꥹȡˤ˲äơ
Ƥ줬åƤߥ塼ƥåΥꥹȤȡߥ塼ƥåФ
ƤݻƤ륿ɬפ롥

ǡTCBˤϡåƤߥ塼ƥåΥ塼إåΥե
ɲä롥ޤͥ٤˲äơ١ͥ٤ݻե
ɲä롥

----------------------------------------
typedef struct task_control_block {
	...
	BIT_FIELD_UINT	bpriority : TBIT_TCB_PRIORITY;
									/* ١ͥ١ɽ*/
	BIT_FIELD_UINT	priority : TBIT_TCB_PRIORITY;
									/* ͥ١ɽ*/
	...
	QUEUE			mutex_queue;	/* åƤߥ塼ƥåΥ塼 */
	...
} TCB;
----------------------------------------

bpriorityϡٻ߾ְʳͭѿǤ뤿ᡤmake_dormantǽ
롥

mutex_queueϡٻ߾ְʳͭѿǤ뤬ٻ߾֤ܤݤ
ɬˤΤǡmake_dormantǤϤʤinitialize_taskˤƽ
롥

ޤtstatեɤ륿֤ɽˡTS_WAIT_MTXʥߥ塼
ƥåΥåԤˤɲä롥

ߥ塼ƥå֥åˤϡߥ塼ƥåԤ塼˲äơߥ塼
ƥååƤ륿TCBؤΥݥ󥿤ȡåƤ
ߥ塼ƥåΥ塼ˤĤʤΥեɤѰդ롥

----------------------------------------
typedef struct mutex_control_block {
	QUEUE		wait_queue;		/* ߥ塼ƥåԤ塼 */
	const MTXINIB *p_mtxinib;	/* ֥åؤΥݥ */
	TCB			*p_loctsk;		/* ߥ塼ƥååƤ륿 */
	QUEUE		mutex_queue;	/* åƤߥ塼ƥåΥ塼 */
} MTXCB;
----------------------------------------

ߥ塼ƥååƤʤȤϡp_loctskNULLꤹ뤳
ɽߥ塼ƥååƤʤˤϡmutex_queue̵
롥

ߥ塼ƥå֥åˤϡߥ塼ƥå°ȥߥ塼ƥå
ͥ٤ݻ롥

----------------------------------------
typedef struct mutex_initialization_block {
	ATR			mtxatr;			/* ߥ塼ƥå° */
	uint_t		ceilpri;		/* ߥ塼ƥåξͥ١ɽ*/
} MTXINIB;
----------------------------------------

ݤˡ줬åƤߥ塼ƥå뤳Ȥ
¿ᡤߥ塼ƥå֥åmutex_queueؤΥݥ󥿤顤
ߥ塼ƥå֥åؤΥݥ󥿤ФΥޥѰդ
mutex.cˡ

----------------------------------------
#define MTXCB_QUEUE(p_queue) \
			((MTXCB *)(((char *) p_queue) - offsetof(MTXCB, mutex_queue)))
----------------------------------------

ͥ浬§ȸͥ٤η׻

TOPPERS奫ͥǤϡITRON4.0ͤθ̩ͥ浬§Τߤ
롥̩ͥ浬§ˤƤϡθͥ٤򡤾ˡ
ͥ٤κǹͤ˰פ褦ꤹ롥

(1) Υ١ͥ

(2) ͥپ¥ߥ塼ƥååƤ硤Υߥ塼
	ƥåǡǤ⤤ͥ٤ĥߥ塼ƥåξͥ

(3) ͥٷѾߥ塼ƥååƤ硤Υߥ塼
	ƥåΥåԤäƤ륿ǡǤ⤤ͥ٤
	θͥ

ͥ٤򡤤Ǥϡͥ٤ꤹǤȤʤȤ̣ǡ
ͥ٤ȸƤ֡

ASPͥΥߥ塼ƥåĥǤϡͥٷѾߥ塼ƥåϥݡ
ʤᡤ(3)Ϲͤɬפʤ

ޤϡ٤Ƥͥ٤򥹥󤷡θͥ٤׻
롥δؿƤ֤Ȥˤꡤθͥ٤ꤹ٤
ͤ׻뤳ȤǤ롥

----------------------------------------
/* 
 *  θͥ٤η׻
 */
static uint_t
mutex_calc_priority(TCB *p_tcb)
{
	uint_t	priority;
	QUEUE	*p_queue;
	MTXCB	*p_mtxcb;

	priority = p_tcb->bpriority;
	p_queue = p_tcb->mutex_queue.p_next;
	while (p_queue != &(p_tcb->mutex_queue)) {
		p_mtxcb = MTXCB_QUEUE(p_queue);
		if (MTX_CEILING(p_mtxcb) && p_mtxcb->p_mtxinib->ceilpri < priority) {
			priority = p_mtxcb->p_mtxinib->ceilpri;
		}
		p_queue = p_queue->p_next;
	}
	return(priority);
}
----------------------------------------

ͥ٤ѹν

ߥ塼ƥåǽˤ꥿θͥ٤ѹˤϡTCBθ
ͥ٤򹹿뤳Ȥ˲äơνԤɬפ

----------------------------------------
ߥ塼ƥåǽˤ꥿θͥ٤Ѳˤϡν
Ԥ롥ͥ٤Ѳ륵ӥȤ⡤
¹ԤǤ֤ǤˤϡƱͥ٤ΥǺǹ̤ͥ
ʤ롥Υӥˤꡤ¹ԤǤ֤ܤ
ˤϡƱͥ٤ΥǺ̤ͥȤʤ롥Υӥ
θǡԤ֤ǡͥٽԤˤĤʤ
ˤϡѹθͥ٤˽äơԤ
νѹ롥ԤƱͥ٤Υˤϡ
νϤǺǸˤʤ롥
----------------------------------------

ν¸뤿ˡͥ٤ѹݤˡƱͥ٤Υ
Ǻǹ̤ͥȤؿɬפǤ롥Τ褦ʴؿ򿷤Ѱդ
뤳ȤǽǤ뤬¿ʬchange_priorityȶ̤Ǥ뤿ᡤ
change_priority˿ʥѥ᡼mtxmodeɲämtxmodefalseλ
Ʊͥ٤ΥǺ̡ͥmtxmodetrueλƱͥ٤Υ
Ǻǹ̤ͥȤ褦˽롥

----------------------------------------
bool_t
change_priority(TCB *p_tcb, uint_t newpri, bool_t mtxmode)
{
	uint_t	oldpri;

	oldpri = p_tcb->priority;
	p_tcb->priority = newpri;

	if (TSTAT_RUNNABLE(p_tcb->tstat)) {
		/*
		 *  ¹ԤǤ֤ξ
		 */
		queue_delete(&(p_tcb->task_queue));
		if (queue_empty(&(ready_queue[oldpri]))) {
			primap_clear(oldpri);
		}
		if (mtxmode) {
			queue_insert_next(&(ready_queue[newpri]), &(p_tcb->task_queue));
		}
		else {
			queue_insert_prev(&(ready_queue[newpri]), &(p_tcb->task_queue));
		}
		primap_set(newpri);

		if (p_schedtsk == p_tcb) {
			if (newpri >= oldpri) {
				p_schedtsk = search_schedtsk();
				return(p_schedtsk != p_tcb && dspflg);
			}
		}
		else {
			if (mtxmode ? newpri <= p_schedtsk->priority
						: newpri < p_schedtsk->priority) {
				p_schedtsk = p_tcb;
				return(dspflg);
			}
		}
	}
	else {
		if (TSTAT_WAIT_WOBJCB(p_tcb->tstat)) {
			/*
			 *  Ʊ֥̿Ȥδ֥åζ
			 *  ʬWOBJCBˤԤ塼ˤĤʤƤ
			 */
			wobj_change_priority(((WINFO_WOBJ *)(p_tcb->p_winfo))->p_wobjcb,
																	p_tcb);
		}
	}
	return(false);
}
----------------------------------------

ǡƱͥ٤ΥǺǹ̤ͥȤʤΤϡͥ٤
륵ӥȤ¹ԤǤ֤Ǥ
¤뤿ᡤwobj_change_priorityɬפϤʤ

chg_prichange_priorityƤ־ˤϡmtxmodefalseˤ롥

ߥ塼ƥåǽˤꡤξ֤Ѳˡθ
ͥ٤Ѳϡmtxmodetrueˤchange_priorityƤ֡
ξ֤ѲˤϡӸƤ롥

ͥ٤

ͥ٤Ԥݤˡͥ٤ꤹ뤿ͥ٤夬
ʤޤ˾ȡʤޤϸ˾Ǥ礭㤤롥

ͥ٤夬ʤޤ˾ˤϡ夬äͥ٤ȥ
θͥ٤Ӥǡͥ٤ѹɬȽǤǤ롥
٤Ƥͥ٤򥹥󤹤ɬפϤʤ

Фơͥ٤ʤޤϸ˾ǡͥ
٤θͥ٤ȰפƤʸȡͥ
٤θͥ٤ꤷƤˤˤϡ٤Ƥͥ٤
󤷤ƥθͥ٤׻뤳ȤɬפǤ롥
ͥ٤θͥ٤ȰפƤʤäˤϡͥ٤
ˤʤǽϤʤνɬפʤ

ޤǤʤͥ٤Ѳʤˤϡθͥ٤
ɬפʤ

ͥ٤夬ʤޤ˾νϼ̤ꡥnewpriˤϡ
äΡʤޤͥ٤Ϥ

----------------------------------------
/*
 *  ͥ٤夬ʤޤ˾θͥѹ
 */
Inline bool_t
mutex_raise_priority(TCB *p_tcb, uint_t newpri)
{
	if (newpri < p_tcb->priority) {
		return(change_priority(p_tcb, newpri, true));
	}
	return(false);
}
----------------------------------------

ͥ٤ʤޤϸ˾νϼ̤ꡥoldpriˤϡ
Ρʤޤϸäͥ٤Ϥ

----------------------------------------
/*
 *  ͥ٤ʤޤϸ˾θͥѹ
 */
Inline bool_t
mutex_drop_priority(TCB *p_tcb, uint_t oldpri)
{
	uint_t	newpri;

	if (oldpri == p_tcb->priority) {
		newpri = mutex_calc_priority(p_tcb);
		if (newpri != p_tcb->priority) {
			return(change_priority(p_tcb, newpri, true));
		}
	}
	return(false);
}
----------------------------------------

δؿ⡤ǥѥåɬפʾtrueɬפʤ
false֤

ͥɬײս

Ҥ(1)(2)ͥ٤Ѳˡθͥ٤ѹ
ɬפˤʤǽ롥ǡ(1)(2)ͥ٤Τ줾ˤĤơ
ɤΤ褦ʾѲ뤫ƤץΤɤβսǸͥ
ѹ٤Ф

(1)֥Υ١ͥ١פѲΤϡchg_priˤäƥΥ١
	ͥ٤ѹΤߤǤ롥λϡͥ٤夬
	Ⲽ⤢롥

(2)֥ͥپ¥ߥ塼ƥååƤ硤Υߥ塼
	ƥåǡǤ⤤ͥ٤ĥߥ塼ƥåξͥ١
	ѲΤϡʲΤ줫ξǤ롥

(2-1) ͥپ¥ߥ塼ƥååλϡͥ٤
	  롥

(2-2) ͥپ¥ߥ塼ƥååλϡͥ
	  롥

ͥμ

ͥɬײսˡˡƤ롥(1)chg_pri
νˤĤƤϸǤޤȤƸƤ뤳ȤȤǤ(2-1)(2-2)ˤ
ƸƤ롥

(2-1) ͥپ¥ߥ塼ƥåå

ߥ塼ƥååϡloc_mtxploc_mtxtloc_mtx
äơunl_mtxext_tskter_tskˤ롥

loc_mtxploc_mtxtloc_mtxǥߥ塼ƥååˤϡ
ߥ塼ƥååp_loctskåߥ塼ƥå
p_mtxcbȤȡνԤФ褤

----------------------------------------
	mutex_raise_priority(p_loctsk, p_mtxcb->p_mtxinib->ceilpri);
----------------------------------------

unl_mtxext_tskter_tskǥߥ塼ƥååΤϡ
ߥ塼ƥåԤ֤ΥԤ줿Ǥ롥ξˤϡ
ָͥ٤Ѳ륵ӥȤ¹ԤǤ
֤Ǥפ˳ʤᡤԤ줿ϡƱͥ٤
Ǻ̤ͥȤʤ롥

ǡξˤmtxmodetrueˤchange_priorityƤӽФ
mutex_raise_priorityȤ鷺ˡͥ٤TCBꤷˡ
make_non_waitƤӽФǼ롥ŪˤϡԤƥߥ塼ƥ
åp_tcbåߥ塼ƥåp_mtxcbȤ
ȡνԤ

----------------------------------------
		if (MTX_CEILING(p_mtxcb)) {
			if (p_mtxcb->p_mtxinib->ceilpri < p_tcb->priority) {
				p_tcb->priority = p_mtxcb->p_mtxinib->ceilpri;
			}
		}
		make_non_wait(p_tcb);
----------------------------------------

嵭Υɤϡߥ塼ƥåΥåԤmutex_release
ޤ롥mutex_releaseμϼ̤ꡥ

----------------------------------------
static bool_t
mutex_release(MTXCB *p_mtxcb)
{
	TCB		*p_tcb;

	if (queue_empty(&(p_mtxcb->wait_queue))) {
		p_mtxcb->p_loctsk = NULL;
		return(false);
	}
	else {
		/*
		 *  ߥ塼ƥåԤ塼Ƭp_tcbˤˡߥ塼ƥ
		 *  å롥
		 */
		p_tcb = (TCB *) queue_delete_next(&(p_mtxcb->wait_queue));
		wait_dequeue_tmevtb(p_tcb);
		p_tcb->p_winfo->wercd = E_OK;

		p_mtxcb->p_loctsk = p_tcb;
		queue_insert_prev(&(p_tcb->mutex_queue), &(p_mtxcb->mutex_queue));
		if (MTX_CEILING(p_mtxcb)) {
			if (p_mtxcb->p_mtxinib->ceilpri < p_tcb->priority) {
				p_tcb->priority = p_mtxcb->p_mtxinib->ceilpri;
			}
		}
		return(make_non_wait(p_tcb));
	}
}
----------------------------------------

δؿθȾϡΤ褦˼뤳Ȥǽ˻פ롥

----------------------------------------
	else {
			bool_t	dspreq = false;

			p_tcb = (TCB *) queue_delete_next(&(p_mtxcb->wait_queue));
			if (wait_complete(p_tcb)) {
				dspreq = true;
			}
			if (mutex_acquire(p_tcb, p_mtxcb)) {
				dspreq = true;
			}
			return(dspreq);
	}
----------------------------------------

Υɤˤϡߥ塼ƥåå̤ͥƱ
ͥ٤ΥǺǹȤʤäƤޤȤ꤬롥ͤ˹碌
뤿ˤϡmutex_acquireФƥѥ᡼mtxmodeɲäʤɤν
ɬפǤ롥

ޤΥɤϡwait_compleateǥǥ塼ˤĤʤ塤
mutex_acquireƤmutex_raise_priorityǥǥ塼κ
Ԥ礬ꡤΨ

(2-2) ͥپ¥ߥ塼ƥåå

ߥ塼ƥååϡunl_mtx˲äơext_tsk
ter_tskini_mtxˤ롥ξˤϡߥ塼ƥåå
p_loctskåߥ塼ƥåp_mtxcbȤȡν
ԤФ褤
								   
----------------------------------------
	mutex_drop_priority(p_loctsk, p_mtxcb->p_mtxinib->ceilpri);
----------------------------------------

ƽμ

loc_mtxploc_mtxtloc_mtx

loc_mtxǤϡߥ塼ƥååȡߥ塼ƥåΥ
ԤϤԤΤᡤҤͥѹս(2-1) б
ʤФʤʤ(2-1)νϡmutex_acquireǹԤ

unl_mtx

unl_mtxǤϡߥ塼ƥååȡԤ֤Ǥä
˥ߥ塼ƥååԤΤᡤҤͥ
ѹս(2-1)(2-2)бʤФʤʤ(2-1)νϡ
mutex_releaseǹԤ

ini_mtx

ini_mtxǤϡߥ塼ƥååȡߥ塼ƥå
åԤĤΤԤΤᡤҤͥѹս
(2-2)бʤФʤʤ

ext_tsk

ext_tskǤϡߥ塼ƥååȡԤ֤Ǥä
˥ߥ塼ƥååԤΤᡤҤͥ
ѹս(2-1)(2-2)бʤФʤʤ(2-1)νϡ
mutex_release_allƤӽФmutex_releaseǹԤ

(2-2)νˤĤƤϡͳˤά뤳ȤǤ롥νϡ
ߥ塼ƥåΥåˤ꼫ͥѹǤ뤬
ϤΥӥˤ꽪λ뤿ᡤͥ٤򹹿ɬפ
ʤ

ter_tsk

ter_tskǤϡߥ塼ƥåΥåԤĤΤߥ塼ƥ
åȡԤ֤Ǥä˥ߥ塼ƥå
ԤΤᡤҤͥѹս(2-1)(2-2)б
ʤФʤʤ(2-1)νϡmutex_release_allƤӽФ
mutex_releaseǹԤ

(2-2)νˤĤƤϡͳˤά뤳ȤǤ롥νϡ
ߥ塼ƥåΥåˤоݥͥѹǤ뤬
оݥϤΥӥˤ꽪λ뤿ᡤͥ٤򹹿ɬ
Ϥʤ

chg_priν

ޤߥ塼ƥå򥵥ݡȤ뤳Ȥˤꡤchg_pri˰ʲΥ顼
ɲäɬפ롥

----------------------------------------
оݥͥپ¥ߥ塼ƥååƤ뤫åԤäƤ
硤tskpriϡΥߥ塼ƥåξͥ٤Ʊ
ʤФʤʤ
----------------------------------------

Υ顼򸡽Ф뤿ˡchg_priˤϼΥɤɲä롥

----------------------------------------
	else if ((!queue_empty(&(p_tcb->mutex_queue))
										|| TSTAT_WAIT_MTX(p_tcb->tstat))
						&& !mutex_check_ceilpri(p_tcb, newbpri)) {
		ercd = E_ILUSE;
	}
----------------------------------------

mutex_check_ceilpriμϼ̤ꡥδؿϡ顼򸡽Ф
false򡤤Ǥʤtrue֤

----------------------------------------
bool_t
mutex_check_ceilpri(TCB *p_tcb, uint_t bpriority)
{
	QUEUE	*p_queue;
	MTXCB	*p_mtxcb;

	/*
	 *  åƤͥپ¥ߥ塼ƥåǡͥ
	 *  ٤bpriority㤤ΤСfalse֤
	 */
	p_queue = p_tcb->mutex_queue.p_next;
	while (p_queue != &(p_tcb->mutex_queue)) {
		p_mtxcb = MTXCB_QUEUE(p_queue);
		if (MTX_CEILING(p_mtxcb) && bpriority < p_mtxcb->p_mtxinib->ceilpri) {
			return(false);
		}
		p_queue = p_queue->p_next;
	}

	/*
	 *  ͥپ¥ߥ塼ƥåΥåԤäƤˡ
	 *  ξͥ٤bpriority㤯Сfalse֤
	 */
	if (TSTAT_WAIT_MTX(p_tcb->tstat)) {
		p_mtxcb = ((WINFO_MTX *)(p_tcb->p_winfo))->p_mtxcb;
		if (MTX_CEILING(p_mtxcb) && bpriority < p_mtxcb->p_mtxinib->ceilpri) {
			return(false);
		}
	}

	/*
	 *  ξˤƤϤޤʤtrue֤
	 */
	return(true);
}
----------------------------------------

ˡ١ͥ٤ѹ塤νԤɬפ롥

----------------------------------------
ȼäơоݥθͥ٤ѹ롥

оݥͥپ¥ߥ塼ƥååƤʤˤϡ
Ԥ롥оݥ¹ԤǤ֤ξˤϡƱͥ٤Υ
Ǻ̤ͥȤʤ롥оݥԤ֤ǡͥٽ
ԤˤĤʤƤˤϡоݥѹθͥ٤˽
ơԤǤνѹ롥ԤƱͥ٤Υ
ˤϡоݥνϤǺǸˤʤ롥

оݥͥپ¥ߥ塼ƥååƤˤϡоݥ
θͥ٤ѹ뤳ȤϤʤ̤ͥѹʤ
----------------------------------------

¸뤿ˤϡͥپ¥ߥ塼ƥååƤʤ
ˤΤchange_priorityƤ֤褦˽Ф褤change_priorityϡ
mtxmodefalseˤƸƤ֡ˡŪˤϡchg_priμʬϼΤ褦ˤ
롥

----------------------------------------
		p_tcb->bpriority = newbpri;
		if (queue_empty(&(p_tcb->mutex_queue))
								|| !mutex_scan_ceilmtx(p_tcb)) {
			if (change_priority(p_tcb, newbpri, false)) {
				dispatch();
			}
		}
		ercd = E_OK;
----------------------------------------

ǡmutex_scan_ceilmtxϡͥپ¥ߥ塼ƥåå
Ƥtrue֤ؿǡΤ褦˼롥

----------------------------------------
bool_t
mutex_scan_ceilmtx(TCB *p_tcb)
{
	QUEUE	*p_queue;
	MTXCB	*p_mtxcb;

	p_queue = p_tcb->mutex_queue.p_next;
	while (p_queue != &(p_tcb->mutex_queue)) {
		p_mtxcb = MTXCB_QUEUE(p_queue);
		if (MTX_CEILING(p_mtxcb)) {
			return(true);
		}
		p_queue = p_queue->p_next;
	}
	return(false);
}
----------------------------------------

rot_rdqν

rot_rdqϡtskpriTPRI_SELFꤵ줿ˡΥ١ͥ
оͥ٤Ȥ롥ߥ塼ƥåƳˤꡤ١ͥ٤ɽե
ɤߤ줿ᡤʬΥɤɬפ롥Ūˤϡ
rot_rdq

----------------------------------------
	pri = (tskpri == TPRI_SELF) ? p_runtsk->priority : INT_PRIORITY(tskpri);
----------------------------------------

ιԤ򡤼Τ褦˽롥

----------------------------------------
	pri = (tskpri == TPRI_SELF) ? p_runtsk->bpriority : INT_PRIORITY(tskpri);
----------------------------------------

ref_tskν

ref_tskϡtskbpriоݥΥ١ͥ٤֤ߥ塼ƥåƳ
ˤꡤ١ͥ٤ɽեɤߤ줿ᡤʬΥ
ɤɬפ롥Ūˤϡref_tsk

----------------------------------------
		pk_rtsk->tskbpri = EXT_TSKPRI(p_tcb->priority);
----------------------------------------

ιԤ򡤼Τ褦˽롥

----------------------------------------
		pk_rtsk->tskbpri = EXT_TSKPRI(p_tcb->bpriority);
----------------------------------------

ߥ塼ƥåǽ󥯤ʤ

Ǹˡߥ塼ƥåǽѤʤˡߥ塼ƥåϢΥ
ɤ󥯤ʤפԤ

ߥ塼ƥå⥸塼γƤӽФߥ塼ƥå⥸塼
ؿϼ̤ꡥ

	mutex_check_ceilprichg_pri
	mutex_scan_ceilmtxchg_pri
	mutex_release_allext_tskter_tsk

δؿϥեå롼ǤΤȤƤӽФݤˤϡѿȤ
ϤळȤˤ롥㤨Сmutex_release_all(p_runtsk)פˡ

	(*mtxhook_release_all)(p_runtsk);

ȵҤ롥mtxhook_release_allˤϡߥ塼ƥå⥸塼뤬󥯤
줿ˤmutex_release_allؤΥݥ󥿤Ǽ롥Ūˤϡ
initialize_mutexˤꤹ롥ߥ塼ƥå⥸塼뤬󥯤
ʤˤϡmtxhook_release_all򻲾ȤƤϤʤʤΤȤ0
뤳Ȥϲꤷʤˡ

㤨Сext_tskmutex_release_allƤֲսϼΤ褦ˤʤ롥

----------------------------------------
	if (!queue_empty(&(p_runtsk->mutex_queue))) {
		(void) (*mtxhook_release_all)(p_runtsk);
	}
----------------------------------------

TCBmutex_queueǤʤʤΤϡߥ塼ƥåå
ƤΤߤǡϥߥ塼ƥå⥸塼뤬󥯤줿˸
롥ΤΥɤǡߥ塼ƥå⥸塼뤬󥯤ʤ
ˤϡmtxhook_release_allȤ뤳ȤϤʤ

¾2ĤδؿˤĤƤ⤳Ʊͤ˰

ߥ塼ƥåǽĥΥ륰

	chg_pri -- mutex_check_ceilpri
			-- change_priority -- wobj_change_priority

	ext_tsk -- mutex_release_all -- mutex_release

	ter_tsk -- mutex_release_all -- mutex_release

	initialize_mutex

	mutex_check_ceilpri

	mutex_calc_priority

	mutex_raise_priority -- change_priority -- wobj_change_priority

	mutex_drop_priority -- mutex_calc_priority
						-- change_priority -- wobj_change_priority

	mutex_acquire -- mutex_raise_priority --

	mutex_release_all -- mutex_release

	loc_mtx -- mutex_acquire -- mutex_raise_priority --
	ploc_mtx -- mutex_acquire -- mutex_raise_priority --
	tloc_mtx -- mutex_acquire -- mutex_raise_priority --

	unl_mtx -- mutex_drop_priority --
			-- mutex_release

	ini_mtx -- mutex_drop_priority --

	ref_mtx 

ߥ塼ƥåǽΥƥ

ߥ塼ƥåΥƥ(1)

FIFOߥ塼ƥå򡤥åȥå̤ƥ
Ȥ롥

ߥ塼ƥåΥƥ(2)

ͥٽߥ塼ƥå򡤥åȥå̤
Ȥ롥

ߥ塼ƥåΥƥ(3)

ͥپ¥ߥ塼ƥå򡤥åȥå̤
ƥȤ롥ref_tskˤ١ͥ٤ȸͥ٤λȽΥƥȤ
ͤƤ롥

ߥ塼ƥåΥƥ(4)

ͥپ¥ߥ塼ƥåФơloc_mtxunl_mtxȼͥ٤ѹ
Ū˥ƥȤ롥change_prioritymutex_calc_priority
ƤˤƧ߹ޤʤ

ߥ塼ƥåΥƥ(5)

ͥپ¥ߥ塼ƥåФơߥ塼ƥåκƽŪ
˥ƥȤ롥change_prioritymutex_calc_priorityƤˤƧ
߹ޤʤ

ߥ塼ƥåΥƥ(6)

ͥپ¥ߥ塼ƥåФơνλ̤ͥβ
žΥߥ塼ƥåϢνŪ˥ƥȤ롥

ߥ塼ƥåΥƥ(7)

ͥپ¥ߥ塼ƥåФơζλΥߥ塼ƥå
ϢνŪ˥ƥȤ롥

ߥ塼ƥåΥƥ(8)

ͥپ¥ߥ塼ƥåФơchg_priȼߥ塼ƥåϢͥ
ѹŪ˥ƥȤ롥change_priority
mutex_check_ceilprimutex_scan_ceilmtxƤˤƧ߹ޤʤ

ʾ

**********************************************************************
ѤʤäƤ
**********************************************************************

ߥ塼ƥåǽνͰ

ߥ塼ƥåǽλͤˤĤƤϡITRON4.0ͤΥߥ塼ƥåǽ
١Ȥ뤬νä롥

ߥ塼ƥåȼθͥ٤ѲˤϡƱͥ
٤ΥǺǹ̤ͥȤʤ롥

	¹ԤǤ֤ξ˸¤٤
		¹Ծ֤˸¤ȤƤ⤢  Ժ
		ӥȤ¹ԤǤ֤Ǥ˸¤Ƥ⤢  
	ߥ塼ƥååƤ˸¤
		ʿ˥å硤ޤǥåƤޤ

chg_priǥΥ١ͥ٤ѹǡ١ͥ٤ѹ
ξ֤ǥߥ塼ƥåͳͥ٤ѾƤʤ˸¤ꡤƱ
ͥ٤ΥǺ̤ͥȤʤ롥ߥ塼ƥåͳͥ٤
ѾƤˤɤʤ뤫׸Ƥͥ٤ѤϺǹ̡ͥ
ѤʤϤΤޤޤȤΤˡ

	¹ԤǤ֤ξ˸¤٤  
		¹Ծ֤˸¤ȤƤ⤢  Ժ

θƤơΤ褦˾ܺٲ롥

ߥ塼ƥåȼθͥ٤Ѳΰϼ
̤Ȥ롥оݥӥȤ¹ԤǤ֤Ǥ
ˤϡƱͥ٤ΥǺǹ̤ͥȤʤ롥Ǥʤ
ˤϡƱͥ٤ΥǺ̤ͥȤʤ롥

chg_priǥΥ١ͥ٤ѹΰϼ̤Ȥ롥
ݥ¹ԤǤ֤ǡ١ͥ٤ѹξ֤ǥߥ塼ƥ
ͳǥ١ͥ٤Ʊ⤤ͥ٤ѾƤ
ϡͥ٤ѲʤƱͥ٤ΥǺǹ̤ͥȤ
ꡤͥ٤Ѳʤʤ̤ͥѲʤʳξ
ϡƱͥ٤ΥǺ̤ͥȤʤ롥

˥ߥ塼ƥåͳǥ١ͥ٤㤤ͥ٤Ѿϡ
	ͥٷѾߥ塼ƥåΤߤǵꡤͥپ¥ߥ塼ƥåǤ
	ʤΤᡤͥٷѾߥ塼ƥå򥵥ݡȤʤ
	ˤϡ֥ߥ塼ƥåͳǥ١ͥ٤Ʊ⤤ͥ
	ѾƤפϡͥپ¥ߥ塼ƥååƤ
	פȰפ롥

ڻ͡

ͥٷѾϡϡͥ٤ǤϤʤ̤ͥѾ٤Ǥ٤
Ȥո뤬μǤ̤ͥ򵭲Ƥʤᡤ¸
񤷤Ȥ꤬롥

chg_priεǽҡʴϢʬΤߡ

----------------------------------------------------------------------
tskidǻꤷоݥˤΥ١ͥ٤tskpriǻꤷͥ
٤ѹ롥Ūʿ񤤤ϰʲ̤ꡥ

оݥٻ߾֤ǤʤˤϡоݥΥ١ͥ٤tskpri
ǻꤷͥ٤ѹ롥ȼäơоݥθͥ٤
롥

оݥ¹ԤǤ֤ξˤϡоݥ̤ͥϼ̤
ʤ롥ѹθͥ٤ߥ塼ƥåͳͥ٤ѾƤʤ
ˤϡƱͥ٤ΥǺ̤ͥȤʤ롥ߥ塼ƥåͳ
ͥ٤ѾƤˤϡͥ٤ѲʤƱͥ٤Υ
Ǻǹ̤ͥȤʤꡤͥ٤Ѳʤʤ̤ͥѲ
ʤ

ǡͥ٤ߥ塼ƥåͳͥ٤ѾƤȤϡо
ߥ塼ƥååƤ뤳Ȥˤꡤ١ͥ٤Ʊ
⤤ͥ٤ѾƤ뤳ȤʤΤ줫ʤ
ξˤξǤ롥

оݥåƤͥٷѾߥ塼ƥåоݥ
	١ͥ٤Ʊ⤤ͥ٤äԤäƤ롥
оݥͥپ¥ߥ塼ƥååƤʥ
	Ƥͥپ¥ߥ塼ƥåξͥ٤ϡɬΥ
	Υ١ͥ٤Ʊ⤤ˡ

оݥԤ֤ǡͥٽԤˤĤʤƤ
ˤϡоݥѹθͥ٤˽äơԤǤν
ѹ롥ԤƱͥ٤Υˤϡоݥ
νϤǺǸˤʤ롥
----------------------------------------------------------------------

͡ITRON4.0͡4.02.00ˤˤchg_pri

----------------------------------------------------------------------
Υӥ륳¹Ԥ̡оݥθͥ٤Ѳ
Ӹͥ٤١ͥ٤˰פƤʥߥ塼ƥåǽ
ȤʤˤϡξϾΩġˤˤϡνԤоݥ
¹ԤǤ֤Ǥ硤̤ͥѹͥ٤ˤ
äѲ롥ѹͥ٤Ʊͥ٤ĥδ֤Ǥϡ
ݥ̤ͥȤ롥оݥ餫Υͥٽ
ˤĤʤƤˤ⡤ԤǤνѹͥ
٤ˤäѲ롥ѹͥ٤Ʊͥ٤ĥδ
ǤϡоݥǸˤĤʤ
----------------------------------------------------------------------

chg_priˤͥѲ˴ؤʬ

(a) Υӥ¹Ԥ̡оݥθͥ٤Ѳ
礪Ӹͥ٤١ͥ٤˰פƤ

(a1)ָͥ٤١ͥ٤˰ס
		ߥ塼ƥåͳͥ٤ѾƤʤ or
		ߥ塼ƥåͳͥ٤ѾƤͥ٤١ͥ٤
		Ʊ㤤
(a2) оݥθͥ٤Ѳ

(a-) Υӥ¹Ԥ̡оݥθͥ٤Ѳ
ͥ٤١ͥ٤˰פƤʤ

(a1-)ָͥ٤١ͥ٤˰פƤʤ
		ߥ塼ƥåͳǡ١ͥ٤⤤ͥ٤ѾƤ
(a2-) оݥθͥ٤Ѳ

١ͥ٤chg_priǤɤΤ褦Ѳ򡤥ߥ塼ƥå
ͳǷѾƤǹͥ٤ȤӤʬह롥ɽǡֹ⤤פȤϡ١
ͥ٤ߥ塼ƥåͳǷѾƤǹͥ٤⤤Ȥ
ޤ(Ѳ)פȤϡchg_priǥ١ͥ٤ͤѤ
Ȥ򼨤
													̤ͥѲ
	chg_pri	chg_pri		Ω			¹ԤǤ	Ԥ
	⤤		⤤(Ѳ)	(a1)(a2)(a)	(b)					
	⤤		⤤(Ѳʤ)	(a1)    (a)	(b)					
	⤤		Ʊ			(a1)(a2)(a)			㢪ǹ		
	⤤		㤤			    (a2)(a)			㢪ǹ		
	Ʊ		⤤			(a1)(a2)(a)	(b)					
	Ʊ		Ʊ(Ѳʤ)	(a1)    (a)			㢪Ѳʤ	㢪
	Ʊ		㤤								Ѳʤ		Ѳʤ
	㤤		⤤			(a1)(a2)(a)	(b)					
	㤤		Ʊ			(a1)    (a)			㢪Ѳʤ	㢪
	㤤		㤤(Ѳ)						Ѳʤ		Ѳʤ
	㤤		㤤(Ѳʤ)						Ѳʤ		Ѳʤ

(b) ѹθͥ٤ߥ塼ƥåͳͥ٤ѾƤʤ

(b-) ѹθͥ٤ߥ塼ƥåͳͥ٤ѾƤ

ƤΥ

ͥپ¤ˤܤäƹͤ

ͥپ¤Ǥϡͥ٤ѲΤϡʲξ

ߥ塼ƥååȤ
		ͥ٤夬ʤޤϡѤʤ
		 ŦξͤȡƱͥǤϺǹ̤ͥǤ٤

ߥ塼ƥååȤ
		ͥ٤ʤޤϡѤʤ
		 ¾ͥپ¥ߥ塼ƥååƤˤϡ
				ƱͥǤϺǹ̤ͥǤ٤
		 ǤʤˤϡɤǤʤȻפ뤬
				stack resource policy ¸ˤϡǹ̤ͥǤ٤

ꡧ륿ߥ塼ƥåå¾Υå
		ΣĤƱ˵

	 Ԥ֤¹Բǽ֤ˤʤϡǹ̤ͥǤɬפʤ
		å¾ΥפϺ̤ͥȤ

	ȡ
		¾˥ߥ塼ƥååϡ̤ͥȤ

ߥ塼ƥå줿
		åƤͥ٤ʤޤϡѤʤ

chg_priȯԤ줿
		ߥ塼ƥååƤ
			١ͥ٤夲
				١ͥ٤åƤߥ塼ƥåͥپ
				¤⤯ʤ뤳ȤϤʤᡤ١ͥ٤夲
				Ȥǡͥ٤ѹϤʤ
			١ͥ٤򲼤
				ޤǤΥ١ͥ٤åƤߥ塼ƥå
				ͥپ¤⤤ȤϤʤᡤ١ͥ٤
				Ȥǡͥ٤ѹϤʤ

			 åƤߥ塼ƥåͥپ¤ϡѹΥ١
			ͥ٤Ʊ⤤ᡤͥ٤ѹϤʤ
			äơ̤ͥѹʤΤľ

			ͥٷѾߥ塼ƥåΩʤʤ롥

		ߥ塼ƥååƤʤϡ̾ο񤤤Ȱפ٤
				Ĥޤꡤ̤ͥȤ

λλ줿
		ߥ塼ƥååƤСå뤳Ȥˤʤ뤬
		λƤޤΤǡ̤ͥϰ̣ʤʤ

˸ƤλͤξܺٸƤʸŤ

ITRON4.0ͤθ̩ͥ浬§ˤƤϡθͥ٤
ˡͥ٤κǹͤ˰פ褦ꤹ롥

(1) Υ١ͥ

(2) TA_INHERIT°Υߥ塼ƥååƤ硤
	Υߥ塼ƥåΥåԤäƤ륿ǡǤ⤤ͥ
	٤ĥθͥ

(3) TA_CEILING°Υߥ塼ƥååƤ硤
	Υߥ塼ƥåǡǤ⤤ͥ٤ĥߥ塼ƥåξ
	ͥ

ͥ٤򡤤Ǥϡͥ٤ꤹǤȤʤȤ̣ǡ
ͥ٤ȸƤ֡

(A)ˤꡤ(2)(3)ͥ٤ϡƱͥκǹ̤ͥȤ
ʤȤˤʤ롥

ޤ(2)ˤơTA_INHERIT°Υߥ塼ƥåԤ塼ϥͥ
ٽǤ뤿ᡤǤ⤤ͥ٤ĥϡԤ塼Ƭ
Ǥ롥Ĥޤꡤ(2)ͥ٤뤿ˡԤ塼򥹥
󤹤ɬפϤʤ
**********************************************************************
