
		TOPPERS/FMPͥ
		߷ץ

		бС: Release 1.2.0
		ǽ: 2010ǯ725ʺ

ΥɥȤϡTOPPERS/FMPͥ߷ץǤ롥ΤΤ
ꡤŪǤϤʤ

----------------------------------------------------------------------
 TOPPERS/FMP Kernel
     Toyohashi Open Platform for Embedded Real-Time Systems/
     Flexible Multiprocessor Profile Kernel

 Copyright (C) 2005-2009 by Embedded and Real-Time Systems Laboratory
             Graduate School of Information Science, Nagoya Univ., JAPAN
 
 嵭Ԥϡʲ(1)(4)ξ˸¤ꡤܥեȥ
 ܥեȥѤΤޤࡥʲƱˤѡʣ
 ѡۡʰʲѤȸƤ֡ˤ뤳Ȥ̵ǵ롥
 (1) ܥեȥ򥽡ɤηѤˤϡ嵭
     ɽѾ浪Ӳ̵ݾڵ꤬Τޤޤηǥ
     ˴ޤޤƤ뤳ȡ
 (2) ܥեȥ򡤥饤֥ʤɡ¾Υեȥȯ˻
     ѤǤǺۤˤϡۤȼɥȡ
     ԥޥ˥奢ʤɡˤˡ嵭ɽѾ浪Ӳ
     ̵ݾڵǺܤ뤳ȡ
 (3) ܥեȥ򡤵Ȥ߹ʤɡ¾Υեȥȯ˻
     ѤǤʤǺۤˤϡΤ줫ξ
     ȡ
   (a) ۤȼɥȡѼԥޥ˥奢ʤɡˤˡ嵭
       ɽѾ浪Ӳ̵ݾڵǺܤ뤳ȡ
   (b) ۤη֤̤ˡˤäơTOPPERSץȤ
       𤹤뤳ȡ
 (4) ܥեȥѤˤľŪޤϴŪ뤤ʤ»
     ⡤嵭ԤTOPPERSץȤդ뤳ȡ
     ޤܥեȥΥ桼ޤϥɥ桼Τʤ
     ͳ˴Ťᤫ⡤嵭ԤTOPPERSץȤ
     դ뤳ȡ
 
 ܥեȥϡ̵ݾڤ󶡤ƤΤǤ롥嵭Ԥ
 TOPPERSץȤϡܥեȥ˴ؤơλŪ
 ФŬޤơʤݾڤԤʤޤܥեȥ
 ѤˤľŪޤϴŪʤ»˴ؤƤ⡤
 Ǥʤ
 
 @(#) $Id: design.txt 750 2010-11-30 05:54:57Z ertl-honda $
----------------------------------------------------------------------
======================================================================
ToDo
======================================================================
åȰ¸ɵͤ롥

======================================================================

======================================================================
ꥢ 
  R    : ꡼
  W    : 饤
  (I) : ͥ˥
  (E) : ͥ뽪λ˥

ROMǡ  : ͤѿROM֤뤳Ȥꡥ
RAMǡ  : ͤѿRAM֤뤳Ȥꡥ

======================================================================
ܼ
======================================================================
TOPPERS/FMPͥμ߷
ưƥ
ե졼
  OSΥåñ
  ԥåƥ
  ޥƥ
  ꥢƥ
饹 
  ǰ
  饹
ǡ¤
  
  ץåȥ֥åPCB
  ץåȥ֥åPCBˤؤΥ
  ।٥ȥȥ֥å(TEVTCB)
  ।٥ȥҡ
  ֥ȤΥȥ֥å
  ֥Ȥν֥å
  Ԥ֥å
RAMǡֻ
  ֥Ȥδ֥å
  ץåѿ
  ƥॵӥѤǡ
åñ̤߷
  
  ͥʬ
  åñ̤
  2ĥåμȼǥåɥåβ
åμ
  åڤؤ
  åѿε
  ɤεҤ
  åˤ꥽ɤκۤȯս
åؿʶ
  ץå¾ȥץå֤¾
  åΥޥ졼å
  åRUNNABLEå
  åؿǤPCBؤΥݥ󥿤μ
  åؿγ
  ƥॳǻѤåؿ
  åؿμ
åؿʥåȰ¸
  ߤȯ̵ͭΥå
  ƥȤưײ
  åؿʥåȰ¸ˤλ
  åؿʥåȰ¸ˤμ
ͥƥå
  ͥƥåڤؤ
  Х륿ȥå
  ͥƥåˤ꥽ɤκۤȯս
  Х륿ǥץåγ٥åΥݡȡ̤
ޥ졼
  ޥ졼󥷥ƥॳmig_tsk()ˤλ͸Ƥ
  ޥ졼󥷥ƥॳmig_tsk()ˤλͤγĥ
  ưȥޥ졼󥷥ƥॳmact_tskˤλ͸Ƥ
  mig_tsk()
  mact_tsk()
  ޥ졼ȯսter_tsk()/ext_tsk()
।٥ȥϥɥΥޥ졼
  ƥॳ
  ɲåǡ
  msta_cyc(ID cycid, ID prcid)μ
  [i]msta_alm(ID almid, RELTIM almtim, ID prcid)μ
TOPPERS/SMPͥɲä¾Ѥεǽΰ
  ԥåǽ
  ץåͭAPI
ԥåǽ
  ѹս
  ͥƥμ
  ߥ졼μ
ǥåɥå
  оݥƥॳ롦ؿ
  TCBؤɲåȥ
  ƥॳ롦ؿμ
ter_tsk()Ϣ
  ter_tsk()
  ter_tsk()Υȥ饤ε  

ؿʶ
  ɲäؿ
  ѹؿ
  ؿ
åȰ¸
  ץåIDvolatile
  CPUå֤ǸƤӽФؿ
ɵҤΥåݥ
  ץåͭǡؤΥ
  ƥॳǤPCBμ
  Ѥåؿ
  ena_int()/dis_int()γֹΥåΥߥ
¾
  åޥѹ
  оݤȤsus_tskΥ졼
  ʣΥԤ˴ؤα
  [i]mrot_rdq()ɬ


======================================================================
TOPPERS/FMPͥμ߷
======================================================================
TOPPERS/FMPͥʰʲFMPͥˤϡTOPPERS奫ͥδ
פȤʤTOPPERS/ASPͥʰʲASPͥˤޥץåĥ
ꥢ륿५ͥǤ롥

ʲǤϡASPͥμ߷ˤˤĤƽҤ٤뤬߷ˤȤ
ϢƤꡤΤʬΥǤʤʬ⤢롥

FMPͥμ߷פԤˤꡤASPͥ᤿ˤ˲äơ
ˤꤹ롥

(1) ͡ʥƥΥޥץåƥΥݡ

ޥץåƥΥƥ¿¿ͤǤꡤξư
OSϡΥƥͭѤưɬפ롥ޥ
ץåƥΥƥΥХꥨʲ˼

ץå
  2ץå
  3ץåʾ

ץå֤¾浡
  ¾̿
  ѥϡɥ
    Ʊ˺ǽ¾֡ʥåˤθĿ


  ץ饤١ȥ
    ΥץåΤߥǽʥ
  
    ץå饢ǽǤ뤬ΥץåΥ
      ®ʥ
  Х
    ץåƱ®٤ǥǽʥ


  ץåθ̤Υ
  ƥñΥ

ΥƥФƸΨΤ褤Ȥʤ뤿ᡤFMPͥ
ϡͥεǽʲΥХꥨȤ߹碌ʥե
졼ܡˤǽǤ롥

OSΥåñ
  㥤ȥå
  ץåå
  γ٥å

ԥåƥ
  ͥƥ
  ߥ졼

ޥƥ
  Х륿
  륿

ꥢƥ
  RAMǡֻ

ʤRAMǡȰۤʤꡤROMǡ֤Ϻ٤ꤷʤȤˤ롥
ϡƤΥץåץ饤١ȥ˥ԡĤȤƤ
뤫Ǥ롥ޤޥץåƥˤơRAMǡ
ƥåͭȤ뤿ˤϡʥҡȥå夬ɬ
ʤΤФơROMǡΥå̾ΥåǤ褤Τᡤ
¿ΥåȤˤROMǡΥåĤȤȤ롥

֥Ȥν֥å뤳ȤȤ롥֥
å(RAMǡ)ϡǡ־٤ֲǽȤ뤿ᡤ̤
ѿ롥


======================================================================
ưƥ
======================================================================
FMPͥϼΥƥΥޥץåƥư롥

(a)ƥץåǡץROMǡФơƱ쥢ɥ쥹ǥ
   ǽǤ뤳ȡ줾ΥץåʪŪʥ
   ꤬ۤʤäƤƤ⡤ƱƤݻƤФ褤

(b)ץå顤ƱΥɥ쥹ǥǽRAM뤳ȡ
   
(c)ƤΥץå顤ǤդΥץåФƳߡʥץå
   ߡˤȯǽǤ뤳

(d)ץå֤Ǥ¾ΤεĤ
    : test & set ̿ᡤ Mutexϩ

(e)ץå֤¾浡Ѥƥå2ĺǽǤ뤳
   2ĤΤߤξϥ㥤ȥåΤߥݡȲǽ
   ץå2+1ĺǽǤȥץåå򥵥ݡȲǽ
   åκĿ˾¤ʤȺγ٥å⥵ݡȲǽ

(f)ƥץåˡIDեȥ鼫ץåȽ
   ̲ǽǤ뤳ȡ


======================================================================
ե졼
======================================================================
FMPͥϰʲεǽΥХꥨʥե졼
ġ

----------------------------------------------------------------------
OSΥåñ
----------------------------------------------------------------------
OSΥɡʼ˥ƥॳˤ¹Ԥݤ˥ץå֤¾Ūʼ
Ԥɬפʲս¾椹뤿Υåñ̡åñ̤γ٤
ȼΥХإåɤϾʤ뤬¹Ԥ㲼롥
åñ̤γ٤٤ʣΥå뤿ᡤ¹ԥ
إåɤ礭ʤ뤬ץå֤μ¹Ԥ夹롥ʤ
ñ̤γ٤٤ˤϡƥॳˤäƤϡǥåɥå
Τˡ¹Ի֤üĹʤ礬롥Τᡤץå
ʤ2١ˤϡåñ̤ƤͭǤꡤץ
¿ʤˤĤơγ٤κ٤åͭǤ롥

㥤ȥå
 
ƥ1ĤΥåġƤΥƥॳ༡Ū˼¹Ԥ롥

ץåå

ץå˥åȥ֥ȥåġϤ줫
ΥץåΥå˴ϢŤ졤ʳΥ֥ȤϤ
줫Υ֥ȥå˴ϢŤ롥ۤʤץåΥå
ϢŤ줿֥ȤФ륷ƥॳϤߤƶͿ
˼¹ԲǽǤ롥

γ٥å

ץå˥å򡤥֥˥֥ȥåġ
Ϥ줫ΥץåΥå˴ϢŤ졤ʳ
֥ȤϤ줾Υ֥ȥå˴ϢŤ롥ۤʤ
˴ϢŤ줿֥ȤФ륷ƥॳϤߤƶͿ
˼¹ԲǽǤ롥

----------------------------------------------------------------------
ԥåƥ
----------------------------------------------------------------------
FMPͥǿƳ줿ԥåǽμ¸ˡ

ͥƥ

åȥץå¾浡ǽCAS,Test&Set̿,LL/SC,Mutex
ϩˤľѤԥåο¾浡ǽɬפȤʤ롥

ߥ졼

¾ΥƥॳƱͤOSΥåѤƼ¸

----------------------------------------------------------------------
ޥƥ
----------------------------------------------------------------------
ƥδˡ

Х륿

ƥñΥƥѤ롥ϡɥޤ1ĻѤ
޳ߤμդȥƥιñΥץåԤ
ΥץåϥƥץåȸƤӡŪ˷ꤹ롥
٥ȥϥɥϡƥץåǤΤư롥

륿

ƥץåΩƥѤ롥ϡɥޤϥץ
åĿʬɬפȤʤꡤ줫Υץå˴ϢŤ졤Υץ
åΥƥ򹹿뤿ΤѤ롥

----------------------------------------------------------------------
ꥢƥ
----------------------------------------------------------------------
֥ȤΥȥ֥å䥿åRAMǡ
λ꤬ǽˡϡҤ륯饹䡤åȰ¸Υ
졼ƥץ졼ȥեtarget.tf롥

----------------------------------------------------------------------
ե졼Ȥ߹碌
----------------------------------------------------------------------
ʲΥե졼Ȥ߹碌ƻԲǽǤ롥

ޥƥΥХ륿OSΥåñ̤Υץ
  åγ٥å

ԥåƥΥߥ졼ȡOSΥåñ
  ̤κγ٥å

======================================================================
饹
======================================================================
----------------------------------------------------------------------
ǰ
----------------------------------------------------------------------
νդץåOSѤRAMǡ־λΤ
ˡ饹γǰƳ롥

 ƥˤʣΥ饹Ƥ롥
 ֥ȤϤ줫Υ饹°ɬפ롥
 ֥Ȥ°륯饹Ū˻ꤹ(ưŪѹǤʤ)
 饹IDʿ͡ˤǼ̤롥

饹˰ʲƤƤ롥ϥåȰ¸Υ
ե졼ƥץ졼ȥեtarget.tf롥

դץå
դǽץåʣΥץåǽդץ
    ޤ
ƥ֥ȤΥȥ֥å־
¾ɬפʥΰʥΥåΰǡ塼Υǡ
    塼ΰʤɡˤ־
¾δʥåñ̤ʤɡ

֥Ȥ°륯饹λϡե졼եǥ
饹ΰϤߤ˥֥  ȤŪAPI򵭽Ҥ뤳Ȥǻꤹ롥

   CLASS(<饹ID>){
      CRE_TSK(TASK1, .....);
      CRE_SEM(SEM1, ....);
   }

----------------------------------------------------------------------
饹
----------------------------------------------------------------------
饹ϡåȰ¸Υե졼ƥץ졼ȥե


 NUM_CLASS : 饹

饹ƤϡåȰ¸Υե졼ƥץ졼ȥ
ǡϢƥ饹ƤIDбϢ
Ǥꤹ롥

 CLASS_AFFINITY_INIT
   դץå
 CLASS_AFFINITY_MASK
   ޥ졼ǽʥץåΥޥ
   0ӥåȤINDEX0Υץåб"1"ǥޥ졼ǽ
 CLASS_OBJ_LOCK
   ץååξ˻Ѥ륪֥ȥå

ƥ֥ȤΥȥ֥å䤽¾ɬפʥΰ־
ϡkernel_cfg.c Τ줾ΥΰѤδؿ
ƤӽФ뤿ᡤ˵Ҥ롥

target_kernel.hǡ饹IDֹ򥯥饹̾Υޥ롥


======================================================================
ǡ¤
======================================================================
----------------------------------------------------------------------

----------------------------------------------------------------------
ASPͥǥХѿȤƤ륫ͥѿ¿
ϡFMPͥǤϥץåΩѿȤƻɬפ롥
ѿϡХإåɤҤΥ֤θơ
ץåι¤ΤȤƤޤȤ롥

RAMǡ˴ؤƤϡꥢƥФƼκŬǽ
褦߷פ롥ŪˤϡǤϤʤġѿȤ줾
־ǽȤ롥

----------------------------------------------------------------------
ץåȥ֥åPCB
----------------------------------------------------------------------
ץå˻ѿݻ빽¤ΤǤꡤkerflg, p_runtsk, 
p_schedtsk ޤޤ롥

ˤ顤kernel_cfg.c ǥץå˰ۤʤѿȤ롥
ƥץåPCB򥢥뤿ᡤPCBΥݥ󥿤 
kernel_cfg.c (p_pcb_table[])
  
    PCB _kernel_prc1_pcb;
    PCB _kernel_prc2_pcb;

    PCB* const p_pcb_table[TNUM_PRCID] = {
      &_kernel_prc1_pcb,
      &_kernel_prc2_pcb
    };
 
ޥ졼ΥݡȤΤᡤTCB/CYCCB/ALMCBPCBΥݥѿ
ФȤƻդƤץåPCBؤΥݥ󥿤Ͽ
롥PCBΥݥѿƤϡñ̤ޥ졼˽񤭴
뤿ᡤRAMǡȤƻġ

åȰ¸ǥץå˻ĥǡ¤ TPCB ȤƤޤȤᡤ
PCBΥСȤ롥ǥѥåǤϡPCBΥǡȥå
¸ǥץå˻ĥǡؤΥƱߥ󥰤ȯ
ǽ뤿ᡤPCBΥСȤ֤Ȥ㤯
ǽ뤿Ǥ롥

PCBƤȥϡΤ褦ˤʤäƤ롥

ץåID
  ѿ
    ID  prcid;
  
    ץå : R/W(I)
    ¾ץå : R
    å   : ɬפʤ

   񤭹ߤϡư˼ץåΤ˹Ԥ
   ROMǡȤƻĤȤǽѿʤᡤ
   RAMǡȤƤ롥
     
ͥư֥ե饰
  ѿ
   bool_t  kerflg;
  
    ץå : R/W(I/E)
    ¾ץå : -
    å   : ɬפʤ

   ץåΤߤOSεưλѹͥư
   ϻȤΤߡ
   OSεưλλͤǤϡХ1ĤȤƤʤ
   ξ硤ޥץå񤭹ߤԤ

å
 ѿ
    LOCK  tsk_lock;
 
    ץå : R/W
    ¾ץå : R
    å   : ɬפʤ

   ͥ뵯ư˽ɤ߹ߤϥåȯ񤭹ߤϥ
   åȰ¸ˤäƤȯ롥

֥ȥå
 ѿ
    LOCK  obj_lock;
 
    ץå : R/W
    ¾ץå : R
    å   : ɬפʤ

   ͥ뵯ư˽ɤ߹ߤϥåȯ񤭹ߤϥ
   åȰ¸ˤäƤȯ롥

1ܤμΥå
 ѿ
   LOCK *p_firstlock;
 
    ץå : R/W
    ¾ץå : -
    å   : ɬפʤ

2ܤμΥå
 ѿ
   LOCK *p_secondlock;
 
    ץå : R/W
    ¾ץå : -
    å   : ɬפʤ

¹Ծ֤Υ
 ѿ
   TCB  *p_runtsk;
 
    ץå : R/W
    ¾ץå : R
    å   : ɬפʤ
     
   񤭹ߤϥǥѥåΤߤǹԤ¾ץåɤ߹ߤϡ
   ref_tsk()ǤΤ߹ԤäƤ롥

ǹ̤ͥΥ
 ѿ
  TCB  *p_schedtsk;
 
    ץå : R/W
    ¾ץå : R/W
    å   : ɬפ

ǥѥå㳰롼ư׵ե饰
 ѿ
   bool_t  reqflg;
 
    ץå : R/W
    ¾ץå : -
    å   : ɬפʤ

   åɬפʤ¾ΥǡƱ˥Ƥ뤿ᡤ
   åϼƤ롥
   ¾Υץå˥ǥѥå׵᤹ϡоݥץåΥץ
   åֳߥϥɥ reqflg  true 뤿ᡤ¾Υץå 
   reqflg 򥢥뤳ȤϤʤ

ǥѥåػ߾
 ѿ
   bool_t  disdsp;
 
    ץå : R/W
    ¾ץå : -
    å   : ɬפʤ

   åɬפʤ¾ΥǡƱ˥Ƥ뤿ᡤ
   åϼƤ롥

ǥѥåǽ
 ѿ
   bool_t  dspflg;
 
    ץå : R/W
    ¾ץå : R
    å   : ɬפ

ԥåƤ뤫
 ѿ
   ID  locspnid;
 
   ץå : R/W
   ¾ץå : -
   å   : ɬפʤ
   
ǥ塼
 ѿ
   QUEUE  ready_queue[TNUM_TPRI];
 
   ץå : R/W
   ¾ץå : R/W
   å   : ɬפ

ǥ塼ΤΥӥåȥޥå
 ѿ
   uint16_t ready_primap;
 
   ץå : R/W
   ¾ץå : R/W
   å   : ɬפ

।٥ȥȥ֥åؤΥݥ
 ѿ
   TEVTCB   *p_tevtcb;
 
   ץå : R/W(I)
   ¾ץå : R
   å   : ɬפʤ

   ͥ뵯ư˽

åȰ¸Υץåȥ֥å
 ѿ
   TPCB  target_pcb;
 
   åȰ¸

----------------------------------------------------------------------
ץåȥ֥åPCBˤؤΥ
----------------------------------------------------------------------
ñ̤¹ԤƤץåPCBؿ get_my_p_pcb() 
ȤơΥץåPCBؿ get_mp_p_pcb(prcid) Ȥ
Ѱդ롥ƥॳǤϡPCBؤΥݥ󥿤ѿ 
my_p_pcb ¸ơѿͳƥץåͭΥǡإ
롥δؿǤpcbμϡŬоݤȤʤʤ褦ˤ
롥

get_my_p_pcb() ϶ǡx_prc_index() ѤƥץåINDEX
PCBΥɥ쥹륤饤ؿȤ롥åȰ¸
ŬȤơPCBΥɥ쥹ľݻ쥸ѰդơΥ
򥢥ˡǽȤ롥ΤˤϡOMIT_GET_MY_PCB 
ȡ get_my_p_pcb() ̵ȤʤꡤåȰ¸ǡ
get_my_p_pcb() ǽȤ롥

㤨СMPCore¸ξϡPCBΥɥ쥹CP15 Thread ID 쥸
ꤹ뤳Ȥͤ롥Nios II ξϡcpuid 쥸ƱPCB
Υɥ쥹ꤹˡͤ롥

----------------------------------------------------------------------
।٥ȥȥ֥å(TEVTCB)
----------------------------------------------------------------------
।٥Ȥ˴Ϣǡ¤(systime_offset, current_time)
ޤƤ빽¤Ρ륿ξϥץå롥
Х륿ξ1롥Ŀۤʤ
ᡤPCBȤ̤ι¤ΤȤΥݥ󥿤PCBϿ롥

ƥץåΥ।٥ȥȥ֥å˥뤿ᡤ
।٥ȥȥ֥åؤΥݥ󥿤 kernel_cfg.c 
(p_tevtcb_table[])

   TEVTCB   _kernel_prc1_tevtcb;
   TEVTCB   _kernel_prc2_tevtcb;

   TEVTCB* const _kernel_p_tevtcb_table[TNUM_PRCID] = {
         &_kernel_prc1_tevtcb,
         &_kernel_prc2_tevtcb
   };

p_tevtcb_table[]ϥͥ뵯ưνѤꡤ
ͥ뵯ưPCBͳǥ롥

।٥ȥȥ֥åƤȥϡΤ褦ˤʤä
롥

।٥ȥȥ֥å

ߤΥƥ
  ѿ
    EVTTIM current_time;
  
    ץå : R/W
    ¾ץå : R
    å   : ɬפ

ΥƥåΥƥ
  ѿ
    EVTTIM next_time;
  
    ץå : R/W
    ¾ץå : R
    å   : ɬפ

ƥѻѿ
  ѿ
    uint_t next_subtime
  
    ץå : R/W
    ¾ץå : R
    å   : ɬפ

ƥ郎̤Ǥ뤳Ȥ򼨤ե饰
  ѿ
    bool_t pend_update
  
    ץå : R/W
    ¾ץå : R
    å   : ɬפ

।٥ȥҡפκǸλΰΥǥå
  ѿ
    uint_t last_index
  
    ץå : R/W
    ¾ץå : R/W
    å   : ɬפ

।٥ȥҡפؤΥݥ
  ѿ
    TMEVTN *p_tmevt_heap;
  
    ץå : R/W(I)
    ¾ץå : R
    å   : ɬפʤ

----------------------------------------------------------------------
।٥ȥҡ
----------------------------------------------------------------------
।٥ȥҡפˤϡTEVTCB ȤΩơΥݥ󥿤 
TEVTCB Ͽ롥।٥ȥϥɥϥޥ졼ǽǤ
ᡤ।٥ȥҡפΥϡƥƤΥ।٥
ϥɥϿǽʥȤ롥դǽץåξѤƺ
Ŭ뤳ȤϲǽǤ롥

।٥ȥҡפΥϡΤ褦ˤʤäƤ롥

।٥ȥҡ
  
    ץå : R/W
    ¾ץå : R/W
    å   : ɬפ

----------------------------------------------------------------------
֥ȤΥȥ֥å
----------------------------------------------------------------------
ˤ顤֥˸̤ѿȤ롥IDֹ椫饳ȥ
֥å뤿ˡ֥Ȥμˡƥ֥ȤΥ
ȥ֥åؤΥݥ󥿤Ͽơ֥ʥơ֥롤ROM
ǡˤ롥

   TCB _kernel_tcb_TASK1_1;
   TCB _kernel_tcb_TASK1_2;

   TCB* const p_tcb_table[TNUM_TSKID] ={
    	&_kernel_tcb_TASK1_1,
    	&_kernel_tcb_TASK1_2,
        ...
   }

----------------------------------------------------------------------
֥Ȥν֥å
----------------------------------------------------------------------
ROMǡǤ륪֥Ƚ֥åϡASPͥƱͤۤ
롥ޤñΤѿȤϡơ֥뤬
ɬפȤʤ뤬Υơ֥뤬ɬפȤʤΤϡΤߤǤ
ᡤ̵̤礭

----------------------------------------------------------------------
Ԥ֥å
----------------------------------------------------------------------
ASPͥǤϡWINFOWINFO_WOBJˤTMEVTB ϡå˳
ݤƤ롥ˡǤϡդ줿ץåΥץ饤١
ȥ˥å֤硤¾Υץå饢
ȤǤʤΤᡤFMPͥǤϡԤ֥åTCB˳
ݤ뤳ȤȤ롥

ASPͥǤϡ֥Ȥ।٥ԤǤʤϡWINFO
p_tmevtb NULLꤷƤԤ֥åTCB˳ݤȡ
NULLǤʤᡤTMEVTBcallbackNULL뤳Ȥˤꡤ
।٥ԤǤʤȤꤹ롥


======================================================================
RAMǡֻ
======================================================================
----------------------------------------------------------------------
֥Ȥδ֥å
----------------------------------------------------------------------
֥ȴ֥å˴ؤƤϥ饹ñ̤ǻꤹ롥֥Ȥ
򤵤˺٤ꤹ뤫ϡåȰ¸Ȥ롥
ϥåȰ¸Υե졼ƥץ졼ȥե
target.tf롥

----------------------------------------------------------------------
ץåѿ
----------------------------------------------------------------------
ץåѿϥåȰ¸Υե졼ƥ
졼ȥեtarget.tf롥

֥Ȥδ֥åλȶˡkernel_cfg.c ˡ
ե졼ƥץ졼ȥեkernel.tfˤ顤RAMǡ
Τ˴ؿƤӽФ뤿ᡤδؿޤ᤿Ԥ
ܺ٤ porting.txt 򻲾ȤΤȡ

----------------------------------------------------------------------
ƥॵӥѤǡ
----------------------------------------------------------------------
ƥॵӥʥꥢɥ饤СˤѤǡ
־λФƤϡtarget_syssvc.h ǻꤹ롥typeˤϷ
variableˤѿ̾Ϥ롥

 
   SEC_PRC1_LOGTASK(type, variable)
   SEC_PRC2_LOGTASK(type, variable)
     ...

 ꥢ륤󥿥եɥ饤ФѤѿ
   SEC_SERIAL1(type, variable)
   SEC_SERIAL2(type, variable)
     ..

 ƥǽѤѿ
   SEC_PRC1_SYSLOG(type, variable)
   SEC_PRC2_SYSLOG(type, variable)
     ..


======================================================================
åñ̤߷
======================================================================
----------------------------------------------------------------------

----------------------------------------------------------------------
Ǥ礭ʥåñ̤ϥƥΤǰĤΥåѤˡʥ㥤
ȥåˤǤ뤬ˡǤϤߤ˴Ϣʤ˳Ƥ
ץåФ륹ӥƥݤǤʤޤå
ޤǤλ֤˾¤ʤå르ꥺѤϡꥢ륿
ʤ롥㤨Хץå1ȥץå2Ǥ줾ץå
Ĥ֥å򤷤ƤǤ⡤åˤꡤߤ
μ¹Ԥ˳ƤޤΤᡤʤȤƥץåΥåñ̤
̡ˤ٤롥ϼץåΥ֥¾Υץ
ν˳٤ǤϤʤǤ롥ʤ顤ޤ٤γ
٤ǥåñ̤ꤷƤޤȡåΥͥʿ¿ʤꥪ
Сإåɡʺǰǽˤ礷Ƥޤ

ޤǤ¿βսǥåμˤʤ褦˥åñ
̤ꤹɬפ롥ˤꡤǥåɥåɬפʥƥॳ
Ǿ¤ˤ롥㤨ХåA,Bꡤ륿AåA->B
Ǽ¾ΥåB->AνǼȡǥåɥå
ȯ뤿ᡤƥǥåμᡤΤޤޤǤϡ
᤿ǥåʤս˴ؤƤϡǥåȥåΤ
ä롥

ߤνǤϥåʤȤ롥ߤǥå
ȡåޤǤλ֤˾¤ʤå르ꥺѤ
硤ߤα֤ξ¤ޤʤʤäƤޤ

ߤνи˴ؤƤϡåλγ߱㲼ʤ
ˤϡåλԤȳߤεĤ򷫤֤Ƽ¹Ԥɬפ롥
ʤ顤ߤνиǤϳߤĤǤʤåȤ¿ᡤ
߶ػ߻֤ξ¤ʤʤ롥

FMPͥǤϡOSˤ륿Υץåؤμưդ򥵥ݡȤ
ʤᡤߤǤϡåˤ¾椬ɬפʥǡ¤˥
ɬפϤʤߤνи˴ؤƤϡߤνиǥǥѥ
ɬפǤʤϡåˤ¾ɬפʤǥѥ
ɬפʾϡǥѥåå֤Ǽ¹ԤʤФʤ
Ȥȡåɬפ롥ǥѥåå
Ǽ¹Ԥ٤ϥޥ졼ξϤǵ롥

----------------------------------------------------------------------
ͥʬ
----------------------------------------------------------------------
åñ̤ꤹ뤿ᡤASPͥޥץåĥˡ
ͥζͭǡ¤ȡФ륢ѥ
롥

ͥμʥǡ¤ȤơΤΤġ

  ȥ֥åTCB
  ǥ塼
  ֥ȤΥȥ֥å
  ޥ٥ȥ塼

ƥƥॳѿǤΤΥǡ¤Ф륢ѥ
ϡΤ褦ʬǤ롥

a˥Ф̾
  оݤΥʤޤϼˤTCBӥǥ塼Τߤ
  TCBȥǥ塼Τɤ餫ʤޤˡ

b˥Фü
  оݤΥTCBӥǥ塼ȡΥäƤ
  Ʊ֥̿ȤΥȥ֥å򥢥롥
  ͤΥХꥨˤäƤϡƱ֥̿Ȥä
  ¾ΥTCBȥǥ塼⥢롥

c Ʊ֥̿ȤФñ
  оݤƱ֥̿ȤΥȥ֥åΤߤ򥢥
  롥

dƱ֥̿ȤФԤȼ
  оݤƱ֥̿ȤΥȥ֥å򥢥
  ɬפʾʼԤˤˤϼTCBӥ
  ǥ塼⥢롥

eƱ֥̿ȤФ륿Ԥȼ
  оݤƱ֥̿ȤΥȥ֥åȡΥ
  ֥ȤԤäƤ륿СTCBӥǥ塼
  롥

f˥।٥ȥ塼Ф

gPCBΤߤФ

hˤ¾
  Υǡ¤򥢥ʤ

ƥॳڤѿФƤʬԤädesign.xlsΥ
ѥΥȤ򻲾ȡˡ

TCBȥǥ塼Ʊ˥礬¿Ȥ狼äᡤ
TCBȥǥ塼Ʊåñ̤뤳ȤȤޤޥ
ȥ塼򥢥ˤϡTCBǥ塼ˤ⥢
礬¿ᡤޥ٥ȥ塼TCBǥ塼Ʊåñ
뤳ȤȤΥåñ̤򥿥åȸƤ֡

Ʊ֥̿ȤΥȡ֥åФåñ̤TCB
ǥ塼ޤåñ̤Ȥ̤ˤ롥Υåñ̤򥪥֥
åȸƤ֡åȥ֥ȥåξɬפΤ
ˤϡʡbˡdˡeˡˡǥåɥåΤᡤåñ̤μ
դ˷ʤФʤʤå֥ȥåν
åbˤΥƥॳꡤ֥ȥå
åνǼdˡeˤΥƥॳ뤬¿(b)Υƥॳ
٤㤤ȹͤ뤿ᡤ֥ȥåå
νǼ뤳Ȥ§Ȥ롥ΤᡤbˤʬΥƥॳ
μ˺ݤƤϡǥåɥåλȤߤɬפ롥

ǥåɥåɬפʥƥॳؿϼ̤Ǥ롥

 ext_tsk
 ter_tsk
 chg_pri
 rel_wai
 irel_wai
 make_non_waitؿ
 wait_tmoutؿ

----------------------------------------------------------------------
åñ̤
----------------------------------------------------------------------
ҤεǤϡץå˥åȥ֥ȥå
åʿȥǥåɥåξʤŬڤȽҤ٤ʤ
顤2ץå٤ξϥ㥤ȥåǽʬʾ礬¿Ȥ䡤
ϡɥ¾浡¿ʤᡤ㥤ȥå
Ǥʤͤ롥ǡFMPͥǤ3Υåñ
ǽȤ롥

ƥñΥåѤ򥸥㥤ȥåȸƤ֡

ͥʬϤ顤㥤ȥåμγ٤٤åñ̤Ȥ
ơåȥ֥ȥåץå˻ĥåñ̤
ѤץååȸƤ֡

ˡ֥ȥå˴ؤƤϡġΥ֥Ω
֥ȥåͤ졤γ٥åȸƤ֡
å˴ؤƤϡϢΥǡ¤륷ƥॳ
¿ϡǥ塼뤿ᡤ˥åĤ褦˺ʬ
ȤƤ⡤ǥ塼ΤΥåɬפȤʤꡤ¹ԥХإå
ä뤬ϸ夷ʤͽۤ롥Τᡤγ٥å
Ǥ⡤åϥץå˻ĤȤ롥

----------------------------------------------------------------------
2ĥåμȼǥåɥåβ
----------------------------------------------------------------------
ץåγ٥åξ硤䥿।٥ȥϥɥΥ
졼κݤˤϡޥ졼󸵤ȥޥ졼2Ĥ
åƱ˼ɬפ롥κݡǥåɥå򤹤
ᡤץåIDξץåΥå뤳Ȥˤ
롥


======================================================================
åμ
======================================================================
----------------------------------------------------------------------
åڤؤ
----------------------------------------------------------------------
åȰ¸ target_config.h ǡޥ TTYPE_KLOCK  G_KLOCK
ʥ㥤ȥå/P_KLOCKʥץåå/F_KLOCKʺ
γ٥åˤΤ줫롥

----------------------------------------------------------------------
åѿε
----------------------------------------------------------------------
åѿ˳ǼƤϡåȰ¸Ǥ롥CAS,Test&Set,LL/SC
ä̿ľϡľܥåΤΰȤƻȤѲϩ
ϡɥ쥹Ǽ뤳ȤꤷƤ롥åѿη
ؿϡåȰ¸롥

㥤ȥå
  ХѿȤƳݡ

ץåå
  å 
    PCB˳ݡTCBPCBؤΥݥ󥿤ǼơTCBͳǥ
  ֥ȥå
    PCB˳ݡƥ֥Ȥν֥å˥֥ȥå
      ؤΥݥ󥿤ݻΰѰա

γ٥å
  å 
    PCB˳ݡTCBPCBؤΥݥ󥿤ǼơTCBͳǥ
  ֥ȥå
    ƥ֥ȤΥȥ֥å˳ݡ

----------------------------------------------------------------------
ɤεҤ
----------------------------------------------------------------------
ɤϡγ٥å˵Ҥ롥åʬϴ
ȤƴؿϥåΤ֥ȥå
ΤܤΥåμʤΤʬ롥

ǥåɥåɬפʥƥॳǤϡåˤäơ
ˡ礭Ѥ롥ξˤϡθơƥॳñ̤
ifdefڤؤ롥

----------------------------------------------------------------------
åˤ꥽ɤκۤȯս
----------------------------------------------------------------------
ƥ֥Ȥν֥å
  ץååξ硤åѿؤΥݥ󥿤Ǽѿ

ƥ֥Ȥδ֥å
  γ٥åξ硤åѿݤ롥

ƥ֥Ȥν롼
  γ٥åξ硤åѿ

åؿ
  㥤ȥåȡץåγ٥åǰۤʤ롥

֥ȥåޥGET_OBJLOCK
  㥤ȥå : 㥤ȥå֤
  ץåå   : PCBΥ֥ȥå֤
  γ٥å       : ƥ֥ȤΥȥ֥å
                             ֥ȥå֤

ץåȥ֥åPCB
  ץåå : åȥ֥ȥå
  γ٥å     : å
  ץååȺγ٥å : Υåεΰ
                                         p_firstlock, p_secondlock

㥤ȥåѤΥåѿ
  㥤ȥåξ

֥åTCB
  ץåγ٥åξ硤ǥåɥåѤѿ3
    ɲä롥

ǥåɥåɬפʴؿ
  ץåγ٥åξϡǥåɥåԤ
    Ȥ롥


======================================================================
åؿʶ
======================================================================
----------------------------------------------------------------------
ץå¾ȥץå֤¾
----------------------------------------------------------------------
ƥॳμ¹Ԥˤϡץå֤Ǥ¾ȡץåǤ
¾椬ɬפȤʤ롥FMPͥǤϡԤҤΥåʥԥ
ˤǸԤϳ߶ػߤǼ¸롥

Ĥ¾Ϥߤ˴ϢƤꡤꥢ륿ݤ뤿
ˤŬڤ˰ʤФʤʤ㤨СåμȳߤζػߤȤ
˼¹Ԥȡåμȳߤζػߤδ֤˳ߤꤽ
դǽ롥ߤդȡåƤ뤿ᡤ
ߤդƤ֤¾ΥץåԤƤޤץå
Ф륹ӥƥݤǤʤߤػߤƥåμ
ߤȡåμߤ֡ߤػߤȤʤäƳ߶ػ߻
֤ĹʤäƤޤΤ褦ˤɤ˼¹ԤƤ꤬ȯƤ
ޤŪʼ¸ˡĤƱå뤳ȤǤ뤬1̿ǥ
μȳߤζػߤԤץå¸ߤʤᡤ¸Ϻ
롥

ƤơʺѸ

FMPͥǤϡޤߤػߤƤ顤åμߤ롥
ơåμߤ뤿Ӥˡʥåμߤ̥å
ʤäˡˡ׵å׵᤬С
ĤƳߤդ롥

ߤ˶ػߤ뤳Ȥˤꡤåޤ޳ߥϥɥ
Ԥ뤳Ȥɤåμߤ뤿Ӥ˳׵å뤳
Ȥˤ߱ΰɤǤ롥

 retry:
    /* (1) ֥ȥåμ */
    disable_interrupt();
    while(!test_and_set(obj lock)){
        /* åǤĳߤȯ */
        /* Сߤդθ retry */
        /* Ƴ */
        if(interrupt_request()){
            enable_interrupt();
            goto retry;
        }
     }
     /* (2) βսΥɤϷ֤¹Ԥǽ */
     /* 뤿ᡤͥΥǡѹ */
     /* Ϥʤʤ */
     ...
     /* (3) åμ */
     while(!test_and_set(tsk lock)){
         if(interrupt_request()){
             /* åǤĳߤȯ */
             /* Х֥ȥå */
             /* ߤդθ retry Ƴ */
             release_lock(obj_lock);
             enable_interrupt();
             goto retry;
          }
     }
     /* (4)Critical Section */
     ...

----------------------------------------------------------------------
åΥޥ졼å
----------------------------------------------------------------------
ƥॳ¹Ԥκݤ˥åɬפ뤬ΥХꥨ
ϴĤʬव롥ΤΥ˴ϢŤ줿
åˤϡTCBϿ줿PCBΥåѤѿѤƥ
å롥FMPͥϥ䥿।٥ȥϥɥΥ
졼򥵥ݡȤƤ뤿ᡤåȤƤ⡤μ
λоݤΥ䥿।٥ȥϥɥ餬ޥ졼󤹤
ǽ롥ޥ졼ȯȡåۤ
ץåФΤȤʤ뤿ᡤåμľɬפȤʤ롥ʲ
ǤϡƥХꥨˤĤơåΥޥ졼Υ
ɬ̵ͭˤĤƤޤȤ롥

ƥȤ鼫Υåμ

ΥåϡʲξȤǡ
Υޥ졼Υåɬפʤʤ롥

  CPUå֤ǥץåIDơPCBإå٤
  å롥

FMPͥΥޥ졼ˤꡤƱץå˳դ
Ƥ륿Τߥޥ졼ǽǤ롥ΤᡤCPUå
Ȥˤϡޥ졼󤵤뤳ȤϤʤᡤ嵭ξˤ
åμΥޥ졼Υåɬפʤʤ롥

ȡCPUå֤ǼץåIDϥޥ졼
ˤ̵ȤʤäƤǽ롥

¸ΥåؿǳߤĤȤϡ
Υåˤ⡤Υޥ졼Υå
ɬפȤʤ롥

ƥȤǤեʼޤˤΥå

ǤեʼޤˤΥåϡå塤
ݥޥ졼󤷤Ƥ뤫åɬפ롥

åˡϡå˻ѤPCBȡåTCBϿ
ƤPCBƱǤ뤫ˤȽǤ롥

ƥȤܤΥåȤƥå

åܤΥåȤƼ硤åˡޥ
졼ȯƤʤåɬפ롥ϡmig_tsk
ơ֥ԤΥޥ졼󤹤ݤˡ֥
ȥåϼåΤߤƥޥ졼»ܤ
뤿Ǥ롥

դˡmig_tskǥޥ졼оݤΥ֥Ԥξ硤
֥ȥå褦ˤСܤΥå˥ޥ
졼Υåɬפʤʤ롥ʤ顤mig_tsk˥ǥåɥ
롼ꡤter_tskƱͤ˽ԤǤʤᡤ»
֤ޤʤʤ롥

¾˥ޥ졼ȯAPIȤƤϡmact_tsk / imact_tsk / 
ext_tsk / ter_tsk 뤬mact_tsk/imact_tskϡԤ֤Υ
Ƥϡ塼󥰥ӥåȤ򥻥åȤǤΤʤext_tsk
ϡ¹Ծ֤ǤΤ߸ƤӽФ뤿ᳺʤter_tskϡ֥
åȥå뤿ʤ

åޥǤΥޥ졼ΥåϷڤȸѤ뤿ᡤ
mig_tsk ǤΥ֥ȥåμϹԤʤ

󥿥ƥȤ鼫ץåΥåμ

ߥϥɥ䥿।٥ȥϥɥϼ¹˥ޥ졼󤵤
ȤϤʤᡤޥ졼Υåɬפʤ

󥿥ƥȤǤեΥåμ

ǤեΥåϡå塤оݥޥ
󤷤Ƥ뤫åɬפ롥

åˡϡå˻ѤPCBȡåTCBϿ
ƤPCBƱǤ뤫ˤȽǤ롥

----------------------------------------------------------------------
åRUNNABLEå
----------------------------------------------------------------------
CPUå֤Ȥƥå֤ˡ¾ΥץåΥˤ
ơSUSPEND֤ѹǽ뤿ᡤå
оݥξ֤åɬפ롥ƥॳʬ
"design.xls"RUNNABLEåΥȤ˼

ƥȤ鼫Υåμ

 PCB* t_acquire_tsk_lock_self(void);
 PCB* t_acquire_nested_tsk_lock_self(LOCK *p_objlock)
 
ΥåϡߤػߤƤ顤å
ޤǤδ֤¾Υץå˳դƤ륿顤
sus_tskȯԤ졤Ԥ֤Ȥʤǽ롥ξ硤API¹Ԥ
Ԥȡ礬ȯ뤿ʶԤ֤Ԥ֤ˤʤ..ˡ
å塤ξ֤RUNNABLEåɬפ롥
ξ֤RUNNABLEǤʤϡåưöߤĤ롥

ǥѥåػ߾֤ˤپ֡run-suspendˤΥ
ӽФǽʥƥॳ˴ؤƤ꤬ȯ롥Ūˤϡ
ξ֤RUNNABLEǤʤᡤRUNNABLEå˰äߤ
ĤƤޤǥѥåػ߾֤ʤΤǡߥϥɥνиǥǥ
ѥåȯꡤ̵¥롼פȤʤäޤᡤкɬפǤ롥

ƥȤ鼫ΥåμAPIϼ
̤Ǥ롥

ʬ
 ǥѥåػ߾֤ǸƤӽФʤAPI
 ǥѥåػ߾֤ǸƤӽФAPI
 
snd_dtq(ID dtqid, intptr_t data)
tsnd_dtq(ID dtqid, intptr_t data, TMO tmout)
rcv_dtq(ID dtqid, intptr_t *p_data)
trcv_dtq(ID dtqid, intptr_t *p_data, TMO tmout)
snd_pdq(ID pdqid, intptr_t data, PRI datapri)
tsnd_pdq(ID pdqid, intptr_t data, PRI datapri, TMO tmout)
rcv_pdq(ID pdqid, intptr_t *p_data, PRI *p_datapri)
trcv_pdq(ID pdqid, intptr_t *p_data, PRI *p_datapri, TMO tmout)
wai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN *p_flgptn)
twai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN *p_flgptn, TMO tmout)
rcv_mbx(ID mbxid, T_MSG **ppk_msg)
trcv_mbx(ID mbxid, T_MSG **ppk_msg, TMO tmout)
get_mpf(ID mpfid, void **p_blk)
tget_mpf(ID mpfid, void **p_blk, TMO tmout)
wai_sem(ID semid)
twai_sem(ID semid, TMO tmout)
rot_rdq(PRI tskpri)
dis_dsp(void)
ena_dsp(void)
call_texrtn(void)
dispatch_call_texrtn(void)
dis_tex(void)
ena_tex(void)
ext_tsk(void)
get_inf(intptr_t *p_exinf)
slp_tsk(void)
tslp_tsk(TMO tmout)
dly_tsk(RELTIM dlytim)
get_tim(SYSTIM *p_systim)

