Lines Matching +full:int +full:- +full:a

1               Thread-Metric RTOS Test Suite
4 1. Thread-Metric Test Suite
6 The Thread-Metric test suite consists of 8 distinct RTOS
9 that can be processed during a specific timer interval. A 30
14 This is the baseline test consisting of a single thread. This
22 voluntarily release control to each other in a round-robin fashion.
31 This test consists of 5 threads that each have a unique priority.
33 left in a suspended state. The lowest priority thread will resume
41 highest priority thread - starting the whole process over once again.
45 This test consists of a single thread. The thread will cause an
46 interrupt (typically implemented as a trap), which will result in
47 a call to the interrupt handler. The interrupt handler will
48 increment a counter and then post to a semaphore. After the
51 the semaphore set by the interrupt handler, increments a counter
57 difference is the interrupt handler in this test resumes a
62 This test consists of a thread sending a 16 byte message to a
69 This test consists of a thread getting a semaphore and then
75 This test consists of a thread allocating a 128-byte block and
81 A few minor modifications have been made to the Thread-Metric source
84 2.1. tm_main() -> main()
91 Thread entry points used by Zephyr have a different function signature
92 than that used by the original Thread-Metric code. These functions
97 Zephyr's version does not spawn a reporting thread. Instead it calls
107 The source code to the Thread-Metric test suite is organized into
116 tm_interrupt_processing_test.c                No-preemption interrupt processing
144     int  tm_thread_create(int thread_id, int priority, void (*entry_function)(void));
146     This function creates a thread of the specified priority where 1 is
151     int  tm_thread_resume(int thread_id);
154     thread_id. If successful, a TM_SUCCESS is returned.
156     int  tm_thread_suspend(int thread_id);
159     thread_id. If successful, a TM_SUCCESS is returned.
166     void  tm_thread_sleep(int seconds);
171     int  tm_queue_create(int queue_id);
173     This function creates a queue with a capacity to hold at least
174     one 16-byte message. If successful, a TM_SUCCESS is returned.
176     int  tm_queue_send(int queue_id, unsigned long *message_ptr);
178     This function sends a message to the previously created queue.
179     If successful, a TM_SUCCESS is returned.
181     int  tm_queue_receive(int queue_id, unsigned long *message_ptr);
183     This function receives a message from the previously created
184     queue. If successful, a TM_SUCCESS is returned.
186     int  tm_semaphore_create(int semaphore_id);
188     This function creates a binary semaphore. If successful, a
191     int  tm_semaphore_get(int semaphore_id);
194     If successful, a TM_SUCCESS is returned.
196     int  tm_semaphore_put(int semaphore_id);
199     If successful, a TM_SUCCESS is returned.
201     int  tm_memory_pool_create(int pool_id);
203     This function creates a memory pool able to satisfy at least one
204     128-byte block of memory. If successful, a TM_SUCCESS is returned.
206     int  tm_memory_pool_allocate(int pool_id, unsigned char **memory_ptr);
208     This function allocates a 128-byte block of memory from the
209     previously created memory pool. If successful, a TM_SUCCESS
213     int  tm_memory_pool_deallocate(int pool_id, unsigned char *memory_ptr);
215     This function releases the previously allocated 128-byte block
216     of memory. If successful, a TM_SUCCESS is returned.
234     3. The tm_thread_sleep service is implemented by a 10ms RTOS