asp/extension/mutex/test/test_mutex3.c

   1 /*
   2  *  TOPPERS Software
   3  *      Toyohashi Open Platform for Embedded Real-Time Systems
   4  *
   5  *  Copyright (C) 2007,2008 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_mutex3.c 1696 2010-01-01 16:01:25Z ertl-hiro $
  38  */
  39
  40 /*
  41  *              ミューテックスのテスト(3)
  42  *
  43  * 【テストの目的】
  44  *
  45  *  優先度上限ミューテックスを，ロックする処理とロック解除する処理を一
  46  *  通りテストする．ref_tskによるベース優先度と現在優先度の参照処理のテ
  47  *  ストも兼ねている．
  48  *
  49  * 【テスト項目】
  50  *
  51  *      (A) ミューテックスのロック処理（loc_mtx）
  52  *              (A-1) ロックされていない場合には，すぐにロックできること
  53  *              (A-2) 多重にロックしようとすると，E_ILUSEエラーになること
  54  *              (A-3) ロックされている場合には，優先度順で待ち状態になること
  55  *      (B) ミューテックスのロック解除処理（unl_mtx）
  56  *              (B-1) 他タスクがロックしているミューテックスを解放しようとすると
  57  *              　　　E_ILUSEエラーになること
  58  *              (B-2) 待ちタスクがないと，単にロック解除すること
  59  *              (B-3) 待ちタスクにロックを渡すこと
  60  *              (B-4) 待ちタスクにロックを渡して，ディスパッチが起こること
  61  *      (C) ミューテックスのロック処理（ploc_mtx）
  62  *              (C-1) ロックされている場合には，すぐにE_TMOUTエラーになること
  63  *      (D) ミューテックスのロック処理（tloc_mtx）
  64  *              (D-1) ロックされている場合には，タイムアウト付きの待ち状態にな
  65  *              　　　ること
  66  *      (E) おまけ
  67  *              (E-1) タスクを終了すると，ミューテックスをロック解除すること
  68  *
  69  * 【使用リソース】
  70  *
  71  *      TASK1: 低優先度タスク，メインタスク，最初から起動
  72  *      TASK2: 中優先度タスク
  73  *      TASK3: 高優先度タスク
  74  *      MTX1: ミューテックス（TA_CEILING属性，上限は高優先度）
  75  *
  76  * 【テストシーケンス】
  77  *
  78  *      == TASK1（優先度：低）==
  79  *              call(set_bit_func(bit_mutex))
  80  *      1:      ref_mtx(MTX1, &rmtx)
  81  *              assert(rmtx.htskid == TSK_NONE)
  82  *              assert(rmtx.wtskid == TSK_NONE)
  83  *              loc_mtx(MTX1)                                   ... (A-1)
  84  *      2:      ref_tsk(TASK1, &rtsk)
  85  *              assert(rtsk.tskpri == HIGH_PRIORITY)
  86  *              assert(rtsk.tskbpri == LOW_PRIORITY)
  87  *              loc_mtx(MTX1) -> E_ILUSE                ... (A-2)
  88  *      3:      ref_mtx(MTX1, &rmtx)
  89  *              assert(rmtx.htskid == TASK1)
  90  *              assert(rmtx.wtskid == TSK_NONE)
  91  *              act_tsk(TASK2)
  92  *      4:      tslp_tsk(10) -> E_TMOUT
  93  *      == TASK2（優先度：中）==
  94  *      5:      ploc_mtx(MTX1) -> E_TMOUT               ... (C-1)
  95  *              loc_mtx(MTX1)                                   ... (A-3)
  96  *      == TASK1（続き）==
  97  *      6:      ref_mtx(MTX1, &rmtx)
  98  *              assert(rmtx.htskid == TASK1)
  99  *              assert(rmtx.wtskid == TASK2)
 100  *              act_tsk(TASK3)
 101  *      7:      tslp_tsk(10) -> E_TMOUT
 102  *      == TASK3（優先度：高）==
 103  *      8:      unl_mtx(MTX1) -> E_ILUSE                ... (B-1)
 104  *      9:      loc_mtx(MTX1)                                   ... (A-3)
 105  *      == TASK1（続き）==
 106  *      10:     ref_mtx(MTX1, &rmtx)
 107  *              assert(rmtx.htskid == TASK1)
 108  *              assert(rmtx.wtskid == TASK3)
 109  *              dis_dsp()
 110  *              unl_mtx(MTX1)                                   ... (B-3)
 111  *      11:     ref_tsk(TASK1, &rtsk)
 112  *              assert(rtsk.tskpri == LOW_PRIORITY)
 113  *              assert(rtsk.tskbpri == LOW_PRIORITY)
 114  *              ref_mtx(MTX1, &rmtx)
 115  *              assert(rmtx.htskid == TASK3)
 116  *              assert(rmtx.wtskid == TASK2)
 117  *              ena_dsp()
 118  *      == TASK3（続き）==
 119  *      12:     ext_tsk() -> noreturn                   ... (E-1)
 120  *      == TASK2（続き）==
 121  *      13:     ref_tsk(TASK2, &rtsk)
 122  *              assert(rtsk.tskpri == HIGH_PRIORITY)
 123  *              assert(rtsk.tskbpri == MID_PRIORITY)
 124  *              unl_mtx(MTX1)                                   ... (B-4)
 125  *      14:     loc_mtx(MTX1)
 126  *      15:     slp_tsk()
 127  *      == TASK1（続き）==
 128  *      16:     ref_mtx(MTX1, &rmtx)
 129  *              assert(rmtx.htskid == TASK2)
 130  *              assert(rmtx.wtskid == TSK_NONE)
 131  *              tloc_mtx(MTX1, 10) -> E_TMOUT   ... (D-1)
 132  *      17:     wup_tsk(TASK2)
 133  *      == TASK2（続き）==
 134  *      18:     unl_mtx(MTX1)                                   ... (B-2)
 135  *      19:     ext_tsk() -> noreturn
 136  *      == TASK1（続き）==
 137  *      20:     END
 138  */
 139
 140 #include <kernel.h>
 141 #include <t_syslog.h>
 142 #include "syssvc/logtask.h"
 143 #include "kernel_cfg.h"
 144 #include "test_lib.h"
 145 #include "test_mutex.h"
 146
 147 extern ER       bit_mutex(void);
 148
 149 void
 150 task1(intptr_t exinf)
 151 {
 152         ER              ercd;
 153         T_RTSK  rtsk;
 154         T_RMTX  rmtx;
 155
 156         set_bit_func(bit_mutex);
 157
 158         check_point(1);
 159         ercd = ref_mtx(MTX1, &rmtx);
 160         check_ercd(ercd, E_OK);
 161         check_assert(rmtx.htskid == TSK_NONE);
 162         check_assert(rmtx.wtskid == TSK_NONE);
 163
 164         ercd = loc_mtx(MTX1);
 165         check_ercd(ercd, E_OK);
 166
 167         check_point(2);
 168         ercd = ref_tsk(TASK1, &rtsk);
 169         check_ercd(ercd, E_OK);
 170         check_assert(rtsk.tskpri == HIGH_PRIORITY);
 171         check_assert(rtsk.tskbpri == LOW_PRIORITY);
 172
 173         ercd = loc_mtx(MTX1);
 174         check_ercd(ercd, E_ILUSE);
 175
 176         check_point(3);
 177         ercd = ref_mtx(MTX1, &rmtx);
 178         check_ercd(ercd, E_OK);
 179         check_assert(rmtx.htskid == TASK1);
 180         check_assert(rmtx.wtskid == TSK_NONE);
 181
 182         ercd = act_tsk(TASK2);
 183         check_ercd(ercd, E_OK);
 184
 185         check_point(4);
 186         ercd = tslp_tsk(10);
 187         check_ercd(ercd, E_TMOUT);
 188
 189         check_point(6);
 190         ercd = ref_mtx(MTX1, &rmtx);
 191         check_ercd(ercd, E_OK);
 192         check_assert(rmtx.htskid == TASK1);
 193         check_assert(rmtx.wtskid == TASK2);
 194
 195         ercd = act_tsk(TASK3);
 196         check_ercd(ercd, E_OK);
 197
 198         check_point(7);
 199         ercd = tslp_tsk(10);
 200         check_ercd(ercd, E_TMOUT);
 201
 202         check_point(10);
 203         ercd = ref_mtx(MTX1, &rmtx);
 204         check_ercd(ercd, E_OK);
 205         check_assert(rmtx.htskid == TASK1);
 206         check_assert(rmtx.wtskid == TASK3);
 207
 208         ercd = dis_dsp();
 209         check_ercd(ercd, E_OK);
 210
 211         ercd = unl_mtx(MTX1);
 212         check_ercd(ercd, E_OK);
 213
 214         check_point(11);
 215         ercd = ref_tsk(TASK1, &rtsk);
 216         check_ercd(ercd, E_OK);
 217         check_assert(rtsk.tskpri == LOW_PRIORITY);
 218         check_assert(rtsk.tskbpri == LOW_PRIORITY);
 219
 220         ercd = ref_mtx(MTX1, &rmtx);
 221         check_ercd(ercd, E_OK);
 222         check_assert(rmtx.htskid == TASK3);
 223         check_assert(rmtx.wtskid == TASK2);
 224
 225         ercd = ena_dsp();
 226         check_ercd(ercd, E_OK);
 227
 228         check_point(16);
 229         ercd = ref_mtx(MTX1, &rmtx);
 230         check_ercd(ercd, E_OK);
 231         check_assert(rmtx.htskid == TASK2);
 232         check_assert(rmtx.wtskid == TSK_NONE);
 233
 234         ercd = tloc_mtx(MTX1, 10);
 235         check_ercd(ercd, E_TMOUT);
 236
 237         check_point(17);
 238         ercd = wup_tsk(TASK2);
 239         check_ercd(ercd, E_OK);
 240
 241         check_finish(20);
 242
 243         check_point(0);
 244 }
 245
 246 void
 247 task2(intptr_t exinf)
 248 {
 249         ER              ercd;
 250         T_RTSK  rtsk;
 251
 252         check_point(5);
 253         ercd = ploc_mtx(MTX1);
 254         check_ercd(ercd, E_TMOUT);
 255
 256         ercd = loc_mtx(MTX1);
 257         check_ercd(ercd, E_OK);
 258
 259         check_point(13);
 260         ercd = ref_tsk(TASK2, &rtsk);
 261         check_ercd(ercd, E_OK);
 262         check_assert(rtsk.tskpri == HIGH_PRIORITY);
 263         check_assert(rtsk.tskbpri == MID_PRIORITY);
 264
 265         ercd = unl_mtx(MTX1);
 266         check_ercd(ercd, E_OK);
 267
 268         check_point(14);
 269         ercd = loc_mtx(MTX1);
 270         check_ercd(ercd, E_OK);
 271
 272         check_point(15);
 273         ercd = slp_tsk();
 274         check_ercd(ercd, E_OK);
 275
 276         check_point(18);
 277         ercd = unl_mtx(MTX1);
 278         check_ercd(ercd, E_OK);
 279
 280         check_point(19);
 281         ercd = ext_tsk();
 282
 283         check_point(0);
 284 }
 285
 286 void
 287 task3(intptr_t exinf)
 288 {
 289         ER              ercd;
 290
 291         check_point(8);
 292         ercd = unl_mtx(MTX1);
 293         check_ercd(ercd, E_ILUSE);
 294
 295         check_point(9);
 296         ercd = loc_mtx(MTX1);
 297         check_ercd(ercd, E_OK);
 298
 299         check_point(12);
 300         ercd = ext_tsk();
 301
 302         check_point(0);
 303 }