ǥѥåػ߾֤ǸƤӽФAPIϡپ֤ǸƤӽФ뤿ᡤ
ξ֤ѹʤᡤRUNNABLEåԤɬפʤ

ǡRUNNABLEåԤʤץåΥåؿ
ä롥

 PCB* t_acquire_tsk_lock_self_without_runnable_check(void);
 
ƥȤǤեʼޤˤΥåμ

¾оݤȤϡԤ֤Υ饷ƥॳȯ
Ԥ뤳Ȥˤʤ뤬ͥԲʬδʤ

⤽⡤Ԥ֤ΥƥॳȯԤ޻ߤˤϡ
ƤӽФƤΥƥॳˤơγդ줿ץ
åΥå褦ˤʤФʤʤ

оݤȤ⡤Ϥʤȹͤ뤬̤APIǳǧ
ɬפ롥

ref_tsk()ϡԤ֤ɤ߼ǽ뤿ᡤͽ
ref_tsk()ä롥

ɤξǤ⡤ƥॳ¹˶Ԥ֤ˤʤäƤư
ƥȤɬפǤ롥

----------------------------------------------------------------------
åؿǤPCBؤΥݥ󥿤μ
----------------------------------------------------------------------
ޥ졼θȡץåդ줿ץå
PCBؤΥݥ󥿤μϡCPUå֤ǹԤɬפ롥

