Changeset f6142c19 in rtems for testsuites/smptests


Ignore:
Timestamp:
Sep 9, 2016, 9:00:06 AM (3 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
master
Children:
4d3c866
Parents:
8123cae8
git-author:
Sebastian Huber <sebastian.huber@…> (09/09/16 09:00:06)
git-committer:
Sebastian Huber <sebastian.huber@…> (09/21/16 06:59:33)
Message:

score: Scheduler node awareness for thread queues

Maintain the priority of a thread for each scheduler instance via the
thread queue enqueue, extract, priority actions and surrender
operations. This replaces the primitive priority boosting.

Update #2556.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • testsuites/smptests/smpmutex01/init.c

    r8123cae8 rf6142c19  
    11/*
    2  * Copyright (c) 2015 embedded brains GmbH.  All rights reserved.
     2 * Copyright (c) 2015, 2016 embedded brains GmbH.  All rights reserved.
    33 *
    44 *  embedded brains GmbH
     
    2929#define TASK_COUNT 9
    3030
     31#define PRIO_NONE 0
     32
     33/* Value choosen for Qemu, 2 would be sufficient for real targets */
     34#define TIMEOUT_IN_TICKS 10
     35
    3136typedef enum {
    3237  REQ_WAKE_UP_MASTER = RTEMS_EVENT_0,
    3338  REQ_WAKE_UP_HELPER = RTEMS_EVENT_1,
    3439  REQ_MTX_OBTAIN = RTEMS_EVENT_2,
    35   REQ_MTX_RELEASE = RTEMS_EVENT_3
     40  REQ_MTX_OBTAIN_TIMEOUT = RTEMS_EVENT_3,
     41  REQ_MTX_RELEASE = RTEMS_EVENT_4,
     42  REQ_MTX_2_OBTAIN = RTEMS_EVENT_5,
     43  REQ_MTX_2_RELEASE = RTEMS_EVENT_6,
     44  REQ_SEM_OBTAIN_RELEASE = RTEMS_EVENT_7,
     45  REQ_SEM_RELEASE = RTEMS_EVENT_8
    3646} request_id;
    3747
     
    5161typedef struct {
    5262  rtems_id mtx;
     63  rtems_id mtx_2;
     64  rtems_id sem;
    5365  rtems_id tasks[TASK_COUNT];
    5466  int generation[TASK_COUNT];
     
    157169}
    158170
     171static void obtain_timeout(test_context *ctx)
     172{
     173  rtems_status_code sc;
     174
     175  sc = rtems_semaphore_obtain(ctx->mtx, RTEMS_WAIT, TIMEOUT_IN_TICKS);
     176  rtems_test_assert(sc == RTEMS_TIMEOUT);
     177}
     178
    159179static void release(test_context *ctx)
    160180{
     
    162182
    163183  sc = rtems_semaphore_release(ctx->mtx);
     184  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     185}
     186
     187static void obtain_2(test_context *ctx)
     188{
     189  rtems_status_code sc;
     190
     191  sc = rtems_semaphore_obtain(ctx->mtx_2, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     192  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     193}
     194
     195static void release_2(test_context *ctx)
     196{
     197  rtems_status_code sc;
     198
     199  sc = rtems_semaphore_release(ctx->mtx_2);
     200  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     201}
     202
     203static void sem_obtain(test_context *ctx)
     204{
     205  rtems_status_code sc;
     206
     207  sc = rtems_semaphore_obtain(ctx->sem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     208  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     209}
     210
     211static void sem_release(test_context *ctx)
     212{
     213  rtems_status_code sc;
     214
     215  sc = rtems_semaphore_release(ctx->sem);
     216  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     217}
     218
     219static void wait(void)
     220{
     221  rtems_status_code sc;
     222
     223  sc = rtems_task_wake_after(TIMEOUT_IN_TICKS + 1);
    164224  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
    165225}
     
    200260}
    201261
     262static void assert_prio_by_scheduler(
     263  test_context *ctx,
     264  task_id id,
     265  rtems_name scheduler,
     266  rtems_task_priority expected
     267)
     268{
     269  rtems_task_priority actual;
     270  rtems_status_code sc;
     271  rtems_id scheduler_id;
     272
     273  sc = rtems_scheduler_ident(scheduler, &scheduler_id);
     274  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     275
     276  actual = PRIO_NONE;
     277  sc = rtems_task_get_priority(
     278    ctx->tasks[id],
     279    scheduler_id,
     280    &actual
     281  );
     282
     283  if (expected == PRIO_NONE) {
     284    rtems_test_assert(sc == RTEMS_NOT_DEFINED);
     285  } else {
     286    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     287  }
     288
     289  rtems_test_assert(actual == expected);
     290}
     291
    202292static void helper(rtems_task_argument arg)
    203293{
     
    206296  while (true) {
    207297    rtems_event_set events = wait_for_events();
    208     rtems_test_assert(events == REQ_WAKE_UP_HELPER);
    209     send_event(ctx, M, REQ_WAKE_UP_MASTER);
     298
     299    if ((events & REQ_WAKE_UP_HELPER) != 0) {
     300      send_event(ctx, M, REQ_WAKE_UP_MASTER);
     301    }
     302
     303    if ((events & REQ_SEM_RELEASE) != 0) {
     304      sem_release(ctx);
     305    }
    210306  }
    211307}
     
    224320    }
    225321
     322    if ((events & REQ_MTX_OBTAIN_TIMEOUT) != 0) {
     323      obtain_timeout(ctx);
     324      ++ctx->generation[id];
     325    }
     326
    226327    if ((events & REQ_MTX_RELEASE) != 0) {
    227328      release(ctx);
    228329      ++ctx->generation[id];
     330    }
     331
     332    if ((events & REQ_MTX_2_OBTAIN) != 0) {
     333      obtain_2(ctx);
     334      ++ctx->generation[id];
     335    }
     336
     337    if ((events & REQ_MTX_2_RELEASE) != 0) {
     338      release_2(ctx);
     339      ++ctx->generation[id];
     340    }
     341
     342    if ((events & REQ_SEM_OBTAIN_RELEASE) != 0) {
     343      sem_obtain(ctx);
     344      ++ctx->generation[id];
     345      sem_release(ctx);
    229346    }
    230347  }
     
    246363
    247364  sc = rtems_semaphore_create(
    248     rtems_build_name(' ', 'M', 'T', 'X'),
     365    rtems_build_name('M', 'T', 'X', '1'),
    249366    1,
    250367    RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
    251368    0,
    252369    &ctx->mtx
     370  );
     371  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     372
     373  sc = rtems_semaphore_create(
     374    rtems_build_name('M', 'T', 'X', '2'),
     375    1,
     376    RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY,
     377    0,
     378    &ctx->mtx_2
     379  );
     380  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     381
     382  sc = rtems_semaphore_create(
     383    rtems_build_name(' ', 'S', 'E', 'M'),
     384    0,
     385    RTEMS_COUNTING_SEMAPHORE | RTEMS_PRIORITY,
     386    0,
     387    &ctx->sem
    253388  );
    254389  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
     
    288423}
    289424
    290 static void test_simple_boosting(test_context *ctx)
     425static void test_mixed_queue_two_scheduler_instances(test_context *ctx)
    291426{
    292427  obtain(ctx);
     428  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     429  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     430
     431  request(ctx, B_4, REQ_MTX_OBTAIN_TIMEOUT);
     432  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     433  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     434  check_generations(ctx, NONE, NONE);
     435  wait();
     436  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     437  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     438  check_generations(ctx, B_4, NONE);
     439
     440  request(ctx, B_4, REQ_MTX_OBTAIN);
     441  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     442  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     443  check_generations(ctx, NONE, NONE);
     444
     445  request(ctx, B_5_0, REQ_SEM_OBTAIN_RELEASE);
     446  send_event(ctx, H_A, REQ_SEM_RELEASE);
     447  check_generations(ctx, NONE, NONE);
     448
     449  /*
     450   * We are in scheduler instance A.  Task B_5_0 of scheduler instance B issued
     451   * the counting semaphore obtain before us.  However, we inherited the
     452   * priority of B_4, so we get the semaphore before B_5_0 (priority order
     453   * within scheduler instance B).
     454   */
     455  sem_obtain(ctx);
     456  check_generations(ctx, NONE, NONE);
     457
     458  release(ctx);
     459  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     460  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     461  sync_with_helper(ctx);
     462  check_generations(ctx, B_4, NONE);
     463
     464  request(ctx, B_4, REQ_MTX_RELEASE);
     465  check_generations(ctx, B_4, NONE);
     466
     467  sem_release(ctx);
     468  sync_with_helper(ctx);
     469  check_generations(ctx, B_5_0, NONE);
     470
     471  sem_obtain(ctx);
     472}
     473
     474static void test_mixed_queue_two_scheduler_instances_sem_only(test_context *ctx)
     475{
     476  request(ctx, B_5_0, REQ_SEM_OBTAIN_RELEASE);
     477  send_event(ctx, H_A, REQ_SEM_RELEASE);
     478  check_generations(ctx, NONE, NONE);
     479
     480  /*
     481   * We are in scheduler instance A.  Task B_5_0 of scheduler instance B issued
     482   * the counting semaphore obtain before us.  No priority inheritance is
     483   * involved, so task B_5_0 gets the counting semaphore first.
     484   */
     485  sem_obtain(ctx);
     486  check_generations(ctx, B_5_0, NONE);
     487
     488  sem_release(ctx);
     489}
     490
     491static void test_simple_inheritance_two_scheduler_instances(test_context *ctx)
     492{
     493  obtain(ctx);
     494  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     495  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     496
    293497  request(ctx, B_5_0, REQ_MTX_OBTAIN);
     498  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     499  assert_prio_by_scheduler(ctx, M, SCHED_B, 5);
     500
    294501  request(ctx, B_4, REQ_MTX_OBTAIN);
     502  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     503  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     504
    295505  request(ctx, B_5_1, REQ_MTX_OBTAIN);
    296   check_generations(ctx, NONE, NONE);
    297   assert_prio(ctx, M, 0);
     506  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     507  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     508  check_generations(ctx, NONE, NONE);
     509
     510  release(ctx);
     511  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     512  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     513  sync_with_helper(ctx);
     514  check_generations(ctx, B_4, NONE);
     515
     516  request(ctx, B_4, REQ_MTX_RELEASE);
     517  check_generations(ctx, B_4, B_5_0);
     518
     519  request(ctx, B_5_0, REQ_MTX_RELEASE);
     520  check_generations(ctx, B_5_0, B_5_1);
     521
     522  request(ctx, B_5_1, REQ_MTX_RELEASE);
     523  check_generations(ctx, B_5_1, NONE);
     524}
     525
     526static void test_nested_inheritance_two_scheduler_instances(test_context *ctx)
     527{
     528  obtain_2(ctx);
     529  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     530  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     531
     532  request(ctx, B_5_0, REQ_MTX_OBTAIN);
     533  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     534  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     535  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE);
     536  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5);
     537  check_generations(ctx, B_5_0, NONE);
     538
     539  request(ctx, B_5_0, REQ_MTX_2_OBTAIN);
     540  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     541  assert_prio_by_scheduler(ctx, M, SCHED_B, 5);
     542  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE);
     543  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5);
     544
     545  request(ctx, B_4, REQ_MTX_OBTAIN_TIMEOUT);
     546  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     547  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     548  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE);
     549  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 4);
     550  wait();
     551  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     552  assert_prio_by_scheduler(ctx, M, SCHED_B, 5);
     553  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE);
     554  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5);
     555  check_generations(ctx, B_4, NONE);
     556
     557  request(ctx, B_4, REQ_MTX_OBTAIN);
     558  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     559  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     560  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE);
     561  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 4);
     562
     563  request(ctx, B_5_1, REQ_MTX_2_OBTAIN);
     564  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     565  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     566  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE);
     567  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 4);
     568  check_generations(ctx, NONE, NONE);
     569
     570  release_2(ctx);
     571  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     572  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     573  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE);
     574  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 4);
     575  sync_with_helper(ctx);
     576  check_generations(ctx, B_5_0, NONE);
     577
     578  request(ctx, B_5_0, REQ_MTX_RELEASE);
     579  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE);
     580  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5);
     581  check_generations(ctx, B_4, B_5_0);
     582
     583  request(ctx, B_4, REQ_MTX_RELEASE);
     584  check_generations(ctx, B_4, NONE);
     585
     586  request(ctx, B_5_0, REQ_MTX_2_RELEASE);
     587  check_generations(ctx, B_5_0, B_5_1);
     588
     589  request(ctx, B_5_1, REQ_MTX_2_RELEASE);
     590  check_generations(ctx, B_5_1, NONE);
     591}
     592
     593static void test_dequeue_order_two_scheduler_instances(test_context *ctx)
     594{
     595  obtain(ctx);
     596  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     597  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     598
     599  request(ctx, A_2_0, REQ_MTX_OBTAIN);
     600  assert_prio_by_scheduler(ctx, M, SCHED_A, 2);
     601  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     602  check_generations(ctx, NONE, NONE);
     603
     604  request(ctx, B_5_0, REQ_MTX_OBTAIN);
     605  assert_prio_by_scheduler(ctx, M, SCHED_A, 2);
     606  assert_prio_by_scheduler(ctx, M, SCHED_B, 5);
     607  check_generations(ctx, NONE, NONE);
     608
     609  request(ctx, B_5_1, REQ_MTX_OBTAIN);
     610  assert_prio_by_scheduler(ctx, M, SCHED_A, 2);
     611  assert_prio_by_scheduler(ctx, M, SCHED_B, 5);
     612
     613  request(ctx, B_4, REQ_MTX_OBTAIN);
     614  assert_prio_by_scheduler(ctx, M, SCHED_A, 2);
     615  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     616
     617  request(ctx, A_2_1, REQ_MTX_OBTAIN);
     618  assert_prio_by_scheduler(ctx, M, SCHED_A, 2);
     619  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     620
     621  request(ctx, A_1, REQ_MTX_OBTAIN);
     622  assert_prio_by_scheduler(ctx, M, SCHED_A, 1);
     623  assert_prio_by_scheduler(ctx, M, SCHED_B, 4);
     624  check_generations(ctx, NONE, NONE);
     625
    298626  release(ctx);
    299627  sync_with_helper(ctx);
    300   assert_prio(ctx, M, 3);
    301   check_generations(ctx, B_4, NONE);
     628  assert_prio_by_scheduler(ctx, M, SCHED_A, 3);
     629  assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE);
     630  assert_prio_by_scheduler(ctx, A_1, SCHED_A, 1);
     631  assert_prio_by_scheduler(ctx, A_1, SCHED_B, 4);
     632  check_generations(ctx, A_1, NONE);
     633
     634  request(ctx, A_1, REQ_MTX_RELEASE);
     635  assert_prio_by_scheduler(ctx, A_1, SCHED_A, 1);
     636  assert_prio_by_scheduler(ctx, A_1, SCHED_B, PRIO_NONE);
     637  assert_prio_by_scheduler(ctx, B_4, SCHED_A, 2);
     638  assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4);
     639  check_generations(ctx, A_1, B_4);
     640
    302641  request(ctx, B_4, REQ_MTX_RELEASE);
    303   check_generations(ctx, B_4, B_5_0);
     642  assert_prio_by_scheduler(ctx, B_4, SCHED_A, PRIO_NONE);
     643  assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4);
     644  assert_prio_by_scheduler(ctx, A_2_0, SCHED_A, 2);
     645  assert_prio_by_scheduler(ctx, A_2_0, SCHED_B, 5);
     646  check_generations(ctx, B_4, A_2_0);
     647
     648  request(ctx, A_2_0, REQ_MTX_RELEASE);
     649  assert_prio_by_scheduler(ctx, A_2_0, SCHED_A, 2);
     650  assert_prio_by_scheduler(ctx, A_2_0, SCHED_B, PRIO_NONE);
     651  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, 2);
     652  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5);
     653  check_generations(ctx, A_2_0, B_5_0);
     654
    304655  request(ctx, B_5_0, REQ_MTX_RELEASE);
    305   check_generations(ctx, B_5_0, B_5_1);
     656  assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE);
     657  assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5);
     658  assert_prio_by_scheduler(ctx, A_2_1, SCHED_A, 2);
     659  assert_prio_by_scheduler(ctx, A_2_1, SCHED_B, 5);
     660  check_generations(ctx, B_5_0, A_2_1);
     661
     662  request(ctx, A_2_1, REQ_MTX_RELEASE);
     663  assert_prio_by_scheduler(ctx, A_2_1, SCHED_A, 2);
     664  assert_prio_by_scheduler(ctx, A_2_1, SCHED_B, PRIO_NONE);
     665  assert_prio_by_scheduler(ctx, B_5_1, SCHED_A, PRIO_NONE);
     666  assert_prio_by_scheduler(ctx, B_5_1, SCHED_B, 5);
     667  check_generations(ctx, A_2_1, B_5_1);
     668
    306669  request(ctx, B_5_1, REQ_MTX_RELEASE);
     670  assert_prio_by_scheduler(ctx, B_5_1, SCHED_A, PRIO_NONE);
     671  assert_prio_by_scheduler(ctx, B_5_1, SCHED_B, 5);
    307672  check_generations(ctx, B_5_1, NONE);
    308 }
    309 
    310 static void test_dequeue_order_two_scheduler_instances(test_context *ctx)
    311 {
    312   obtain(ctx);
    313   request(ctx, A_2_0, REQ_MTX_OBTAIN);
    314   check_generations(ctx, NONE, NONE);
    315   assert_prio(ctx, M, 2);
    316   request(ctx, B_5_0, REQ_MTX_OBTAIN);
    317   check_generations(ctx, NONE, NONE);
    318   assert_prio(ctx, M, 0);
    319   request(ctx, B_5_1, REQ_MTX_OBTAIN);
    320   request(ctx, B_4, REQ_MTX_OBTAIN);
    321   request(ctx, A_2_1, REQ_MTX_OBTAIN);
    322   request(ctx, A_1, REQ_MTX_OBTAIN);
    323   check_generations(ctx, NONE, NONE);
    324   release(ctx);
    325   sync_with_helper(ctx);
    326   check_generations(ctx, A_1, NONE);
    327   assert_prio(ctx, M, 3);
    328   assert_prio(ctx, A_1, 0);
    329   request(ctx, A_1, REQ_MTX_RELEASE);
    330   check_generations(ctx, A_1, B_4);
    331   assert_prio(ctx, A_1, 1);
    332   assert_prio(ctx, B_4, 0);
    333   request(ctx, B_4, REQ_MTX_RELEASE);
    334   check_generations(ctx, B_4, A_2_0);
    335   assert_prio(ctx, B_4, 4);
    336   assert_prio(ctx, A_2_0, 0);
    337   request(ctx, A_2_0, REQ_MTX_RELEASE);
    338   check_generations(ctx, A_2_0, B_5_0);
    339   assert_prio(ctx, A_2_0, 2);
    340   assert_prio(ctx, B_5_0, 0);
    341   request(ctx, B_5_0, REQ_MTX_RELEASE);
    342   check_generations(ctx, B_5_0, A_2_1);
    343   assert_prio(ctx, B_5_0, 5);
    344   assert_prio(ctx, A_2_1, 2);
    345   request(ctx, A_2_1, REQ_MTX_RELEASE);
    346   check_generations(ctx, A_2_1, B_5_1);
    347   assert_prio(ctx, B_5_1, 5);
    348   request(ctx, B_5_1, REQ_MTX_RELEASE);
    349   check_generations(ctx, B_5_1, NONE);
    350   assert_prio(ctx, B_5_1, 5);
    351673}
    352674
     
    359681  test_simple_inheritance(ctx);
    360682  test_dequeue_order_one_scheduler_instance(ctx);
    361   test_simple_boosting(ctx);
     683  test_mixed_queue_two_scheduler_instances(ctx);
     684  test_mixed_queue_two_scheduler_instances_sem_only(ctx);
     685  test_simple_inheritance_two_scheduler_instances(ctx);
     686  test_nested_inheritance_two_scheduler_instances(ctx);
    362687  test_dequeue_order_two_scheduler_instances(ctx);
    363688}
     
    400725#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT
    401726
    402 #define CONFIGURE_MAXIMUM_SEMAPHORES 1
     727#define CONFIGURE_MAXIMUM_SEMAPHORES 3
    403728
    404729#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
Note: See TracChangeset for help on using the changeset viewer.