source: rtems/testsuites/tmtests/tmfine01/init.c @ 6087f33e

Last change on this file since 6087f33e was 6087f33e, checked in by Sebastian Huber <sebastian.huber@…>, on Oct 18, 2017 at 6:50:17 AM

tmtests/tmfine01: Add test cases

Update #2674.
Update #3112.
Update #3113.
Update #3114.
Update #3115.

  • Property mode set to 100644
File size: 18.0 KB
Line 
1/*
2 * Copyright (c) 2015, 2017 embedded brains GmbH.  All rights reserved.
3 *
4 *  embedded brains GmbH
5 *  Dornierstr. 4
6 *  82178 Puchheim
7 *  Germany
8 *  <rtems@embedded-brains.de>
9 *
10 * The license and distribution terms for this file may be
11 * found in the file LICENSE in this distribution or at
12 * http://www.rtems.org/license/LICENSE.
13 */
14
15#ifdef HAVE_CONFIG_H
16  #include "config.h"
17#endif
18
19#include "tmacros.h"
20
21#include <sys/lock.h>
22#include <inttypes.h>
23#include <pthread.h>
24#include <sched.h>
25#include <stdio.h>
26
27#include <rtems/test.h>
28
29const char rtems_test_name[] = "TMFINE 1";
30
31#define CPU_COUNT 32
32
33#define MSG_COUNT 3
34
35typedef struct {
36  uint32_t value;
37} test_msg;
38
39typedef struct {
40  rtems_test_parallel_context base;
41  rtems_id master;
42  rtems_id sema;
43  rtems_id mq[CPU_COUNT];
44  uint32_t self_event_ops[CPU_COUNT][CPU_COUNT];
45  uint32_t all_to_one_event_ops[CPU_COUNT][CPU_COUNT];
46  uint32_t one_mutex_ops[CPU_COUNT][CPU_COUNT];
47  uint32_t many_mutex_ops[CPU_COUNT][CPU_COUNT];
48  uint32_t self_msg_ops[CPU_COUNT][CPU_COUNT];
49  uint32_t many_to_one_msg_ops[CPU_COUNT][CPU_COUNT];
50  uint32_t many_sys_lock_mutex_ops[CPU_COUNT][CPU_COUNT];
51  uint32_t many_classic_ceiling_ops[CPU_COUNT][CPU_COUNT];
52  uint32_t many_classic_mrsp_ops[CPU_COUNT][CPU_COUNT];
53  uint32_t many_pthread_spinlock_ops[CPU_COUNT][CPU_COUNT];
54  uint32_t many_pthread_mutex_inherit_ops[CPU_COUNT][CPU_COUNT];
55  uint32_t many_pthread_mutex_protect_ops[CPU_COUNT][CPU_COUNT];
56} test_context;
57
58static test_context test_instance;
59
60static rtems_interval test_duration(void)
61{
62  return rtems_clock_get_ticks_per_second();
63}
64
65static rtems_interval test_init(
66  rtems_test_parallel_context *base,
67  void *arg,
68  size_t active_workers
69)
70{
71  return test_duration();
72}
73
74static void test_fini(
75  const char *name,
76  uint32_t *counters,
77  size_t active_workers
78)
79{
80  size_t i;
81
82  printf("  <%s activeWorker=\"%zu\">\n", name, active_workers);
83
84  for (i = 0; i < active_workers; ++i) {
85    printf(
86      "    <Counter worker=\"%zu\">%" PRIu32 "</Counter>\n",
87      i,
88      counters[i]
89    );
90  }
91
92  printf("  </%s>\n", name);
93}
94
95static void test_self_event_body(
96  rtems_test_parallel_context *base,
97  void *arg,
98  size_t active_workers,
99  size_t worker_index
100)
101{
102  test_context *ctx = (test_context *) base;
103  rtems_id id = rtems_task_self();
104  uint32_t counter = 0;
105
106  while (!rtems_test_parallel_stop_job(&ctx->base)) {
107    rtems_status_code sc;
108    rtems_event_set out;
109
110    ++counter;
111
112    sc = rtems_event_send(id, RTEMS_EVENT_0);
113    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
114
115    sc = rtems_event_receive(
116      RTEMS_EVENT_0,
117      RTEMS_WAIT | RTEMS_EVENT_ANY,
118      RTEMS_NO_TIMEOUT,
119      &out
120    );
121    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
122  }
123
124  ctx->self_event_ops[active_workers - 1][worker_index] = counter;
125}
126
127static void test_self_event_fini(
128  rtems_test_parallel_context *base,
129  void *arg,
130  size_t active_workers
131)
132{
133  test_context *ctx = (test_context *) base;
134
135  test_fini(
136    "SelfEvent",
137    &ctx->self_event_ops[active_workers - 1][0],
138    active_workers
139  );
140}
141
142static void test_all_to_one_event_body(
143  rtems_test_parallel_context *base,
144  void *arg,
145  size_t active_workers,
146  size_t worker_index
147)
148{
149  test_context *ctx = (test_context *) base;
150  rtems_id id = rtems_task_self();
151  bool is_master = rtems_test_parallel_is_master_worker(worker_index);
152  uint32_t counter = 0;
153
154  while (!rtems_test_parallel_stop_job(&ctx->base)) {
155    rtems_status_code sc;
156
157    ++counter;
158
159    sc = rtems_event_send(id, RTEMS_EVENT_0);
160    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
161
162    if (is_master) {
163      rtems_event_set out;
164
165      sc = rtems_event_receive(
166        RTEMS_ALL_EVENTS,
167        RTEMS_WAIT | RTEMS_EVENT_ANY,
168        RTEMS_NO_TIMEOUT,
169        &out
170      );
171      rtems_test_assert(sc == RTEMS_SUCCESSFUL);
172    }
173  }
174
175  ctx->all_to_one_event_ops[active_workers - 1][worker_index] = counter;
176}
177
178static void test_all_to_one_event_fini(
179  rtems_test_parallel_context *base,
180  void *arg,
181  size_t active_workers
182)
183{
184  test_context *ctx = (test_context *) base;
185
186  test_fini(
187    "AllToOneEvent",
188    &ctx->all_to_one_event_ops[active_workers - 1][0],
189    active_workers
190  );
191}
192
193static void test_one_mutex_body(
194  rtems_test_parallel_context *base,
195  void *arg,
196  size_t active_workers,
197  size_t worker_index
198)
199{
200  test_context *ctx = (test_context *) base;
201  rtems_id id = ctx->sema;
202  uint32_t counter = 0;
203
204  while (!rtems_test_parallel_stop_job(&ctx->base)) {
205    rtems_status_code sc;
206
207    ++counter;
208
209    sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
210    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
211
212    sc = rtems_semaphore_release(id);
213    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
214  }
215
216  ctx->one_mutex_ops[active_workers - 1][worker_index] = counter;
217}
218
219static void test_one_mutex_fini(
220  rtems_test_parallel_context *base,
221  void *arg,
222  size_t active_workers
223)
224{
225  test_context *ctx = (test_context *) base;
226
227  test_fini(
228    "OneMutex",
229    &ctx->one_mutex_ops[active_workers - 1][0],
230    active_workers
231  );
232}
233
234static void test_many_mutex_body(
235  rtems_test_parallel_context *base,
236  void *arg,
237  size_t active_workers,
238  size_t worker_index
239)
240{
241  test_context *ctx = (test_context *) base;
242  rtems_status_code sc;
243  rtems_id id;
244  uint32_t counter = 0;
245
246  sc = rtems_semaphore_create(
247    rtems_build_name('T', 'E', 'S', 'T'),
248    1,
249    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
250    0,
251    &id
252  );
253  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
254
255  while (!rtems_test_parallel_stop_job(&ctx->base)) {
256    rtems_status_code sc;
257
258    ++counter;
259
260    sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
261    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
262
263    sc = rtems_semaphore_release(id);
264    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
265  }
266
267  ctx->many_mutex_ops[active_workers - 1][worker_index] = counter;
268
269  sc = rtems_semaphore_delete(id);
270  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
271}
272
273static void test_many_mutex_fini(
274  rtems_test_parallel_context *base,
275  void *arg,
276  size_t active_workers
277)
278{
279  test_context *ctx = (test_context *) base;
280
281  test_fini(
282    "ManyMutex",
283    &ctx->many_mutex_ops[active_workers - 1][0],
284    active_workers
285  );
286}
287
288static void test_self_msg_body(
289  rtems_test_parallel_context *base,
290  void *arg,
291  size_t active_workers,
292  size_t worker_index
293)
294{
295  test_context *ctx = (test_context *) base;
296  rtems_id id = ctx->mq[worker_index];
297  uint32_t counter = 0;
298
299  while (!rtems_test_parallel_stop_job(&ctx->base)) {
300    rtems_status_code sc;
301    test_msg msg = { .value = 0 };
302    size_t n;
303
304    ++counter;
305
306    sc = rtems_message_queue_send(id, &msg, sizeof(msg));
307    rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_TOO_MANY);
308
309    n = sizeof(msg);
310    sc = rtems_message_queue_receive(
311      id,
312      &msg,
313      &n,
314      RTEMS_WAIT,
315      RTEMS_NO_TIMEOUT
316    );
317    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
318    rtems_test_assert(n == sizeof(msg));
319  }
320
321  ctx->self_msg_ops[active_workers - 1][worker_index] = counter;
322}
323
324static void test_self_msg_fini(
325  rtems_test_parallel_context *base,
326  void *arg,
327  size_t active_workers
328)
329{
330  test_context *ctx = (test_context *) base;
331
332  test_fini(
333    "SelfMsg",
334    &ctx->self_msg_ops[active_workers - 1][0],
335    active_workers
336  );
337}
338
339static void test_many_to_one_msg_body(
340  rtems_test_parallel_context *base,
341  void *arg,
342  size_t active_workers,
343  size_t worker_index
344)
345{
346  test_context *ctx = (test_context *) base;
347  rtems_id id = ctx->mq[0];
348  bool is_master = rtems_test_parallel_is_master_worker(worker_index);
349  uint32_t counter = 0;
350
351  while (!rtems_test_parallel_stop_job(&ctx->base)) {
352    rtems_status_code sc;
353    test_msg msg = { .value = 0 };
354    size_t n;
355
356    ++counter;
357
358    sc = rtems_message_queue_send(id, &msg, sizeof(msg));
359    rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_TOO_MANY);
360
361    if (is_master) {
362      n = sizeof(msg);
363      sc = rtems_message_queue_receive(
364        id,
365        &msg,
366        &n,
367        RTEMS_WAIT,
368        RTEMS_NO_TIMEOUT
369      );
370      rtems_test_assert(sc == RTEMS_SUCCESSFUL);
371      rtems_test_assert(n == sizeof(msg));
372    }
373  }
374
375  ctx->many_to_one_msg_ops[active_workers - 1][worker_index] = counter;
376}
377
378static void test_many_to_one_msg_fini(
379  rtems_test_parallel_context *base,
380  void *arg,
381  size_t active_workers
382)
383{
384  test_context *ctx = (test_context *) base;
385
386  test_fini(
387    "ManyToOneMsg",
388    &ctx->many_to_one_msg_ops[active_workers - 1][0],
389    active_workers
390  );
391}
392
393static void test_many_sys_lock_mutex_body(
394  rtems_test_parallel_context *base,
395  void *arg,
396  size_t active_workers,
397  size_t worker_index
398)
399{
400  test_context *ctx = (test_context *) base;
401  struct _Mutex_Control mtx;
402  uint32_t counter = 0;
403
404  _Mutex_Initialize(&mtx);
405
406  while (!rtems_test_parallel_stop_job(&ctx->base)) {
407    ++counter;
408
409    _Mutex_Acquire(&mtx);
410    _Mutex_Release(&mtx);
411  }
412
413  ctx->many_sys_lock_mutex_ops[active_workers - 1][worker_index] = counter;
414}
415
416static void test_many_sys_lock_mutex_fini(
417  rtems_test_parallel_context *base,
418  void *arg,
419  size_t active_workers
420)
421{
422  test_context *ctx = (test_context *) base;
423
424  test_fini(
425    "ManySysLockMutex",
426    &ctx->many_sys_lock_mutex_ops[active_workers - 1][0],
427    active_workers
428  );
429}
430
431static void test_many_classic_ceiling_body(
432  rtems_test_parallel_context *base,
433  void *arg,
434  size_t active_workers,
435  size_t worker_index
436)
437{
438  test_context *ctx = (test_context *) base;
439  rtems_status_code sc;
440  rtems_id id;
441  uint32_t counter = 0;
442
443  sc = rtems_semaphore_create(
444    rtems_build_name('T', 'E', 'S', 'T'),
445    1,
446    RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY_CEILING | RTEMS_PRIORITY,
447    1,
448    &id
449  );
450  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
451
452  while (!rtems_test_parallel_stop_job(&ctx->base)) {
453    rtems_status_code sc;
454
455    ++counter;
456
457    sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
458    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
459
460    sc = rtems_semaphore_release(id);
461    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
462  }
463
464  ctx->many_classic_ceiling_ops[active_workers - 1][worker_index] = counter;
465
466  sc = rtems_semaphore_delete(id);
467  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
468}
469
470static void test_many_classic_ceiling_fini(
471  rtems_test_parallel_context *base,
472  void *arg,
473  size_t active_workers
474)
475{
476  test_context *ctx = (test_context *) base;
477
478  test_fini(
479    "ManyClassicCeilingMutex",
480    &ctx->many_classic_ceiling_ops[active_workers - 1][0],
481    active_workers
482  );
483}
484
485static void test_many_classic_mrsp_body(
486  rtems_test_parallel_context *base,
487  void *arg,
488  size_t active_workers,
489  size_t worker_index
490)
491{
492  test_context *ctx = (test_context *) base;
493  rtems_status_code sc;
494  rtems_id id;
495  uint32_t counter = 0;
496
497  sc = rtems_semaphore_create(
498    rtems_build_name('T', 'E', 'S', 'T'),
499    1,
500    RTEMS_BINARY_SEMAPHORE | RTEMS_MULTIPROCESSOR_RESOURCE_SHARING,
501    1,
502    &id
503  );
504  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
505
506  while (!rtems_test_parallel_stop_job(&ctx->base)) {
507    rtems_status_code sc;
508
509    ++counter;
510
511    sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
512    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
513
514    sc = rtems_semaphore_release(id);
515    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
516  }
517
518  ctx->many_classic_mrsp_ops[active_workers - 1][worker_index] = counter;
519
520  sc = rtems_semaphore_delete(id);
521  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
522}
523
524static void test_many_classic_mrsp_fini(
525  rtems_test_parallel_context *base,
526  void *arg,
527  size_t active_workers
528)
529{
530  test_context *ctx = (test_context *) base;
531
532  test_fini(
533    "ManyClassicMrsPMutex",
534    &ctx->many_classic_mrsp_ops[active_workers - 1][0],
535    active_workers
536  );
537}
538
539static void test_many_pthread_spinlock_body(
540  rtems_test_parallel_context *base,
541  void *arg,
542  size_t active_workers,
543  size_t worker_index
544)
545{
546  test_context *ctx = (test_context *) base;
547  int eno;
548  pthread_spinlock_t spin;
549  uint32_t counter = 0;
550
551  eno = pthread_spin_init(&spin, 0);
552  rtems_test_assert(eno == 0);
553
554  while (!rtems_test_parallel_stop_job(&ctx->base)) {
555    ++counter;
556
557    pthread_spin_lock(&spin);
558    pthread_spin_unlock(&spin);
559  }
560
561  ctx->many_pthread_spinlock_ops[active_workers - 1][worker_index] = counter;
562
563  eno = pthread_spin_destroy(&spin);
564  rtems_test_assert(eno == 0);
565}
566
567static void test_many_pthread_spinlock_fini(
568  rtems_test_parallel_context *base,
569  void *arg,
570  size_t active_workers
571)
572{
573  test_context *ctx = (test_context *) base;
574
575  test_fini(
576    "ManyPthreadSpinlock",
577    &ctx->many_pthread_spinlock_ops[active_workers - 1][0],
578    active_workers
579  );
580}
581
582static void test_many_pthread_mutex_inherit_body(
583  rtems_test_parallel_context *base,
584  void *arg,
585  size_t active_workers,
586  size_t worker_index
587)
588{
589  test_context *ctx = (test_context *) base;
590  int eno;
591  pthread_mutexattr_t attr;
592  pthread_mutex_t mtx;
593  uint32_t counter = 0;
594
595  eno = pthread_mutexattr_init(&attr);
596  rtems_test_assert(eno == 0);
597
598  eno = pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
599  rtems_test_assert(eno == 0);
600
601  eno = pthread_mutex_init(&mtx, &attr);
602  rtems_test_assert(eno == 0);
603
604  while (!rtems_test_parallel_stop_job(&ctx->base)) {
605    ++counter;
606
607    pthread_mutex_lock(&mtx);
608    pthread_mutex_unlock(&mtx);
609  }
610
611  ctx->many_pthread_mutex_inherit_ops[active_workers - 1][worker_index] =
612    counter;
613
614  eno = pthread_mutex_destroy(&mtx);
615  rtems_test_assert(eno == 0);
616
617  eno = pthread_mutexattr_destroy(&attr);
618  rtems_test_assert(eno == 0);
619}
620
621static void test_many_pthread_mutex_inherit_fini(
622  rtems_test_parallel_context *base,
623  void *arg,
624  size_t active_workers
625)
626{
627  test_context *ctx = (test_context *) base;
628
629  test_fini(
630    "ManyPthreadMutexInherit",
631    &ctx->many_pthread_mutex_inherit_ops[active_workers - 1][0],
632    active_workers
633  );
634}
635
636static void test_many_pthread_mutex_protect_body(
637  rtems_test_parallel_context *base,
638  void *arg,
639  size_t active_workers,
640  size_t worker_index
641)
642{
643  test_context *ctx = (test_context *) base;
644  int eno;
645  pthread_mutexattr_t attr;
646  pthread_mutex_t mtx;
647  uint32_t counter = 0;
648
649  eno = pthread_mutexattr_init(&attr);
650  rtems_test_assert(eno == 0);
651
652  eno = pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_PROTECT);
653  rtems_test_assert(eno == 0);
654
655  eno = pthread_mutexattr_setprioceiling(
656    &attr,
657    sched_get_priority_max(SCHED_FIFO)
658  );
659  rtems_test_assert(eno == 0);
660
661  eno = pthread_mutex_init(&mtx, &attr);
662  rtems_test_assert(eno == 0);
663
664  while (!rtems_test_parallel_stop_job(&ctx->base)) {
665    ++counter;
666
667    pthread_mutex_lock(&mtx);
668    pthread_mutex_unlock(&mtx);
669  }
670
671  ctx->many_pthread_mutex_protect_ops[active_workers - 1][worker_index] =
672    counter;
673
674  eno = pthread_mutex_destroy(&mtx);
675  rtems_test_assert(eno == 0);
676
677  eno = pthread_mutexattr_destroy(&attr);
678  rtems_test_assert(eno == 0);
679}
680
681static void test_many_pthread_mutex_protect_fini(
682  rtems_test_parallel_context *base,
683  void *arg,
684  size_t active_workers
685)
686{
687  test_context *ctx = (test_context *) base;
688
689  test_fini(
690    "ManyPthreadMutexProtect",
691    &ctx->many_pthread_mutex_protect_ops[active_workers - 1][0],
692    active_workers
693  );
694}
695
696static const rtems_test_parallel_job test_jobs[] = {
697  {
698    .init = test_init,
699    .body = test_self_event_body,
700    .fini = test_self_event_fini,
701    .cascade = true
702  }, {
703    .init = test_init,
704    .body = test_all_to_one_event_body,
705    .fini = test_all_to_one_event_fini,
706    .cascade = true
707  }, {
708    .init = test_init,
709    .body = test_one_mutex_body,
710    .fini = test_one_mutex_fini,
711    .cascade = true
712  }, {
713    .init = test_init,
714    .body = test_many_mutex_body,
715    .fini = test_many_mutex_fini,
716    .cascade = true
717  }, {
718    .init = test_init,
719    .body = test_self_msg_body,
720    .fini = test_self_msg_fini,
721    .cascade = true
722  }, {
723    .init = test_init,
724    .body = test_many_to_one_msg_body,
725    .fini = test_many_to_one_msg_fini,
726    .cascade = true
727  }, {
728    .init = test_init,
729    .body = test_many_sys_lock_mutex_body,
730    .fini = test_many_sys_lock_mutex_fini,
731    .cascade = true
732  }, {
733    .init = test_init,
734    .body = test_many_classic_ceiling_body,
735    .fini = test_many_classic_ceiling_fini,
736    .cascade = true
737  }, {
738    .init = test_init,
739    .body = test_many_classic_mrsp_body,
740    .fini = test_many_classic_mrsp_fini,
741    .cascade = true
742  }, {
743    .init = test_init,
744    .body = test_many_pthread_spinlock_body,
745    .fini = test_many_pthread_spinlock_fini,
746    .cascade = true
747  }, {
748    .init = test_init,
749    .body = test_many_pthread_mutex_inherit_body,
750    .fini = test_many_pthread_mutex_inherit_fini,
751    .cascade = true
752  }, {
753    .init = test_init,
754    .body = test_many_pthread_mutex_protect_body,
755    .fini = test_many_pthread_mutex_protect_fini,
756    .cascade = true
757  }
758};
759
760static void Init(rtems_task_argument arg)
761{
762  test_context *ctx = &test_instance;
763  const char *test = "TestTimeFine01";
764  rtems_status_code sc;
765  size_t i;
766
767  TEST_BEGIN();
768
769  ctx->master = rtems_task_self();
770
771  sc = rtems_semaphore_create(
772    rtems_build_name('T', 'E', 'S', 'T'),
773    1,
774    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
775    0,
776    &ctx->sema
777  );
778  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
779
780  for (i = 0; i < CPU_COUNT; ++i) {
781    sc = rtems_message_queue_create(
782      rtems_build_name('T', 'E', 'S', 'T'),
783      MSG_COUNT,
784      sizeof(test_msg),
785      RTEMS_DEFAULT_ATTRIBUTES,
786      &ctx->mq[i]
787    );
788    rtems_test_assert(sc == RTEMS_SUCCESSFUL);
789  }
790
791  printf("<%s>\n", test);
792
793  rtems_test_parallel(
794    &ctx->base,
795    NULL,
796    &test_jobs[0],
797    RTEMS_ARRAY_SIZE(test_jobs)
798  );
799
800  printf("</%s>\n", test);
801
802  TEST_END();
803  rtems_test_exit(0);
804}
805
806#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
807#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
808
809#define CONFIGURE_MAXIMUM_TASKS CPU_COUNT
810
811#define CONFIGURE_MAXIMUM_TIMERS 1
812
813#define CONFIGURE_MAXIMUM_SEMAPHORES (1 + CPU_COUNT)
814
815#define CONFIGURE_MAXIMUM_MRSP_SEMAPHORES CPU_COUNT
816
817#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES CPU_COUNT
818
819#define CONFIGURE_MESSAGE_BUFFER_MEMORY \
820  CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(MSG_COUNT, sizeof(test_msg))
821
822#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION
823
824#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
825
826#define CONFIGURE_INIT_TASK_PRIORITY 2
827
828#define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT
829
830#define CONFIGURE_INIT
831
832#include <rtems/confdefs.h>
Note: See TracBrowser for help on using the repository browser.