ƥॳνˤơCPUå֤ȤʤΤϡå
Ǥ롥å˰öCPUå֤Ȥ뤬åλ
ԤˤƳ߱γݤΤ˳ߤĤ뤿ᡤλǼ
PCBؤΥݥ󥿤ϥåͭǤʤ礬롥

¾ץå˳դ줿դƤץåPCB
μ˴ؤƤϡåͭȤʤ롥Τᡤå˼
åоݥդ줿ץåΥåٳǧ
ɬפ롥

Τ褦ˡPCBΥݥ󥿤륿ߥ󥰤դɬפǤ뤿ᡤ
ߥڸ뤿ˡPCBؤΥݥ󥿤ϡƥॳǼ뤳
ȤϤåؿŬڤ˼åؿͤȤ
Ȥˤ롥ƥॳǤϡåؿäPCBؤΥݥ
Ѥ뤳ȤܤȤ롥

----------------------------------------------------------------------
åؿγ
----------------------------------------------------------------------
PCB*֤ΤϡåǤʤNULL򡤥åǤ
pcbؤΥݥ󥿤֤t_acquire_nested_dual_tsk_lock()Τߡ
bool_t֤åǤ false 򡤥å˳
äϡtrue ֤̾ nested ϡ2ܤΥåǤ뤳
Ȥ򼨤

