asp/extension/mutex/test/test_mutex6.c

   1 /*
   2  *  TOPPERS Software
   3  *      Toyohashi Open Platform for Embedded Real-Time Systems
   4  *
   5  *  Copyright (C) 2007-2009 by Embedded and Real-Time Systems Laboratory
   6  *              Graduate School of Information Science, Nagoya Univ., JAPAN
   7  *
   8  *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
   9  *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
  10  *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
  11  *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
  12  *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
  13  *      スコード中に含まれていること．
  14  *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
  15  *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
  16  *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
  17  *      の無保証規定を掲載すること．
  18  *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
  19  *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
  20  *      と．
  21  *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
  22  *        作権表示，この利用条件および下記の無保証規定を掲載すること．
  23  *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
  24  *        報告すること．
  25  *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
  26  *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
  27  *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
  28  *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
  29  *      免責すること．
  30  *
  31  *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
  32  *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
  33  *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
  34  *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
  35  *  の責任を負わない．
  36  *
  37  *  @(#) $Id: test_mutex6.c 1696 2010-01-01 16:01:25Z ertl-hiro $
  38  */
  39
  40 /*
  41  *              ミューテックスのテスト(6)
  42  *
  43  * 【テストの目的】
  44  *
  45  *  優先度上限ミューテックスに対して，タスクの終了時，タスクの優先順位
  46  *  の回転時のミューテックス関連の処理を網羅的にテストする．
  47  *
  48  * 【テスト項目】
  49  *
  50  *      (A) タスクの終了時（ext_tsk）
  51  *              (A-1) ロックしていたミューテックス（1つ）がロック解除されること．
  52  *              (A-2) ロックしていたミューテックス（1つ）がロック解除され，ロッ
  53  *                        クを待っていたタスクがそれをロックし，優先度が変化し，待
  54  *                        ち解除されること．
  55  *              (A-3) ロックしていたミューテックス（複数）がすべてロック解除さ
  56  *                        れること．
  57  *              (A-4) ロックしていたミューテックス（複数）がロック解除され，ロッ
  58  *                        クを待っていたタスク（複数）がそれをロックし，優先度が変
  59  *                        化し，待ち解除されること．その時に，後でミューテックスを
  60  *                        ロックしたタスク（先にロックしていたミューテックスを待っ
  61  *                        ていたタスク）の方が，優先順位が高くなること．
  62  *      (B) タスクの優先順位の回転（rot_rdq）
  63  *              (B-1) TPRI_SELFを指定した時に，タスクのベース優先度の優先順位が
  64  *              　　　回転すること．
  65  *              (B-2) TPRI_SELFを指定した時に，タスクの現在優先度の優先順位が回
  66  *              　　　転しないこと．
  67  *
  68  * 【テスト項目の実現方法】
  69  *
  70  *      (A-1)
  71  *              低優先度タスク（TASK2）にミューテックス（MTX1）をロックさせ，
  72  *              ext_tskすると，ロックが解除されることを確認する．
  73  *      (A-2)
  74  *              低優先度タスク（TASK2）に高優先度上限ミューテックス（MTX1）をロッ
  75  *              クさせ，別の低優先度タスク（TASK3）にMTX1を待たせた状態で，
  76  *              TASK2 がext_tskすると，TASK3が高優先度になって待ち解除されるこ
  77  *              とを確認する．
  78  *      (A-3)
  79  *              低優先度タスク（TASK2）にミューテックスを2つ（MTX1，MTX2）ロッ
  80  *              クさせ，ext_tskすると，両方のロックが解除されることを確認する．
  81  *      (A-4)
  82  *              低優先度タスク（TASK2）に高優先度上限ミューテックス2つ（MTX1，
  83  *              MTX2）をこの順でロックさせ，別の低優先度タスク2つ（TASK3，
  84  *              TASK4）にそれぞれのロックを待たせた状態で，TASK2をext_tskすると，
  85  *              TASK3とTASK4が高優先度になって待ち解除されることを確認する．ま
  86  *              た，先にロックしていたミューテックス（MTX1）を待っていたタスク
  87  *              （TASK3）が，TASK4よりも優先順位が高くなることを確認する．
  88  *      (B-1)
  89  *              低優先度タスクが3つ（TASK2，TASK3，TASK4）が実行できる状態の時
  90  *              に，1つの低優先度タスク（TASK2）に高優先度上限ミューテックスを
  91  *              ロックさせ，rot_rdq(TPRI_SELF)すると，残りの2つの低優先度タスク
  92  *              の優先順位が回転することを確認する．
  93  *      (B-2)
  94  *              上と同じ状況で，高優先度タスクの優先順位が回転しないことを確認
  95  *              する．
  96  *
  97  * 【使用リソース】
  98  *
  99  *      TASK1: 低優先度タスク，メインタスク，最初から起動
 100  *      TASK2: 低優先度タスク
 101  *      TASK3: 低優先度タスク
 102  *      TASK4: 低優先度タスク
 103  *      MTX1: ミューテックス（TA_CEILING属性，上限は高優先度）
 104  *      MTX2: ミューテックス（TA_CEILING属性，上限は高優先度）
 105  *
 106  * 【テストシーケンス】
 107  *
 108  *      == TASK1（優先度：低）==
 109  *              call(set_bit_func(bit_mutex))
 110  *      1:      act_tsk(TASK2)
 111  *      2:      rot_rdq(TPRI_SELF)
 112  *      //              低：TASK2→TASK1
 113  *      == TASK2-1（優先度：低）1回め ==
 114  *      3:      loc_mtx(MTX1)
 115  *      //              高：TASK2，低：TASK1，MTX1：TASK2
 116  *      4:      ext_tsk() -> noreturn                   ... (A-1)
 117  *      //              低：TASK1
 118  *      == TASK1（続き）==
 119  *      5:      ref_mtx(MTX1, &rmtx)
 120  *              assert(rmtx.htskid == TSK_NONE)
 121  *              assert(rmtx.wtskid == TSK_NONE)
 122  *
 123  *      6:      act_tsk(TASK2)
 124  *              act_tsk(TASK3)
 125  *      7:      rot_rdq(TPRI_SELF)
 126  *      //              低：TASK2→TASK3→TASK1
 127  *      == TASK2-2（優先度：低）2回め ==
 128  *      8:      loc_mtx(MTX1)
 129  *      //              高：TASK2，低：TASK3→TASK1，MTX1：TASK2
 130  *      9:      slp_tsk()
 131  *      //              低：TASK3→TASK1，MTX1：TASK2
 132  *      == TASK3（優先度：低）==
 133  *      10:     loc_mtx(MTX1)
 134  *      //              低：TASK1，MTX1：TASK2→TASK3
 135  *      == TASK1（続き）==
 136  *      11:     wup_tsk(TASK2)
 137  *      //              高：TASK2，低：TASK1，MTX1：TASK2→TASK3
 138  *      == TASK2-2（続き）==
 139  *      12:     ext_tsk() -> noreturn                   ... (A-2)
 140  *      //              高：TASK3，低：TASK1，MTX1：TASK3
 141  *      == TASK3（続き）==
 142  *      13:     ref_mtx(MTX1, &rmtx)
 143  *              assert(rmtx.htskid == TASK3)
 144  *              assert(rmtx.wtskid == TSK_NONE)
 145  *              get_pri(TPRI_SELF, &tskpri)
 146  *              assert(tskpri == HIGH_PRIORITY)
 147  *              unl_mtx(MTX1)
 148  *              slp_tsk()
 149  *      //              低：TASK1
 150  *
 151  *      == TASK1（続き）==
 152  *      14:     act_tsk(TASK2)
 153  *      15:     rot_rdq(TPRI_SELF)
 154  *      //              低：TASK2→TASK1
 155  *      == TASK2-3（優先度：低）3回め ==
 156  *      16:     loc_mtx(MTX1)
 157  *              loc_mtx(MTX2)
 158  *      //              高：TASK2，低：TASK1，MTX1：TASK2，MTX2：TASK2
 159  *      17:     ext_tsk() -> noreturn                   ... (A-3)
 160  *      //              低：TASK1
 161  *      == TASK1（続き）==
 162  *      18:     ref_mtx(MTX1, &rmtx)
 163  *              assert(rmtx.htskid == TSK_NONE)
 164  *              assert(rmtx.wtskid == TSK_NONE)
 165  *              ref_mtx(MTX2, &rmtx)
 166  *              assert(rmtx.htskid == TSK_NONE)
 167  *              assert(rmtx.wtskid == TSK_NONE)
 168  *
 169  *      19:     act_tsk(TASK2)
 170  *              wup_tsk(TASK3)
 171  *              act_tsk(TASK4)
 172  *      20:     rot_rdq(TPRI_SELF)
 173  *      //              低：TASK2→TASK3→TASK4→TASK1
 174  *      == TASK2-4（優先度：低）4回め ==
 175  *      21:     loc_mtx(MTX1)
 176  *              loc_mtx(MTX2)
 177  *      //              高：TASK2，低：TASK3→TASK4→TASK1，MTX1：TASK2，MTX2：TASK2
 178  *      22:     chg_pri(TASK1, HIGH_PRIORITY)
 179  *      //              高：TASK2→TASK1，低：TASK3→TASK4，MTX1：TASK2，MTX2：TASK2
 180  *      23:     rot_rdq(TPRI_SELF)                              ... (B-1)(B-2)
 181  *      //              高：TASK2→TASK1，低：TASK4→TASK3，MTX1：TASK2，MTX2：TASK2
 182  *      24:     slp_tsk()
 183  *      //              高：TASK1，低：TASK4→TASK3，MTX1：TASK2，MTX2：TASK2
 184  *      == TASK1（続き）==
 185  *      25:     chg_pri(TSK_SELF, TPRI_INI)
 186  *      //              低：TASK4→TASK3→TASK1，MTX1：TASK2，MTX2：TASK2
 187  *      == TASK4（優先度：低）==
 188  *      26:     loc_mtx(MTX2)
 189  *      //              低：TASK3→TASK1，MTX1：TASK2，MTX2：TASK2→TASK4
 190  *      == TASK3（続き）==
 191  *      27:     loc_mtx(MTX1)
 192  *      //              低：TASK1，MTX1：TASK2→TASK3，MTX2：TASK2→TASK4
 193  *      == TASK1（続き）==
 194  *      28:     wup_tsk(TASK2)
 195  *      //              高：TASK2，低：TASK1，MTX1：TASK2→TASK3，MTX2：TASK2→TASK4
 196  *      == TASK2-4（続き）==
 197  *      29:     ext_tsk() -> noreturn                   ... (A-4)
 198  *      //              高：TASK3→TASK4，低：TASK1，MTX1：TASK3，MTX2：TASK4
 199  *      == TASK3（続き）==
 200  *      30:     ref_mtx(MTX1, &rmtx)
 201  *              assert(rmtx.htskid == TASK3)
 202  *              assert(rmtx.wtskid == TSK_NONE)
 203  *              ref_mtx(MTX2, &rmtx)
 204  *              assert(rmtx.htskid == TASK4)
 205  *              assert(rmtx.wtskid == TSK_NONE)
 206  *              get_pri(TPRI_SELF, &tskpri)
 207  *              assert(tskpri == HIGH_PRIORITY)
 208  *              ext_tsk() -> noreturn
 209  *      //              高：TASK4，低：TASK1，MTX2：TASK4
 210  *      == TASK4（続き）==
 211  *      31:     get_pri(TPRI_SELF, &tskpri)
 212  *              assert(tskpri == HIGH_PRIORITY)
 213  *              ext_tsk() -> noreturn
 214  *      //              低：TASK1
 215  *      == TASK1（続き）==
 216  *      32:     END
 217  */
 218
 219 #include <kernel.h>
 220 #include <t_syslog.h>
 221 #include "syssvc/logtask.h"
 222 #include "kernel_cfg.h"
 223 #include "test_lib.h"
 224 #include "test_mutex6.h"
 225
 226 extern ER       bit_mutex(void);
 227
 228 void
 229 task1(intptr_t exinf)
 230 {
 231         ER              ercd;
 232         T_RMTX  rmtx;
 233
 234         set_bit_func(bit_mutex);
 235
 236         check_point(1);
 237         ercd = act_tsk(TASK2);
 238         check_ercd(ercd, E_OK);
 239
 240         check_point(2);
 241         ercd = rot_rdq(TPRI_SELF);
 242         check_ercd(ercd, E_OK);
 243
 244         check_point(5);
 245         ercd = ref_mtx(MTX1, &rmtx);
 246         check_ercd(ercd, E_OK);
 247         check_assert(rmtx.htskid == TSK_NONE);
 248         check_assert(rmtx.wtskid == TSK_NONE);
 249
 250         check_point(6);
 251         ercd = act_tsk(TASK2);
 252         check_ercd(ercd, E_OK);
 253
 254         ercd = act_tsk(TASK3);
 255         check_ercd(ercd, E_OK);
 256
 257         check_point(7);
 258         ercd = rot_rdq(TPRI_SELF);
 259         check_ercd(ercd, E_OK);
 260
 261         check_point(11);
 262         ercd = wup_tsk(TASK2);
 263         check_ercd(ercd, E_OK);
 264
 265         check_point(14);
 266         ercd = act_tsk(TASK2);
 267         check_ercd(ercd, E_OK);
 268
 269         check_point(15);
 270         ercd = rot_rdq(TPRI_SELF);
 271         check_ercd(ercd, E_OK);
 272
 273         check_point(18);
 274         ercd = ref_mtx(MTX1, &rmtx);
 275         check_ercd(ercd, E_OK);
 276         check_assert(rmtx.htskid == TSK_NONE);
 277         check_assert(rmtx.wtskid == TSK_NONE);
 278
 279         ercd = ref_mtx(MTX2, &rmtx);
 280         check_ercd(ercd, E_OK);
 281         check_assert(rmtx.htskid == TSK_NONE);
 282         check_assert(rmtx.wtskid == TSK_NONE);
 283
 284         check_point(19);
 285         ercd = act_tsk(TASK2);
 286         check_ercd(ercd, E_OK);
 287
 288         ercd = wup_tsk(TASK3);
 289         check_ercd(ercd, E_OK);
 290
 291         ercd = act_tsk(TASK4);
 292         check_ercd(ercd, E_OK);
 293
 294         check_point(20);
 295         ercd = rot_rdq(TPRI_SELF);
 296         check_ercd(ercd, E_OK);
 297
 298         check_point(25);
 299         ercd = chg_pri(TSK_SELF, TPRI_INI);
 300         check_ercd(ercd, E_OK);
 301
 302         check_point(28);
 303         ercd = wup_tsk(TASK2);
 304         check_ercd(ercd, E_OK);
 305
 306         check_finish(32);
 307
 308         check_point(0);
 309 }
 310
 311 static uint_t   task2_count = 0;
 312
 313 void
 314 task2(intptr_t exinf)
 315 {
 316         ER              ercd;
 317
 318         switch (++task2_count) {
 319         case 1:
 320                 check_point(3);
 321                 ercd = loc_mtx(MTX1);
 322                 check_ercd(ercd, E_OK);
 323
 324                 check_point(4);
 325                 ercd = ext_tsk();
 326
 327                 check_point(0);
 328
 329         case 2:
 330                 check_point(8);
 331                 ercd = loc_mtx(MTX1);
 332                 check_ercd(ercd, E_OK);
 333
 334                 check_point(9);
 335                 ercd = slp_tsk();
 336                 check_ercd(ercd, E_OK);
 337
 338                 check_point(12);
 339                 ercd = ext_tsk();
 340
 341                 check_point(0);
 342
 343         case 3:
 344                 check_point(16);
 345                 ercd = loc_mtx(MTX1);
 346                 check_ercd(ercd, E_OK);
 347
 348                 ercd = loc_mtx(MTX2);
 349                 check_ercd(ercd, E_OK);
 350
 351                 check_point(17);
 352                 ercd = ext_tsk();
 353
 354                 check_point(0);
 355
 356         case 4:
 357                 check_point(21);
 358                 ercd = loc_mtx(MTX1);
 359                 check_ercd(ercd, E_OK);
 360
 361                 ercd = loc_mtx(MTX2);
 362                 check_ercd(ercd, E_OK);
 363
 364                 check_point(22);
 365                 ercd = chg_pri(TASK1, HIGH_PRIORITY);
 366                 check_ercd(ercd, E_OK);
 367
 368                 check_point(23);
 369                 ercd = rot_rdq(TPRI_SELF);
 370                 check_ercd(ercd, E_OK);
 371
 372                 check_point(24);
 373                 ercd = slp_tsk();
 374                 check_ercd(ercd, E_OK);
 375
 376                 check_point(29);
 377                 ercd = ext_tsk();
 378
 379                 check_point(0);
 380         }
 381         check_point(0);
 382 }
 383
 384 void
 385 task3(intptr_t exinf)
 386 {
 387         ER              ercd;
 388         PRI             tskpri;
 389         T_RMTX  rmtx;
 390
 391         check_point(10);
 392         ercd = loc_mtx(MTX1);
 393         check_ercd(ercd, E_OK);
 394
 395         check_point(13);
 396         ercd = ref_mtx(MTX1, &rmtx);
 397         check_ercd(ercd, E_OK);
 398         check_assert(rmtx.htskid == TASK3);
 399         check_assert(rmtx.wtskid == TSK_NONE);
 400
 401         ercd = get_pri(TPRI_SELF, &tskpri);
 402         check_ercd(ercd, E_OK);
 403         check_assert(tskpri == HIGH_PRIORITY);
 404
 405         ercd = unl_mtx(MTX1);
 406         check_ercd(ercd, E_OK);
 407
 408         ercd = slp_tsk();
 409         check_ercd(ercd, E_OK);
 410
 411         check_point(27);
 412         ercd = loc_mtx(MTX1);
 413         check_ercd(ercd, E_OK);
 414
 415         check_point(30);
 416         ercd = ref_mtx(MTX1, &rmtx);
 417         check_ercd(ercd, E_OK);
 418         check_assert(rmtx.htskid == TASK3);
 419         check_assert(rmtx.wtskid == TSK_NONE);
 420
 421         ercd = ref_mtx(MTX2, &rmtx);
 422         check_ercd(ercd, E_OK);
 423         check_assert(rmtx.htskid == TASK4);
 424         check_assert(rmtx.wtskid == TSK_NONE);
 425
 426         ercd = get_pri(TPRI_SELF, &tskpri);
 427         check_ercd(ercd, E_OK);
 428         check_assert(tskpri == HIGH_PRIORITY);
 429
 430         ercd = ext_tsk();
 431
 432         check_point(0);
 433 }
 434
 435 void
 436 task4(intptr_t exinf)
 437 {
 438         ER              ercd;
 439         PRI             tskpri;
 440
 441         check_point(26);
 442         ercd = loc_mtx(MTX2);
 443         check_ercd(ercd, E_OK);
 444
 445         check_point(31);
 446         ercd = get_pri(TPRI_SELF, &tskpri);
 447         check_ercd(ercd, E_OK);
 448         check_assert(tskpri == HIGH_PRIORITY);
 449
 450         ercd = ext_tsk();
 451
 452         check_point(0);
 453 }