ץåΥåμʥƥȡ
 PCB* t_acquire_tsk_lock_prcid(ID prcid)

ץåΥåμʥƥȡ
 PCB* t_acquire_tsk_lock_self(void);
 PCB* t_acquire_nested_tsk_lock_self(LOCK *p_objlock)
 
RUNNABLEåԤʤץåΥåμ
ʥƥȡ 
 PCB* t_acquire_tsk_lock_self_without_runnable_check(void);

ǤեʼޤˤΥåμʥƥȡ
 PCB* t_acquire_tsk_lock(TCB *p_tcb)
 PCB* t_acquire_nested_tsk_lock(TCB *p_tcb, LOCK *p_objlock)

Ǥե।٥ȥϥɥΥåμʥƥȡ
 PCB* t_acquire_tsk_lock_cyc(ALMCB *p_cyccb)
 PCB* t_acquire_tsk_lock_alm(CYCCB *p_almcb)

2ĤΥåμʥƥȡ
 void t_acquire_dual_tsk_lock(TCB *p_tcb, ID dstprcid, 
                                    PCB **pp_srcpcb, PCB **pp_dstpcb)
 void t_acquire_dual_tsk_lock_alm(ALMCB *p_almcb, ID dstprcid, 
                                    PCB **pp_srcpcb, PCB **pp_dstpcb)
 void t_acquire_dual_tsk_lock_cyc(CYCCB *p_almcb, ID dstprcid, 
                                    PCB **pp_srcpcb, PCB **pp_dstpcb)
 bool_t t_acquire_nested_dual_tsk_lock(TCB *p_tcb, ID dstprcid, LOCK *p_objlock,
                                    PCB **pp_srcpcb, PCB **pp_dstpcb)

ץåΥåμ󥿥ƥȡ
 PCB* i_acquire_tsk_lock_prcid(ID prcid)

ץåΥåμ󥿥ƥȡ
 PCB* i_acquire_tsk_lock_self(void)

ǤեΥåμ󥿥ƥȡ
 PCB* i_acquire_tsk_lock(TCB *p_tcb)
 PCB* i_acquire_nested_tsk_lock(TCB *p_tcb, LOCK *p_objlock)

Ǥե।٥ȥϥɥΥåμ󥿥ƥȡ
 PCB* i_acquire_tsk_lock_alm(ALMCB *p_almcb)

2ĤΥåμ󥿥ƥȡ
 void i_acquire_dual_tsk_lock(TCB *p_tcb, ID dstprcid, 
                                    PCB **pp_srcpcb, PCB **pp_dstpcb)
 void i_acquire_dual_tsk_lock_alm(ALMCB *p_almcb, ID dstprcid, 
                                    PCB **pp_srcpcb, PCB **pp_dstpcb)

ץꥨץ󤷤ʤץåΥåμ
 PCB* acquire_tsk_lock_without_preemption_self(void)

ץꥨץ󤷤ʤ2ܤΥåμ
 PCB* acquire_nested_tsk_lock_without_preemption(TCB *p_tcb)
 
ץꥨץ󤷤ʤ2ĤΥåμʥƥȡ
 void t_acquire_dual_tsk_lock_without_preemption(TCB *p_tcb, ID dstprcid, 
                                    PCB **pp_srcpcb, PCB **pp_dstpcb)

֥ȥåμʥƥȡ
 void t_acquire_obj_lock(LOCK *p_objlock)

֥ȥåμ󥿥ƥȡ
 void i_acquire_obj_lock(LOCK *p_objlock)

åֵѴؿ

åβ
 void release_tsk_lock(PCB *p_pcb);

åβ2ܡ
 void release_nested_tsk_lock(PCB *p_pcb);

2ĤΥåβ
 void release_dual_tsk_lock(PCB *p_srcpcb, PCB *p_dstpcb);

֥ȥåβ
 void release_obj_lock(LOCK *p_objlock);

----------------------------------------------------------------------
ƥॳǻѤåؿ
----------------------------------------------------------------------
ƥॳڤؿǻѤåؿ"design.xls"Υå
1.1.0ˤΥȤˤޤȤ롥

----------------------------------------------------------------------
åؿμ
----------------------------------------------------------------------
㥤ȥåȥץåγ٥åȤǤϡˡ
礭ۤʤ뤿ᡤifdef ǼڤؤƤ롥

㥤ȥåǤϡåؿμ2ܤΥå
ؿ˴ؤƤϤۤܶǤ뤫Ȥ顤¹ԸΨθƥ饤
ȤƼ롥ץåγ٥åǤϡޥ졼
å2ܤΥåǥåؿμ礭ᡤؿ
ȤƼ롥

åؿ

CPUå֤ǸƤӽФ롥åȰ¸δؿˤå
塤ɬפ˱ƥޥ졼åRUNNABLEåԤ
ޥ졼ǥå2ļˤϡǥåɥ
򤹤뤿ᡤץåIDξץåΥå
롥

2ܤΥåϡå1ܤΥåѿ򼫥ץ
åPCB p_firstlock Ͽ롥2ܤΥåμ NULL 
롥

åֵѴؿ

CPUå֤ǸƤӽФ롥åơCPUå֤Τޤޥ꥿
󤹤롥


======================================================================
åؿʥåȰ¸
======================================================================
----------------------------------------------------------------------
ߤȯ̵ͭΥå
----------------------------------------------------------------------
ŪʥåȰ¸Υåؿt_acquire_obj_lock() / 
t_acquire_tsk_lock() λͤϼ̤Ǥ롥

åǤfalse֤åʤСߤȯ
̵ͭåơߤȯƤСtrue ֤ߤ
ȯƤʤСåμٻߤ롥

ߤȯ̵ͭåǤʤåȤˤĤƤϡåμ
ޤǥåμ򷫤֤Ȥ1λԤη̡
Ǥʤtrue֤Τɤ餫򤹤뤳Ȥˤʤ롥

ߤȯ̵ͭåǤʤץåξ硤åμ
ޤǥåμ򷫤֤ȳ߱ʤꡤ1λԤ
̡åǤʤtrue֤ȡܤΥå뤳
ȤˤʤΤǡ롼ץåȤǽ롥

FMPͥ뤬ݡȤƤ륿åȤǡ㥪Хإåɤǳ
ȯǧ̵ͭǽϼΤ褦ˤʤäƤ롥

  NiosII    : ǽ
  MPCore    : Բǽ
  SHX-3     : Բǽ
  SH2A-DUAL : Բǽ

NiosII ˴ؤƤ⡤߽ǥμ¸ˡˤäƤϡͭʳ
ȽǤ㥪ХإåɤǼ¸Ǥʤʤǽ롥Τᡤ
ȯǧ̵ͭ㥪ХإåɤǲǽʥץåϰŪǤϤʤ
ȸ롥ΤᡤFMPͥǤϳߤȯ̵ͭ㥪Хإå
Ǽ¸ǤʤȤȤ롥

ߤȯ̵ͭȽʤץåˤơ߱ȥ
ץåȤݤ뤿ˤϼˡͤ롥

ޤץå˼å򵭲륰ХѿʼѤߥ
åѿˤѰդ롥1ܤΥåʥ֥ȥåˤ
ȡΥݥ󥿤Ѥߥåѿ¸롥2ܤΥå
롼ǤϡåμߡåǤФΤޤ޿ʤࡥ
åǤʤäϡöߤĤ롥ߥϥɥ
ƬǤϡѤߥåѿåơåƤ
ϡåơߥϥɥ¹Ԥ롥2ܤΥå
Ǥϡߤζػ߸塤Ѥߥåѿåơ1
ܤΥåƤʤ2ܤΥåκƻԤԤ1ܤΥ
åƤСtrue꥿󤹤롥

----------------------------------------------------------------------
ƥȤưײ
----------------------------------------------------------------------
ƥȤưײΤᡤåȰ¸ΥåϢδؿοϲǽʸ¤
ʤˤȤ롥

1.0.XǤϡåȥ֥ȥåϰۤʤ뷿ȤƤ뤬
ɬפϤʤƱηˤȡåϢؿο򸺤餻뤿ᡤƱ
LOCKˤ롥

----------------------------------------------------------------------
åؿʥåȰ¸ˤλ
----------------------------------------------------------------------
ޤǤˤˤꡤåȰ¸ΥåޥλͤϼΤ褦
롥

ƥ

void t_acquire_lock(LOCK *p_lock)
  1ܤΥåؿp_lockϤ줿å롥
  
bool_t t_acquire_nested_lock(LOCK *p_lock)
  2ܰʾΥåؿ
  p_lockϤ줿å롥åǤ
  false֤åǤʤСöߤ
  ػߤơץåPCBμѤߥåѿ
  åơNULLʤtrue֤

󥿥ƥ

void i_acquire_lock(LOCK *p_lock)
  1ܤΥåؿp_lockϤ줿å롥
  
bool_t i_acquire_nested_lock(LOCK *p_lock)
  2ܰʾΥåؿ
  p_lockϤ줿å롥åǤ
  false֤åǤʤСöߤ
  ػߤơץåPCBμѤߥåѿ
  åơNULLʤtrue֤

/󥿥ƥξ

void x_release_lock(LOCK *p_lock)
  p_lockϤ줿å롥

ߤĤʤåؿ

void x_acquire_lock_without_preemption(LOCK *p_lock)
 å˼ԤߤĤʤ
 set_flg/iset_flg/ini_xxxǥȥ饤Ǥʤ˻Ѥ 

----------------------------------------------------------------------
åؿʥåȰ¸ˤμ
----------------------------------------------------------------------
ץåȥ֥åPCB

   LOCK *p_firstlock  = NULL;
   LOCK *p_secondlock = NULL;

ߥȥ꡼

CPUå֤ˡp_firstlock/p_secondlockåơ
NULL ǤʤХå NULL Ȥ롥

ȥ꡼()
{
	....
	p_pcb = get_my_p_pcb(); 
	if (p_pcb->p_firstlock != NULL) {
		x_release_lock(p_pcb->p_firstlock);
		p_pcb->p_firstlock = NULL;
		if (p_pcb->p_secondlock != NULL) {
			x_release_lock(p_pcb->p_secondlock);
			p_pcb->p_secondlock = NULL;
		}
	}
	....
}

åȰ¸δؿ

Test&Setǽ(test_and_set())ĥåȤǤ㡥

void
t_acquire_lock(LOCK *p_lock)
{
	while (test_and_set(p_lock)) {
		t_unlock_cpu();
		t_lock_cpu();
	}
}

bool_t
t_acquire_nested_lock(LOCK *p_lock)
{
	PCB		*p_pcb;

	while (test_and_set(p_lock)) {
		t_unlock_cpu();
		t_lock_cpu();
		/* ޥ졼󤹤ǽΤǤPCB */
		p_pcb = get_my_p_pcb(); 
		if (p_pcb->p_firstlock == NULL) {
			return(true);
		}
	}
	return(false);
}

void
i_acquire_lock(LOCK *p_lock)
{
	while (test_and_set(p_lock)) {
		i_unlock_cpu();
		i_lock_cpu();
	}
}

bool_t
i_acquire_nested_lock(LOCK *p_lock)
{
	PCB		*p_pcb;

	while (test_and_set(p_lock)) {
		i_unlock_cpu();
		i_lock_cpu();
		/* 
		 * ޥ졼󤷤ʤᡤwhile˼¹ԤƤ褤
		 * 1ǥåȤ줿硤ΨΤǡǼ
		 */
		p_pcb = get_my_p_pcb();
		if (p_pcb->p_firstlock == NULL) {
			return(true);
		}
	}
	return(false);
}

void
x_release_lock(LOCK *p_lock)
{
	*p_lock = NULL;
}

void 
acquire_lock_without_preemption(LOCK *p_lock)
{
	while (test_and_set(p_lock));
}


======================================================================
ͥƥå
======================================================================
ͥƥåʥƥˤμ¸ˡȤơϡɥޤ
1ĻѤƥ1ĤΥƥѤ륰Х륿ȡ
ץåĿʬΥϡɥޤѤƥץåȼΥ
Ѥ롤륿򥵥ݡȤ롥

----------------------------------------------------------------------
ޥƥڤؤ
----------------------------------------------------------------------
륿ȥХ륿ڤؤϡtarget_kernel.h 
Ӥ饤󥯥롼ɤեˤơ륿
ͭˤϡTOPPERS_SYSTIM_LOCAL  Х륿ͭ
ˤϡTOPPERS_SYSTIM_GLOBAL 롥

Х륿ξ硤ƥץåID 
TOPPERS_SYSTIM_PRCID 롥

----------------------------------------------------------------------
ޥƥOSΥåñ
----------------------------------------------------------------------
Х륿Ǥϡ㥤ȥåΤߤ򥵥ݡȤ롥
ϡץåγ٥åξϤ˥।٥ȥȥ䥿
।٥ȥҡפ¾椬Ȥʤ뤫Ǥ롥Ūˤϡ
ץåΥץåå¾ԤȤȡ¾Υ
å˳դ줿Ԥ֤ˤʤˤϡå
ļɬפꡤ¾ȥɤζ̲ˤʤ뤿Ǥ롥

----------------------------------------------------------------------
ͥƥåˤ꥽ɤκۤȯս
----------------------------------------------------------------------
।٥ȥȥ֥å।٥ȥҡ
  Х륿
    ƥñ˻ġʥХˡ
  륿
    ץå˻

ץåȥ֥åPCBˤؤϿ
  Х륿
    ХΥ।٥ȥȥ֥å।٥ȥҡפϿ
  륿
    䥿।٥ȥϥɥ餬դ줿ץåλĥ
      ।٥ȥȥ֥åҡפϿ

Ԥ˻Ѥ륿।٥ȥȥ֥å।٥ȥҡ
  䥿।٥ȥϥɥ餬Ԥˤʤݤ˻Ѥ롥
  Х륿
    ХΥ।٥ȥȥ֥å।٥ȥҡ
  륿
    䥿।٥ȥϥɥ餬դ줿ץåλĥ
      ।٥ȥȥ֥åҡ

ϡɥޤδϢߥϥɥ
  Х륿
    ƥץåǤΤ߼¹
  륿
    ƥץåǼ¹

।٥ȥϥɥν
  Х륿
    ƥץåǤΤ߼¹
  륿
    ƥץåǼ¹

।٥ȥϥɥΥޥ졼ϢΥƥॳ
  Х륿
    Υ󥵥ݡȡE_NOSPT֤
  륿
    ݡ

ޥ졼mig_tsk()
  륿
    оݥԤξ硤ޥ졼ΥץåΥ
      ।٥ȥҡפ롥

ǽɾѥƥλȡget_utm
  Х륿
    Υ󥵥ݡȡʥѥ륨顼
  륿
    ݡ

----------------------------------------------------------------------
Х륿ǥץåγ٥åΥݡȡ̤
----------------------------------------------------------------------
ѥåѰդ롥signal_timeϡΥå롥

loop ॢȤʤХ꥿
ॢȤ
 TMEVT˥åΥȥ2ɲáʥåȥ֥
   ȥå
 NULLʤ(ϥɥ餫顼ϥɥ)ȥƥ
   Хå
   Хå줿¦ǤϡCYCCBǥåƥϥ
   ɥƤӽФ
 NULLǤʤ
   ö।٥ȥå򳰤
   ꤵ줿åʥåˤ
   ।٥ȥå
   Ƭ٥ȤѲƤʤå
     ѲƤСꤵ줿å loop 
   ѲƤʤСȥƥХå


======================================================================
ޥ졼
======================================================================
ƥॳˤꡤϥץåưʥޥ졼
ǽȤ롥ޥ졼ǽʥߥ󥰤׸ƤǤ롥

ޥ졼ƳˤꡤͥΥꥢ륿¹ԸΨ
礭ʱƶͿʤȤɸȤ롥

----------------------------------------------------------------------
ޥ졼󥷥ƥॳmig_tsk()ˤλ͸Ƥ
----------------------------------------------------------------------
оݤȤ륿

ޥ졼оݤȤ륿ˤ¸κ񤵤ۤʤ롥

¸ưפʥʡ
  (a)ƥȤƱץå˳դƤ¾Υ
     ʼ¹Բǽ֡Ԥ֡ٻ߾֡ˤФơ

  (b)ƥȤ鼫Ф  

  (c)󥿥ƥȤƱץå˳դƤ¹   
     ǽ֡Ԥ֡ٻ߾֤ΥФơ

  (d)ۤʤץå˳դƤ Ԥ֡ٻ߾ Υ
     Фơ

ͤȤʤ륱ʢ
  (e)󥿥ƥȤƱץå˳դƤ¹   
     ֤ΥФơ

¸ʥʡߡ
  (f)ۤʤץå˳դƤ ¹Ծ֡¹Բǽ Υ
     Фơ

                ץå()  ץå(󥿥)  ¾ץå
¹Ծ              (b)                 (e)               (f)
¹Բǽ          (a)                 (c)               (f)
Ԥ              (a)                 (c)               (d)
ٻ߾              (a)                 (c)               (d)


¸ˡθƤʼ¸ưפʥ

åμϾάƤ롥

(a)ƥȤƱץå˳դƤ¾Υ
  ʼ¹Բǽ֡Ԥ֡ٻ߾֡ˤФơ
 ¹Բǽ֤ʤޥ졼󸵤Υǥ塼鳰
 TCB p_pcb ưΥץåPCB򼨤褦ꤹ롥
 ¹Բǽ֤ʤޥ졼Υǥ塼롥
 ޥ졼ǥǥѥåɬפʤǥѥåꥯȤФ

(b)ƥȤ鼫Ф  
 ޥ졼󸵤Υǥ塼鳰
 TCB p_pcb ưΥץåPCB򼨤褦ꤹ롥
 ޥ졼Υǥ塼롥
 ƥ¸
 󥿥ƥȤΥåڤؤ
 ޥ졼ǥǥѥåɬפʤǥѥåꥯȤФ
 ǥѥåƤӽФ

(c)󥿥ƥȤƱץå˳դƤ¹   
   ǽ֡Ԥ֡ٻ߾֤ΥФơ
 aˤƱ͡

(d)ۤʤץå˳դƤ Ԥ֡ٻ߾ Υ
   Фơ
 TCB p_pcb ưΥץåPCB򼨤褦ꤹ롥

¸ˡθƤʻͤȤʤ륱

(e)󥿥ƥȤƱץå˳դƤ¹   
   ֤ΥФơ

 ߥϥɥ¹Իϡ߱夵뤿ᡤ¹Ծ֤Υ
   ϺǾ¤Υƥȡʥå쥸ˤΤߤ¸줿
   ֤Ǥꡤ¾Υ쥸ϳߥϥɥˤäơɬפ˱
   ƥȤΥå¸Ƥʳߤβߤˡ
   Τᡤޥ졼¨ˤϼ¹ԤǤߤνиǥޥ
   졼ԤʤФʤʤ

 ¨˥ޥ졼󤵤ˡȤƤϡߤǥƥ  
   Ȥ¸ˡ뤬֤߱뤳Ȥ䡤  
   ˤäƤϡåμɬפǤǰ֤ʤ  
   롥

 ߤνиǥޥ졼Ԥˤϡåμɬפ
   ʤ롥å르ꥺˤäƤϡåμޤǤξ»֤
   ޤʤᡤޤʤ

 оݥ¹Ծ֤ΤȤΤAPIμ¹Ԥٱ䤷Ƥޤ
   ˤꥷƥॳο񤤤ѤͤϵƤ뤫

¸ˡθƤʼ¸ʥ

(f)ۤʤץå˳դƤ ¹Ծ֡¹Բǽ Υ
   Фơ

 ¹Ծ֤Υ˴ؤƤϡоݥ¹ԤƤץå
   CPUå֤ǥѥåػ߾֤ξˡFDMPͥˤ¾
   ץåΥФ ter_tsk ƱͤβŪʾ֤ȯ롥

 ˡξ֤ΥФƤΥޥ졼ϡ¨˼
   Ԥʤᡤޥ졼Υƥॳ뤫꥿󤷤
   оݤΥޥ졼󤷤Ƥʤ礬롥

 ¹Ծ֤ΥߤβߤȤʤäƤˤƱͤˡ¨
   ޥ졼󤬼¹Ԥʤ

 ¹Բǽ֤Υ˴ؤƤϡμǤϡǥѥåϥ
   å˼¹Ԥ뤿ᡤ¹Բǽ֤¹Ծ֤ؤܤ
   åμɤȤǤʤΤᡤ¹Ծ֤ܤ륿
   󥰡ʥǥѥåˡˤǥޥ졼Ԥޥ졼
   ΥץåǼ¹Ծ֤ȤʤäˡξΥץåǥ
   ԤƤޤ꤬ȯʼ¹Ծ֤ΥФƥޥ졼
   ¹Ԥ뤳Ȥˤʤˡ褹뤿ˤϡǥѥå
   򥿥åƼ¹Ԥ褦ˤФ褤
 
iter_tsk()ѰդƤʤͳ

ITRON/TOPPERSͤǤϡ󥿥ƥȤ饿λ
iter_tsk() ѰդƤʤͳȤƤϡ¹Ծ֤Υȯ
Ԥȡоݥǥѥåػο񤤤Ȥʤ뤿ʲ
Ūʾ֤򥵥ݡȤ뤫ˤǤ롥

оݥ¹ԲǽԤ֤Υ˸ꤹˡ⤢뤬ʼ¹Ծ
ξ˥顼Ȥˡ¹Ծ֤¹Բǽ֤Ǥ뤫ϡ
ƥ¾Υο񤤤˱ƶ졤оݥμ¤˽λǤʤ
ᡤȤˤȹͤݡȤƤʤ



(c)(e)󥿥ƥȤ鼫ץåΥФƤΥޥ
˴ؤƤϡޤ(e)¨˼¹Ԥˤϡޥ졼
ΥݡȤΤˡߤα򰭲뤳ȤϵƤʤᡤ
ѤʤΤᡤ(e)μ¹Ԥٱ䤹뤬iter_tsk()Ѱդʤ
ꥷθȡоݥ¹Ծ֤¹Բǽ֤ˤäƥ
ॳο񤤤ѤΤϹޤʤˡߤνиǥ
Τ¹Ի֤ξ¤ޤʤǽ롥Τᡤ
ϥݡȤʤ

(d)(f)¾ΥץåΥФƤΥޥ졼˴ؤƤϡ(f)
μ¹Ծ֤ΥϺǤ뤿᥵ݡȤʤ¹Բǽ֤Υ
˴ؤƤϡǥѥååƼ¹Ԥɬפ롥å
μ֤ûޤǥѥåϥåƼ¹Ԥ
ȥå֤ĹʤäƤޤ㤨Сǥѥåȼ 
act_tsk ARMץåǼ¹Ԥϡ1/4μ¹Ի֤ǥѥå
֤Ǥ롥Τᡤޥ졼ΥݡȤˤꡤƤΥǥѥ
ȼƥॳ˱ƶڤܤᡤݡȤʤ(d)ϥݡ
ȲǽǤ뤬Ԥ֡ٻ߾֤Υޥ졼󤹤륱
ϤޤǤȹͤ뤿ᡤݡȤʤʤٻ߾֤Υ
ФƤϡҤ mact_tsk() ˤ굯ưȥޥ졼򥵥ݡȤ
롥

)ƱץåΥФact_tsk()μ¹
 ɾĶ : CT11MPCore 550Mhz
 ǥѥå : 2000[usec]
 ǥѥåʤ : 1500[usec]


ƥॳ

mig_tsk(ID tskid, ID prcid)
  tskid ǻꤷ prcid Υ˥ޥ졼󤹤롥
  ƥȤ顤⤷ϡƱץ
    å˳դ줿ǽ
  prcidTPRC_INIʡ0ˤꤹȡդץåоݤȤ롥

----------------------------------------------------------------------
ޥ졼󥷥ƥॳmig_tsk()ˤλͤγĥ
----------------------------------------------------------------------
ͤγĥƤˤĤƹͤ롥

󥿥ƥȤƱץå˳դƤ륿ʼ
  ԲǽԤٻ߾֡ˤΥޥ졼

äϤʤ¹Ծ֤Υꤷˤϥ顼Ȥ롥
Ҥλ͸ƤǤϡiter_tsk()ƱͤΥݥꥷǡоݥ¹Բǽ
֤¹Ծ֤ˤäơ񤤤ۤʤΤϻȤ꤬Ȥͳ
ǥݡȤʤäʤ顤ޥ졼ǽѤ
ɥХ󥹤¸ϡХإåɤθơϥɥ
󥿥ƥȤǥɥХ󥹤ɬȽǤ롥ơɬ
ʤޥ졼ѤΥФƥǡ塼ˤޥ졼
λؼԤޥ졼ѤΥǥޥ졼Ԥ
ˡŪǤ롥󥿥ƥȤΥޥ졼󤬥ݡ
Сޥ졼ѤΥɬפˤʤꥪХإåɤ㸺
ǽǤ롥

ɥХ󥹤ɬȽǤη̡¹Ծ֤Υޥ졼
оݤȤʤ뤳ȤϤޤǤ뤳Ȥʼ¹Ծ֤ȤȤϴ˥ץå
ƤƤ뤿ޥ졼󤹤ɬʤˡԤ
Ƥ⡤¾Υꤹ뤳ȤǽǤ뤳Ȥ䡤ΥɥХ
Υߥ󥰤ǥޥ졼󤹤Ф褤Ȥͤ⤢롥Τᡤ
¹Ծ֤ʤ饨顼Ȥʤ륹ڥåǤäƤ⡤ͭ⤤ȸ롥


¾ץåΥʼ¹ԲǽԤٻ߾֡ˤΥޥ졼
  (ToDo)

ҤΤ褦ˡ¹Ծ֤ΥФƤΥޥ졼ϥ顼Ȥ
ȤƤǤȤơ¾ץåμ¹ԲǽԤٻ߾֤Υ
Υޥ졼μ¸ˡƤ롥

Ԥٻ߾֤ΥΥޥ졼äϤʤ¹Բ
ǽ֤ΥΥޥ졼ϡǥѥåå
Ƽ¹Ԥ뤳ȤǼ¸ǽǤ롥

ǥѥååƼ¹Ԥ뤳ȤǽƤ롥ǥ
å㤬ƤӽФ륿ߥ󥰤ϼ̤Ǥ롥

  ͥ뵯ư
  ƥॳ
  ߤνиٱǥѥå

ƥॳϴ˥åƤ뤿ʤͥ뵯
ưäϤʤߤνиٱǥѥåˤϡreqflg
å˥åɬפ뤬λǤϥå
ΥΥåȤʤäƤ뤿ᡤ߱ξ¤
ΥåԤˤϡ󥿥ƥȤΥåѹ
ơ󥿥ƥȤȤƥåμԤɬפ롥桼
ߥϥɥ齪λ˥åˡ⤢뤬ߥ
ɥʿѼ¹Ի֤åξ¤ޤʤå르
ꥺѤƤϡߥϥɥμ¹Ի֤ξ¤ޤʤ
뤿ᡤ򤱤褤

˥åβɬפʥǥѥåνиϡ̤Ǥ롥

  start_r
  dispatch_r
  ret_int_r

ʾꡤ¸ϲǽǤ뤬ɤѹ̤礭ǥѥ
ȼƥॳƤѹɬפ롥ޤߤμ¹Ի
ؤƶͿ롥

󥿥ƥȤƱץå˳դƤ륿ʼ
  Ծ֡ˤΥޥ졼(ToDo)

¹Ԥٱ䤹뤳ȤƤ롥

TCBmigflgɲá¹Ծ֤Υξmigflg˰ưΥץå
ΥץåID졤reqflg  trueˤ롥          

ߥϥɥνиǥޥ졼Ԥ

 dspflgΥåterflgåλ塤ƥȤ¸
 󥿥ƥȤΥåڤؤ
 migrate_task()
   åμ
   ץåΥǥ塼Ф
   ưΥץåΥǥ塼
   ץåֳߤȯ
   åβ
   exit_and_dispatch()

¾ץåΥʼ¹Ծ֡ˤΥޥ졼(ToDo)

¹Ԥٱ䤹뤳ȤƤ롥

TCBmigflgɲá¹Ծ֤Υξmigflg˰ưΥץå
ΥץåID졤оݥưƤץåФƥץ
åֳߤ롥

----------------------------------------------------------------------
ưȥޥ졼󥷥ƥॳmact_tskˤλ͸Ƥ
----------------------------------------------------------------------
mig_tsk()λͤ򥿥ƥȤ鼫ƱΥץå˳
դƤ륿˸ꤷᡤ¾ץå˳դ줿
Υޥ졼ˡȤơٻ߾֤ΥФƵưȥ
졼Ԥmact_tsk()ˤѰդ롥ϤΥƥξϡ
䥤٥Ȥˤꡤư륷ƥब¿ᡤΥߥ
ǵưץåꤹΤϡͭѤǤȹͤ롥
εȥޥ졼˴ؤƤϡԤԤƥॳ
¿ᡤݡȤʤ

mact_tsk()λͰ1ʸ

 [i]act_tsk(ID tskid)
   դץåǵư롥
   塼󥰤ϡλ塤λ˳դƤ
     ץåǥư롥

 [i]mact_tsk(ID tskid, ID prcid)
   ץåꤷƥư롥
   ٻ߾֤ΥˤΤȯԲǽǤ롥Τᡤ塼󥰤ȯ
     ʤ
   prcidTPRC_INIʡ0ˤꤹȡդץåǵư롥

 ter_tsk(ID tskid)
   ASPͥ뤫ѹʤ

ٻ߾֡ʼ¹Է³ˤΥФmact_tsk()ο񤤤
Ȥʤ롥ٻ߾֡ʼ¹Է³ˤΥФơmact_tsk()¹Ԥ
̡ΥưΥץåǺǹͥ٤Υˤʤä硤
ǥѥåϤ롥κݡоݥٻ߾ ʼ¹Է
³ˤǤȡĤΥץåǥư뤳ȤˤʤäƤޤ
å˲Ƥޤmact_tsk()оݤΥٻ߾֤
߾ ʼ¹Է³ˤΤɤ餫ȽǤ¾ΥץåϤǤʤ
terflg ȥ¹ԤƤץå p_runtsk Υ
ƤǤäƤ⡤Ǥ˥ǥѥå㤬ưƤ礬
ΤǡȽǤˤϻѤǤʤˡ

ޤ塼󥰤ȯʤȤΤϡ塼󥰤ȡ
ter_tsk()ǥޥ졼ɬפȯ뤿ᡤ¾Υץ
˳դ줿Фƥޥ졼ԤȤˤʤ롥
¾Υץå˳դ줿Υޥ졼ϡ
ޥ졼Υƥॳǵ̤꺤Ǥ뤿ᡤ塼
󥰤ϤʤȤ

mact_tsk()λͰ2ʺѡ

 [i]act_tsk(ID tskid)
   դץåǵư롥
   塼󥰤ϡλ塤λ˳դƤ
     ץåǥư롥

 [i]mact_tsk(ID tskid, ID prcid)
   imact_tsk(ID tskid, ID prcid)
   ץåꤷƥư롥
   塼󥰤ϡλ塤ꤷץåǥ
     ¹Ԥ롥
   prcidTPRC_INIʡ0ˤꤹȡդץåǵư롥

  ter_tsk(ID tskid)
   Ʊץå˳դ줿Τߤǽ
   ¹Ի֤ξ¤ޤʤǥȥ饤

ter_tsk()򼫥Ʊץå˳դ줿Τߤ
ǽȤ뤳ȤǡϲŪʾ֤ȤʤʤᡤͰ1ȯ
ʤ

塼󥰤줿ưԤΤϡext_tsk()  ter_tsk() Ǥ롥
ext_tsk()˴ؤƤϡФޥ졼Ʊν
ʤ

ter_tsk()˴ؤƤϡter_tsk()򼫥Ʊץå˳դ
ΤߤǽȤ뤳ȤǡͰ1ȯ¾ץå
Υޥ졼򤱤뤳ȤǤ롥

mact_tsk()ΥݡȤΤˡter_tsk()äΤϸߴ
Ǥ򤱤褤ʤ顤ter_tsk()ߤ뤳Ȥǡ
ξܤγĥɬפʤʤ뤳Ȥ䡤ǥѥåǥå
ɬפʤʤåȤʾܺ٤ter_tsk()򻲾ȤΤ
ȡˡΤᡤter_tsk()ä뤳ȤȤ

ޤter_tsk()ˤ륿ޥ졼μ¸Τᡤter_tsk()
¹Ի֤ξ¤ޤʤȤ롥ܺ٤ˤĤƤ"ter_tsk()Υȥ
ε"򻲾ȤΤȡ
   
----------------------------------------------------------------------
mig_tsk()
----------------------------------------------------------------------
ȥ֥åTINIB)ؤɲ
  ID     iafinity      : νդץå
  uint_t affinity_mask : γդǽץå 

ER
mig_tsk(ID tskid, ID prcid)
{
   ...
   t_lock_cpu()
   ޥ졼󸵤ΥץåΥå
   if (ۤʤץå˳դƤ륿) {
       顼
   }
   else if (¹Բǽ) {
       if (ȯ) {
          if (ǥѥåػ) {
             顼
          }
          else if(Ʊץå) {
             ̤ͥƱͥ٤ǺȤ
          }
          else {
             dispatch_and_migrate()ˤޥ졼
             ưΥץåǥ꥿󤹤롥
          }
       }
       else {
          /* ¾ξ */
          if (Ʊץå) {
             ̤ͥƱͥ٤ǺȤ
          }
          else {
             ޥ졼󸵤ΥץåΥǥ塼鳰
             TCB  p_pcb ޥ졼ΥץåPCB˽񤭴
             ޥ졼ΥץåΥǥ塼롥
             if (ޥ졼Ǻǹͥ) {
                ǥѥåꥯ
             }
          }
       }
   }
   else if (ٻ߾) {
      TCB  p_pcb ޥ졼ΥץåPCB˽񤭴
   }
   else {
      /* Ԥ */
      if (ԤǤʤ) {
         TCB  p_pcb ޥ졼ΥץåPCB˽񤭴
      }
      else {
         /* 륿ξΤ */
         ޥ졼󸵤ΥץåΥ।٥ȥҡפ
         ưΥץå֤ʤǤХॢȻ֤Ĺ
         ޥ졼ΥץåΥ।٥ȥҡפ
         TCB  p_pcb ޥ졼ΥץåPCB˽񤭴
      }
   }
   ޥ졼󸵤ΥץåΥå
}

åȰ¸ǥ֥ˤ국Ҥ롥

void
dispatch_and_migrate(ID prcid)
{
	å쥸٤ƤΥ쥸򥹥å¸
	åݥ󥿤򼫥ʼץåPCBp_runtskˤTCB¸
	dispatch_r򡤼¹ԺƳϤȤƼTCB¸ 
	å󥿥ƥѤΥåڤؤ
	migrate_self(prcid)
}

migrate_self()϶δؿǤ롥

void
migrate_self(ID prcid)
{
   ޥ졼󸵤ΥץåΥǥ塼鳰
   TCB  p_pcb ޥ졼ΥץåPCB˽񤭴
   ޥ졼ΥץåΥǥ塼롥
   if (ޥ졼Ǻǹͥ) {
      ǥѥåꥯ
   }    
   ޥ졼󸵤ΥץåΥå
}

----------------------------------------------------------------------
mact_tsk()
----------------------------------------------------------------------
ȥ֥åTCBˤؤɲá

  ID actprc : εưΥץå
              (0Ǹ߳դΥץåact_tsk()塼󥰤
              ꤵ)
              
ER
mact_tsk(ID tskid, ID prcid)
{
   ...
   t_lock_cpu();
   ޥ졼󸵤ΥץåΥå
   if (ٻ߾) {
     TCB p_pcb ޥ졼ΥץåPCBѹ
     ¹Բǽ֤ءmake_active
     if (ޥ졼Ǻǹͥ) {
        ǥѥåꥯ
     }
   }
   else if (TCB actque  false ʤ) {
      TCB actque  trueˡ
      ޥ졼׵򥭥塼(actprc˥ץåID).
   }
   else {
      E_QOVER顼
   }
}

----------------------------------------------------------------------
ޥ졼ȯսter_tsk()/ext_tsk()
----------------------------------------------------------------------
mig_tsk()/mact_tsk()ʳΥޥ졼ȯսȤƤϡ
mac_tsk()ˤ뵯ư׵᤬塼󥰤Ƥˡ
ter_tsk()/ext_tsk() ǥޥ졼ȯ롥

ɤξǤоݥTCB actprc åơ0ʳʤ饿
ޥ졼׵᤬塼󥰤Ƥ뤿ᡤޥ졼
Ԥ

ext_tsk()Ǥϡexit_and_migrate() ƤӽФexit_and_migrate()ϥ
åȰ¸졤֥ǵҤ뤳Ȥꤹ롥

void
exit_and_migrate(ID prcid)
{
	å󥿥ƥѤΥåڤؤ
	exit_and_migrate_self(prcid)
}

exit_and_migrate_self()϶δؿǤ롥

void
exit_and_migrate_self(ID prcid) {
   ޥ졼󸵤ΥץåΥǥ塼鳰
   ٻ߾֤Ȥ(make_dormant())
   TCB  p_pcb ޥ졼ΥץåPCBѹ
   TCB  actque  false ؽ
   TCB  actprc  0 ؽ
   if (ޥ졼Ǻǹͥ) {
      ǥѥåꥯ
   }   
  å
  ǥѥå㡼ءexit_and_dispatch();
}


======================================================================
।٥ȥϥɥΥޥ졼
======================================================================
륿ξϡ।٥ȥϥɥϤ줫Υץ
˳դ롥ưϤȡդ줿ץåΥ
।٥ȥȥ֥åڤӥ।٥ȥҡפˤäƴ졤
ॢȤȳդ줿ץåǼ¹Ԥ롥ǡ
줿ץåѹ륷ƥॳѰդ롥

----------------------------------------------------------------------
ƥॳ
----------------------------------------------------------------------
  ER msta_cyc(ID cycid, ID prcid)
   դץåǤμϥɥư
  ER msta_alm(ID almid, RELTIM almtim, ID prcid)
   դץåǤΥ顼ϥɥư
  ER imsta_alm(ID almid, RELTIM almtim, ID prcid)
   դץåǤΥ顼ϥɥưϡ󥿥
     ƥȡ

----------------------------------------------------------------------
ɲåǡ
----------------------------------------------------------------------
CYCINIB
  ID      iaffinity;      /* ϥɥνդץå */
  uint_t  affinity_mask;  /* ϥɥγդǽץå */

ALMINIB
  ID      iaffinity;      /* 顼ϥɥνդץå */
  uint_t  affinity_mask;  /* 顼ϥɥγդǽץå */

----------------------------------------------------------------------
msta_cyc(ID cycid, ID prcid)μ
----------------------------------------------------------------------
ER
msta_cyc(ID cycid, ID prcid)
{
   ...  
   t_lock_cpu()
   ưȰưΥץåΥå
   if (ưƤ) {
      ।٥ȥҡפ鳰
   }
   else {
      cycsta = true;
   }
   ϥɥ饳ȥ֥å p_pcb ˰ưΥץåPCBϿ
   ưΥץåΥ।٥ȥҡפ
   å
} 

----------------------------------------------------------------------
[i]msta_alm(ID almid, RELTIM almtim, ID prcid)μ
----------------------------------------------------------------------
ER
[i]msta_alm(ID almid, RELTIM almtim, ID prcid)
{
   ...  
   t_lock_cpu()
   ưȰưΥץåΥå
   if (ưƤ) {
      ।٥ȥҡפ鳰
   }
   else {
      almsta = true;
   }
   顼ॳȥ֥å p_pcb ˰ưΥץåPCBϿ
   ưΥץåΥ।٥ȥҡפ
   å
} 

======================================================================
TOPPERS/SMPͥɲä¾Ѥεǽΰ
======================================================================
----------------------------------------------------------------------
ԥåǽ
----------------------------------------------------------------------
ۤʤץåΥȳߥϥɥ֤¾椬ɬפȤʤ뤿ᡤ
FMPͥǤ⥵ݡȤ롥

----------------------------------------------------------------------
ץåͭǽ
----------------------------------------------------------------------
ޥ졼ϡץå¾Υ⤷ϼʬȤ˸ꤵ
Ƥ뤿ᡤCPUåǽǼ¸ǽ

¾Υץå¹Ծ֤ΥΥޥ졼򥵥ݡȤ
ǤäƤ⡤ǽŪˤϳߤΤǡ߶ػߤǼ¸ǽ


======================================================================
ԥåǽ
======================================================================
ԥåǽϡۤʤץåǼ¹ԤƤ֤¾
ѤꤷƤ롥Υԥå֤ϡ֥֡ס֥
ߥϥɥ֡סֳߥϥɥ֡פǻѲǽǤ롥ʤ
֥֡פϡŪˤϥޥեǹԤû㤨Хꥢ
Τߤʤɡ˶֤ǻѤǧ롥

ϡϡɥ¾浡Ǻǽʥåοꡤ
ͥƥȥߥ졼2򥵥ݡȤ롥ߥ졼
ϡ¾ΥƥॳѤ륪֥ȥåѤ뤿
ʥƥॳ¹ԻΤߡԥåϲˡ¾Υ
ॳȤζ礬ȯ롥ͥƥ¾ΥƥॳȤζ
ȯʤ

ڤؤϡޥ SPN_TYPE 򡤥ͥƥξ NATIVE_SPN
ߥ졼ξ EMULATE_SPN 롥

----------------------------------------------------------------------
ѹս
----------------------------------------------------------------------
ͥƥߥ졼˼ѹɬפȤʤ롥

ץå֥åPCB
  ID locspnid : 0ʤ饹ԥå֡ԥåƤ
                  СƤ륹ԥåIDݻ롥

ԥåζ
  
  λext_tsk()
   㳰ϥɥ餫Υ꥿

 
  ߥϥɥ餫Υ꥿
  ߥӥ롼󤫤Υ꥿

  ।٥ȥϥɥ
  顼ϥɥ餫Υ꥿
  ϥɥ餫Υ꥿

  CPU㳰
   CPU㳰ϥɥ餫Υ꥿
    CPU㳰ȯ˥ԥåƤʤ

  ͥ뽪λext_ker()

unl_cpu/iunl_cpuѹ
  ԥå֤åơƤХåʤ

----------------------------------------------------------------------
ͥƥμ
----------------------------------------------------------------------
ԥåΥ֥Ȥ1ĤФƥϡɥΥå1ĳ
ˡϡɥΥåο󤬤ʤѤ롥

ǽʥԥåοϡޥ TMAX_NATIVE_SPN  롥
ޤåѿηޥ SPNLOCK 롥

ԥå֥å
   ATR  spnatr : ԥå°

ԥå֥å
    SPNLOCK       spn_lock   : ϡɥΥå
    const SPNINIB *p_spninib : ֥åؤΥݥ
    bool_t        lock_flg   : ԥåθߤΥå(ref_spn)

åȰ¸δؿ
  void x_initialize_spin(ID spnid, SPNLOCK *p_spn_lock)
    ưνԥå֥å spn_lock ȥؤ
      ݥ󥿤Ϥ

  void [t|i]_lock_spin(SPNLOCK *p_spn_lock)
    CPUå֤ǸƤӽФ롥ϡɥԥå
      ߡǤХ꥿󤹤롥Ǥʤϡöߤ
      塤Ƥӳߤػߤ˥ϡɥԥå
      ߤ롥ԥå֤ǸƤӽФ뤳ȤϤʤƤӽФ줿
      ưݾڤɬפʤ

  bool_t x_try_lock_spin(SPNLOCK *p_spn_lock)
    ϡɥԥåμߤ롥false
      ֤ ˼Ԥϡtrue֤CPUå֤ǸƤӽФ
      롥

  void x_unlock_spin(ID spnid)
    ԥåֵѤ

----------------------------------------------------------------------
ߥ졼μ
----------------------------------------------------------------------
¾ΥƥॳƱͤOSΥåѤƼ¸ˡϡɥ
Υåοʾ˥ԥåɬפʾѤ롥γ٥å
ϡͥƥѲǽǤ뤿ᡤγ٥åȥߥ졼
Ʊͭˤȥ顼Ȥ롥

ԥå֥å
   ATR  spnatr : ԥå°
   LOCK *p_obj_lock : åؤΥݥ󥿡ʥץååξ

ԥå֥å
   QUEUE         dummy      : ¾Ʊ֥ȤƱޥȤΥߡ 
   const SPNINIB *p_spninib : ֥åؤΥݥ
   bool_t        lock_flg   : ԥåθߤΥå


======================================================================
ǥåɥå
======================================================================
----------------------------------------------------------------------
оݥƥॳ롦ؿ
----------------------------------------------------------------------
 ext_tsk(void)
 ter_tsk(ID tskid)
 rel_wai(ID tskid)/irel_wai(ID tskid)
 chg_pri(ID tskid, PRI tskpri)  
 wait_tmout()ؿ
 make_non_wait()ؿ

ter_tsk()ˤĤƤϡޥ졼бΤȥ饤Ƥ롥
ext_tsk()Ʊͤ˥ޥ졼бΤᡤȥ饤Ƥ롥
¾Υƥॳ˴ؤƤϡȥ饤ʤεȤ߹ࡥ

make_non_wait() ˴ؤƤϡδؿΤϥǥåɥåɬפȤ
¾ΥƥॳΥǥåɥåˤȥ饤βμ¸
Τˡmake_non_wait() ѹɬפ롥

----------------------------------------------------------------------
TCBؤɲåȥ
----------------------------------------------------------------------
bool_t pend_relwai : Ԥ¹ɽ
bool_t pend_chgpri : chg_pri(ID tskid, PRI tskpri)¹ɽ
UINT   pend_newpri : ͥѹαοͥ١ɽ

----------------------------------------------------------------------
ƥॳ롦ؿμ
----------------------------------------------------------------------
ext_tsk(void)

ER
ext_tsk(void)
{
  retry:
   ...
   Υåμ
   ...
   if (ƵưΥޥ졼׵ʤ) {
      ư׵ᥭ塼󥰤кƵư
   }
   else {
      ưΥץåPCB
      öΥå롥

      ߳դƤץåȰưΥץåΥ
      åIDξ˼
     
      if(ޥ졼Υץåѹ줿) {
         åƲƥȥ饤.
         (can_act()ˤȯǽ)
      }
   }
}

ter_tsk(ID tskid)

ER
ter_tsk(ID tskid)
{
   ...
   t_lock_cpu();
  retry:
   оݥΥåμ
   ...
   if (֥Ԥʳ) {
      if (ƵưΥޥ졼ʤ) {
         ...
      }
      else {
         /* ƵưΥޥ졼󤢤 */
         ưΥץåPCB
         оݥΥå롥

         ߳դƤץåȰưΥץåΥ
         åIDξ˼
     
         if (ޥ졼Υץåѹ줿 ||
             оݥȼդƤץåۤʤ) {
             åƲƥȥ饤.
             (can_act()ˤȯǽ)
         }
         if (!(оݥ¹Ծ || ֥Ԥ)) {
             åƲƥȥ饤.
             (¾Υˤٻ߾֤ȤʤäƤ礬)
         }
      }
   }
   else {
      /* ֥Ԥ */
      if (ƵưΥޥ졼ʤ) {
         å
         ֥ȥååνǥå
         if (ۤʤ륪֥ȤФԤȤʤäƤ) { 
            åƲƥȥ饤.            
         }
      }
      else {
         /* ƵưΥޥ졼󤢤 */
         ưΥץåPCB
         оݥΥå
         
         ֥ȥå
         ߳դƤץåȰưΥץåΥ
         åIDξ˼
         ˼Ԥϥȥ饤
         if (ۤʤ륪֥ȤФԤȤʤäƤ ||
               оݥȼդƤץåۤʤ) {
               åƲƥȥ饤.
         }
         ޥ졼
      }
   }
}

rel_wai(ID tskid)/irel_wai(ID tskid)

ER
rel_wai(ID tskid)
{
    ...
    t_lock_cpu();
    retry:
     if (֥ԤǤʤ) {
        Ԥwait_release()
     }
     else {
        /* ֥Ԥξ */
        p_tcb->pend_relwai = true;
        å
        ֥ȥååνǥå
        if (!p_tcb->pend_relwai) {
            ƤΥå
            E_OBJǽλ
        }
        p_tcb->pend_relwai = false;
        ...
     }
}

chg_pri(ID tskid, PRI tskpri) 

ǽΥånewpriTCBϿƥå¾Υ롼ǤԤ
ֲˤnewpri򸫤ͥ٤ѹƥånewpriͤͭ
ƱԤΤϤʤΤ̾ͥѹԤ

ER
chg_pri(ID tskid, PRI tskpri)
{
    ...
    t_lock_cpu();
  retry:
    if (ٻ߾) {
       E_OBJ֤
    }
    else {
       /* ٻ߾ְʳ */
       if (¹Բǽ) {
          оݥͥʥǥ塼ѹˡ
       }
       else if (֥ԤǤʤ) {
          оݥͥTCBΤѹˡ
       }
       else {
          /* ֥Ԥ */
          p_tcb->pend_chgpri = true;
          p_tcb->pend_newpri = newpri;          
          å
          ֥ȥååνǥå
          åμԤϥȥ饤         
          if (!pend_chgpri) {
             å
             E_OKǥ꥿
          }
          ͥ٤ꡥ
       }
    }
}

wait_tmout(TCB *tcb) ؿ

ƥåԤǤʤв⤷ʤƤ褤륿ξ
ϡॢȽоݥƱץåưƤΤǡ
ݥϤδ֤ư¾Υ֥Ԥˤʤ뤳ȤϤʤ

Х륿ξϡ㥤ȥåǤ뤿ᡤ⤽
åɥåɬפǤϤʤ

void
wait_tmout(TCB *p_tcb) 
{
    if (֥Ԥ) {
        p_tcb->pend_relwai = true;
        å
       retry:
        ֥ȥååνǥå
        åμ˼Ԥȥ饤
        if (!p_tcb->pend_relwai) {
           ֥ȥå
           ꥿
        }
        p_tcb->pend_relwai = false;
        ֥Ԥ
    }

}

make_non_wait() ؿ

Ԥ֤ݤ̤롼pend_chgpri/pend_relwaiå
롥

Inline bool_t
make_non_wait(TCB *p_tcb)
{
   ...
   /* ͥѹե饰å */
   if (pend _chgpri) {
       p_tcb->priority = p_tcb->pend_newpri;
       p_tcb->pend_chgpri = false;
   } 
   /* Ԥαꥢ */
   p_tcb->pend_relwai = false;

   if (!Ԥ) {
      оݥ¹Բǽ֤ذܹԡ
   }
   else {
      /* Ԥ */
      оݥԤ֤ذܹԡ
   }
}


======================================================================
ter_tsk()Ϣ
======================================================================
----------------------------------------------------------------------
ter_tsk()
----------------------------------------------------------------------
FMPͥǤϡter_tskAPIƤӽФƱץå˳
դ줿ΤߤоݤȤ褦¤ߤ롥

FDMPͥǤϡͤ¤ߤƤʤꡤξ
ܤʣƤFDMPͥͽ򻲾ȤΤȡˡ

FDMPͥƳƤʣʾܤϡ桼鸫硤
Ѥ­Ȥʤ롥̾Υλϡ¾Υץå˳դƤ
륿ФƤȯԤǤ륿㳰ѤȤơter_tsk()Ϥ
ޤǤ⥿ߤκǽʤªȡߤƥ
ͳȯԤƤ꤬ʤȹͤ롥

ޤter_tsk()¤ߤʤˤϡǥѥåߤνи
ǥǥѥåɬפˤʤä˥åμɬפȤʤǥ
åȤ⤢롥

----------------------------------------------------------------------
ter_tsk()Υȥ饤ε
----------------------------------------------------------------------
ץååޤϺγ٥åter_tskǥ֥Ԥ
Υλ硤ǥåɥåΤᡤöå
Ƥ顤֥ȥååνǥå롥

ξΥåǥ֥ԤˤʤäƤʤ
䡤¾Υ֥ȤԤˤʤäƤϡȥ饤뤿ᡤ¹Ի
֤ξ¤ޤʤFDMPͥǤTCB pend_tertsk Ƴ
ơȥ饤ȯ˼¹Ծ»֤ޤƤ롥

pend_tertsk Ƴȡter_tsk  pend_tertsk 򥻥åȸ塤
åơ֥ȥå->åνǼߤ롥
åˡ¾Υƥॳ뤬¹Ԥ졤Υƥॳ
Ԥ֤ϡβսmake_non_wait()ˤǡpend_tertsk
åơtrueʤ齪λȺƵư򤹤ɬפ롥

FMPͥǤϡmact_tskƳƤꡤmact_tsk׵ϥڥǥ
롥ڥǥ󥰤줿硤Ƶư˥ޥ졼ȯ롥
嵭ͤˡǥåɥå¾Υƥॳ뤬¹Ԥ줿ϡ
ΥƥॳˤƵưǥޥ졼ȯ롥

¾Υƥॳϡter_tskоݤȤʤäƤ륿դ
ץåȤϰۤʤץå¹Ԥǽ뤿ᡤۤ
ץåˤޥ졼ȯ뤳Ȥˤʤ롥

FMPͥǤϡۤʤץåˤޥ졼ϵĤ
ʤͳȤƤϡFMPͥǤϥǥѥåϥå
ư뤿ᡤǥѥåΥޥ졼󤷤Ƥޤȡ
OSΥǡ¤򵯤ƤޤǤ롥

Ԥ֤ٻ߾֤ΥФޥ졼ϲǽǤ롥
pend_tertskѤǥåɥåǤϡоݤȤ륿Ԥ֤
ꡤԤ֤ΥƵưݤ˥ޥ졼󤵤Τ
ʤ

ʤ顤ޥ졼¹Ԥ뤿ˤϡưΥץå
åɬפꡤǥåɥåΤᡤ
ưΥץåΥå򤤤äɬפ롥

make_non_wait()ϰʲδؿƤӽФؿǤ롥

ΤᡤߤĤǤ߱¤򰭲ʤå
ʤ

 wait_complete()
 wait_tmout()
 wait_tmout_ok()
 wait_release()
 init_wait_queue()

ΤᡤFMPͥǤϡpend_tertsk Ƴter_tsk ϥȥ饤
뤳Ȥˤ롥


======================================================================

======================================================================
CPUå/ǥѥåػ߾֤Ǽ¹ΥФsus_tskȯ
Ԥ줿ο(ޥƥ)ꤹ롥ter_tsk()˴ؤƤϡ
FMPͥǤϡ¾ץåΥФter_tsk()ػߤᡤ
ʤ

 sus_tsk(ID tskid)λ
   CPUå/ǥѥåػΥФsus_tsk()ȯԤȡ
   ϰŪ˲Ūʾ(run-suspend)ˤʤ롥

- CPUå֤μ¹Ծ֤ΥФsus_tsk()ȯ
   - äкɬפϤʤ
   - sus_tsk()μ¹Ը塤ץåֳߤȯ
   - CPUåAPIȯԤǤʤ
   - CPUåǳߤդ
   - ξ֤suspend˰ܹԤƤ뤿ᡤrsm_tsk()
     ư롥

- ǥѥåػ߾֤μ¹Ծ֤ΥФȯ
   - äкɬפϤʤ
   - sus_tsk()¹Ը塤ץåֳߤȯ
   - ߤϵĤƤΤǡߥ롼뤬
      ǥѥåػΤᡤ⤻˥꥿
   - ena_dsp()¹ԤȡǥѥåԤena_dsp()
     ǥåȤ뤿ᡤsus_tsk()ȤΥ졼󥰤ȯ
     ʤ
   - ξ֤suspend˰ܹԤƤ뤿ᡤrsm_tsk()
      ư롥

- پ֡run-suspendˤΥAPIȯ
   - ǥѥåػ߾֤ǤϡԤ֤ˤAPIȯԤǤ
     CPUå֤ǤϤۤȤɤAPI¹ԤǤʤȡ
     ʬξ֤ѹǤʤΤᡤAPIȯԤʤޤ
     ext_tsk()ϸ§顼TOPPERSǤϥ˥󥰤ˤƽ


======================================================================
ؿʶ
======================================================================
ؿˤĤơASPͥȤκۤˤĤ롥

----------------------------------------------------------------------
ɲäؿ
----------------------------------------------------------------------
mp.c
 åֵѴؿ
 void initialize_pcb(void)
   PCBν
 void ipi_handler(void)
   ץåֳߥϥɥ
 bool_t dispatch_request(PCB* p_pcb)
   ǥѥåꥯ
 void ext_ker_request(void)
   ͥ뽪λꥯ
 void barrier_sync(uint_t phase)
   ХꥢƱؿ
 
pcb.h
 PCB* get_mp_p_pcb(ID prcid)
 TPCB* get_my_p_tpcb(void)

task.c
 set_lowest_precedence(TCB *p_tcb, PCB *p_pcb);
   ̤ͥƱͥ٤ΥǺ
 void dispatch_call_texrtn(void)
   å call_texrtn() ƤӽФ
 void migrate_self(ID prcid)
   Υޥ졼
 void exit_and_migrate_self(ID prcid)
   νλȥޥ졼

time_event.c
 ulong_t get_my_current_time(void){
   ץå current_time μ

----------------------------------------------------------------------
ѹؿ
----------------------------------------------------------------------
alarm.c
 void initialize_alarm(void)
   ।٥ȥȥ֥å¤ΤȤʤäᡥ
 void call_almhdr(ALMCB *p_almcb)
   åμɲá
   ԥåζɲá

cyclic.c
 void initialize_cyclic(void)
   ।٥ȥȥ֥å¤ΤȤʤäᡥ
 void call_cychdr(CYCCB *p_cyccb)
   åμɲá
   ԥåζɲá

eventflag.c
 void initialize_eventflag(void)
   γ٥åξΥåѿν

interrupt.c
 void initialize_interrupt(void)
   ߤΥץåؤγդΤᡥ

mailbox.c
 void initialize_mailbox(void)
   γ٥åξΥåѿν

mempfix.c
 void initialize_mempfix(void)
   γ٥åξΥåѿν

pridataq.c
 void initialize_pridataq(void)
   γ٥åξΥåѿν

task.c
 void initialize_task(void)
   TCBѹˤ롥
 bool_t primap_empty(PCB *p_pcb)
    PCB*ɲ
 uint_t primap_search(PCB *p_pcb)
    PCB*ɲ
 void primap_set(PCB *p_pcb, uint_t pri)
    PCB*ɲ
 void primap_clear(PCB *p_pcb, uint_t pri)
    PCB*ɲ
 TCB *search_schedtsk(PCB *p_pcb)
    PCB*ɲ
 bool_t make_runnable(TCB *p_tcb)
    PCB褦ѹ
 bool_t make_non_runnable(TCB *p_tcb)
    PCB褦ѹ
 void make_dormant(TCB *p_tcb)
    TCBɲùܤν
 bool_t change_priority(TCB *p_tcb, uint_t newpri)
    PCB褦ѹ
 bool_t rotate_ready_queue(uint_t pri, PCB *p_pcb)
    PCB*ɲ
 void call_texrtn(void)
    PCB褦ѹ
    åμɲá
 void calltex(void)
    PCB褦ѹ

time_event.h
 void tmevtb_enqueue(TEVTCB *p_tevtcb, TMEVTB *p_tmevtb, RELTIM time, CBACK callback, void *arg)
    ѹTMEVTB->TEVTCB
 void tmevtb_enqueue_evttim(TEVTCB *p_tevtcb, TMEVTB *p_tmevtb, EVTTIM time, CBACK callback, void *arg)
    ѹTMEVTB->TEVTCB
 EVTTIM tmevtb_dequeue(TEVTCB *p_tevtcb, TMEVTB *p_tmevtb)
    ѹTMEVTB->TEVTCB

time_event.c
 void initialize_tmevt(void)
   ।٥ȥȥ֥å¤ΤȤʤäᡥ
 uint_t tmevt_up(TEVTCB *p_tevtcb, uint_t index, EVTTIM time)
   TEVTCB*ɲ
 uint_t tmevt_down(TEVTCB *p_tevtcb, uint_t index, EVTTIM time)
   TEVTCB*ɲ
 void tmevtb_insert(TEVTCB *p_tevtcb, TMEVTB *p_tmevtb, EVTTIM time)
   TEVTCB*ɲ
 EVTTIM tmevtb_delete(TEVTCB *p_tevtcb, TMEVTB *p_tmevtb)
   TEVTCB*ɲ
 void tmevtb_delete_top(TEVTCB* p_tevtcb)
   TEVTCB*ɲ
 RELTIM tmevt_lefttim(TEVTCB *p_tevtcb, TMEVTB *p_tmevtb)
   TEVTCB*ɲ
 void signal_time(void)
   å

wait.h
 void make_wait(TCB *p_runtsk)
   Ԥȥ֥åݻˡѹᡤѹ
 void wait_dequeue_tmevtb(TCB *p_tcb)
   Ԥȥ֥åݻˡѹᡥ
 ID wait_tskid(QUEUE *p_wait_queue)
   Ԥȥ֥åݻˡѹᡥ
 
wait.c
 void make_wait_tmout(TMO tmout, PCB *p_pcb)
   Ԥȥ֥åݻˡѹᡤѹ
 bool_t make_non_wait(TCB *p_tcb)
   ǥåɥåΤΥɤɲá
 bool_t wait_complete(TCB *p_tcb)
   Ԥȥ֥åݻˡѹᡥ
 void wait_tmout(TCB *p_tcb)
   ǥåɥåΤΥɤɲá
 void wait_tmout_ok(TCB *p_tcb)
    PCB褦ѹ
    ۤʤץå˳դ줿εˤϡdispatch_request()
      ƤӽФ
 bool_t wait_release(TCB *p_tcb)
   Ԥȥ֥åݻˡѹᡥ
 void wobj_queue_insert(WOBJCB *p_wobjcb, TCB *p_runtsk)
   PCBȤ褦ˤᡥ
 void wobj_make_wait_tmout(WOBJCB *p_wobjcb, TMO tmout, TCB *p_runtsk)
   Ԥȥ֥åݻˡѹᡤѹ
 bool_t init_wait_queue(QUEUE *p_wait_queue)
   륿Υå

----------------------------------------------------------------------
ؿ
----------------------------------------------------------------------
dataqueue.c
  bool_t send_data(DTQCB *p_dtqcb, intptr_t data, bool_t *p_reqdsp)
    åδطǳAPIŸ
  bool_t force_send_data(DTQCB *p_dtqcb, intptr_t data)
    åδطǳAPIŸ
  bool_t receive_data(DTQCB *p_dtqcb, intptr_t *p_data, bool_t *p_reqdsp)
    åδطǳAPIŸ

pridataq.c
  bool_t send_pridata(PDQCB *p_pdqcb, intptr_t data, PRI datapri, bool_t *p_reqdsp)
    åδطǳAPIŸ
  bool_t receive_pridata(PDQCB *p_pdqcb, intptr_t *p_data, PRI *p_datapri, bool_t *p_reqdsp)
    åδطǳAPIŸ


======================================================================
åȰ¸
======================================================================
----------------------------------------------------------------------
ץåIDvolatile
----------------------------------------------------------------------
ޥ졼θȡå˻Ȥդ
줿ץåΥץåIDϥå˺ٻȤɬפ롥
ΤᡤץåIDλȤϺŬоݤȤʤvolatile 

----------------------------------------------------------------------
CPUå֤ǸƤӽФؿ
----------------------------------------------------------------------
ʲ˼ؿϡCPUå֤ǸƤӽФᡤץå
ͭǡ򥢥Τ˴ؤƤϡ¹˥ޥ졼󤵤
ʤ褦ˡCPUå֤ȤƸͭǡ򥢥뤳ȡ

bool_t sense_context(void)
void t_lock_cpu(void)
void x_lock_cpu(void)
bool_t t_sense_lock(void)
bool_t x_sense_lock(void)
bool_t sense_tskctx_unl(void)
bool_t sense_intctx_unl(void)
bool_t VALID_INTPRI_CHGIPM(PRI intpri)


======================================================================
ɵҤΥåݥ
======================================================================
----------------------------------------------------------------------
ץåͭǡؤΥ
----------------------------------------------------------------------
ץåͭǡؤΥϡɬߤػߤƥޥ
졼ƹԤȡ

PCBΥץåͭΥǡإϡCPUIDΥץå
̤쥸˥Ƥ顤ξ˥٤
ꤹ롥ߤĤ줿֤ǤˡǥץåͭΥǡ
إȡäץåθͭǡإ꤬ȯ
ǽ롥Ūˤϡץå̤쥸˥
ľ˳ߤꡤǥޥ졼󤵤줿硤ޥ졼
˳դƤץåθͭǡ˥Ƥޤ

----------------------------------------------------------------------
ƥॳǤPCBμ
----------------------------------------------------------------------
åؿͤѤƤ뤳ȡ

ץåͭǡΥȴϢƤ뤬PCBϺǤ٤ι
ץåͭǡǤ뤿ᡤåؿPCB֤褦
ˤƤ롥

----------------------------------------------------------------------
Ѥåؿ
----------------------------------------------------------------------
ƥॳåؿ뤳ȡ

åؿϡƥȡåоݡʿΰ㤤ˤढ
ᡤΤѤ뤳ȡ

----------------------------------------------------------------------
ena_int()/dis_int()γֹΥåΥߥ
----------------------------------------------------------------------
ASPͥǤϡCPUå֤ȤʤCHECK_INTNO_DISINT()ǳ
椬ͭå롥FMPͥǤϡǽʳֹ
ۤʤ礬롥ΤᡤCHECK_INTNO_DISINT()θ˥ޥ졼
ȯȡޥ졼塤äֹФԤǽ
롥

ΤᡤCPUå֤ȤˡֹΥåԤ褦ˤ
롥


======================================================================
¾
======================================================================
----------------------------------------------------------------------
åޥѹ
----------------------------------------------------------------------
ASPͥˤơƥॳCPUå֤Ǽ¹Ԥ
åޥϡǥץåͭǡФƥ롥
ΤᡤFMPͥˤƤϡޥ졼󤬤뤿ᡤ
Υåޥưʤǽ롥ޤåȰ¸
δؿˤĤƤ⡤ץåͭǡ˥ǽ뤿ᡤƱ
꤬ͤȯ롥

ŪˤϰʲѿؿåޥCPUå֤ǸƤ
Ф뤿ᡤƤӽФ˥ޥ졼ȯȡޥ
졼λ塤˳դ줿ץåξ֤򸫤Ƥޤ
ǽ롥

ץåͭǡ(PCBѿ)
  dspflg, p_runtsk, locspnid

åȰ¸δؿ
  sense_context(), t_sense_lock(), x_sense_lock()

#define CHECK_TSKCTX() {									\
	if (sense_context()) {									\
		ercd = E_CTX;										\
		goto error_exit;									\
	}														\
}

#define CHECK_INTCTX() {									\
	if (!sense_context()) {									\
		ercd = E_CTX;										\
		goto error_exit;									\
	}														\
}

#define CHECK_TSKCTX_UNL() {								\
	if (sense_context() || t_sense_lock()) {				\
		ercd = E_CTX;										\
		goto error_exit;									\
	}														\
}

#define CHECK_INTCTX_UNL() {								\
	if (!sense_context() || i_sense_lock()) {				\
		ercd = E_CTX;										\
		goto error_exit;									\
	}														\
}

#define CHECK_DISPATCH() {									\
	if (sense_context() || t_sense_lock() || !dspflg) {	\
		ercd = E_CTX;										\
		goto error_exit;									\
	}														\
}

#define CHECK_NONSELF(p_tcb) {								\
	if ((p_tcb) == p_runtsk) {								\
		ercd = E_ILUSE;										\
		goto error_exit;									\
	}														\
}

#define CHECK_LOCSPN() {									\
	if (locspnid != 0) {									\
		ercd = E_CTX;										\
		goto error_exit;									\
	}														\
}

åȰ¸δؿ˴ؤƤϡ줾δؿǳߤػߤƽ
ԤФ褤¹ԥХإåɤθơƥȽCPU
å֤ξå륿åȰ¸δؿѰդ롥δؿ
ϡޥ졼θơɬפʤ顤ߤػߤȽꤹ롥
ˤϳߤ򸵤ξ֤Ȥ롥

 sense_tskctx_unl() : ƥ  CPUå֤ʤ true
 sense_intctx_unl() : 󥿥ƥ  CPUå֤ʤ true

¾senseϤΰ¸δؿϥޥ졼θơɬפʤ
ߤػߤȽꤹ롥

ѿΥåϡCPUå˥å褦ˤ롥Ū
ˤϡCHECK_DISPATCH()ϡCHECK_TSKCTX_UNL()Ȥ롥ơ
dspflgΤߤå CHECK_DISPATCH() ѰդCPUå֤Ȥ
˸ƤӽФ

#define CHECK_TSKCTX_UNL() {								\
	if (!sense_tskctx_unl()) {								\
		ercd = E_CTX;										\
		goto error_exit;									\
	}														\
}

#define CHECK_INTCTX_UNL() {								\
	if (!sense_intctx_unl()) {								\
		ercd = E_CTX;										\
		goto error_exit;									\
	}														\
}

#define CHECK_DISPATCH(p_pcb) {								\
	if (!(p_pcb->dspflg)) {									\
		ercd = E_CTX;										\
		t_unlock_cpu();										\
		goto error_exit;									\
	}														\
}															\

-----------------------------------------------------------------------
оݤȤsus_tskΥ졼
----------------------------------------------------------------------
sus_tskƱΤ졼󥰤ͤ롥

¾оݤȤ¾Ԥ֤ȤʤäȤƤ⡤
Բʬ顤꤬ʤʤ⤽ɤʤˡ

оݤȤˤϡԤ֤ sus_tsk ¹Ԥ뤳Ȥ
ʤꡤ¹Ԥη̡E_QOVR֤뤳Ȥˤʤ롥

E_QOVR֤ȤȤϡԤ֤ sus_tsk ƤӽФȤ
ȤˤʤΤǡ򤱤褤ȹͤ롥򤱤뤿ˤϡоݥ
¾ˤäơѤåؿѹɬפ롥
⤽⼫ʬȤФsus_tsk ƤӽФȼΤ쥢ȹͤ
뤿ᡤE_QOVR֤äƤ褤Ȥͤ뤿ᡤͤʲΤ褦
ѹоݥȽϹԤʤ

----------------------------------------
ޥץåбͥǤϡоݥξˤ⡤
E_QOVR顼Ȥʤ礬롥ξϡФsus_tskȯ
ΤƱߥ󥰤ǡ¾ΥץåǼ¹ԤƤ륿Ʊ
Фsus_tskȯԤ줿ȯǽ롥
----------------------------------------

----------------------------------------------------------------------
ʣΥԤ˴ؤα
----------------------------------------------------------------------
ASPͥǤϡ ʲΥƥॳԤ륿ο
Ĺʤ롥

 init_xxx
 ٥ȥե饰 set_flg()

FMPͥǤϡåطᡤ¹Ի֤ξ¤ޤʤ

ޤini_xxxˤ륿åμ˴ؤƤϡretryѤȥ
ϹԤʤ˲ŪʥɤǤ뤿ˡΤᡤ֤߱ξ
¤ޤʤʤΤǡ̰Ƥ⤫ޤʤȹͤ롥

ƱץåФʣߤ뤳ȤƤʤ顤
init_wait_queue()  make_non_wait()ͤåƳߤ
Ф褤

----------------------------------------------------------------------
[i]mrot_rdq()ɬ
----------------------------------------------------------------------
mrot_rdq()ϡꤷץåͥ٤Υǥ塼ž
륷ƥॳǤ롥FDMPͥ뤫Ƴ졤ɬˤĤƤϡ
βȤƤirot_rdq()ϡϥɥǸƤӽФȤˤꡤ
饦ɥӥ󥹥塼󥰤¸Ȥ롥FMPͥǤϡ
Х륿ξϡƥץåǤΤ߼ϥ
ɥ餬ư뤿ᡤƥץåʳǥ饦ɥӥ󥹥
塼󥰤¸뤿ˤϡimrot_rdq()ɬפǤȸ롥
mrot_rdq()ɬˤĤƤϺ롥

ʾ
