1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/***************************************************************************
* Copyright (c) 2024 Microsoft Corporation
* Copyright (c) 2026-present Eclipse ThreadX contributors
*
* This program and the accompanying materials are made available under the
* terms of the MIT License which is available at
* https://opensource.org/licenses/MIT.
*
* SPDX-License-Identifier: MIT
**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** Thread-Metric Component */
/** */
/** Porting Layer (Must be completed with RTOS specifics) */
/** */
/**************************************************************************/
/**************************************************************************/
/* Include necessary files. */
#include "tm_api.h"
/* This function called from main performs basic RTOS initialization,
calls the test initialization function, and then starts the RTOS function. */
void tm_initialize(void (*test_initialization_function)(void))
{
}
/* This function takes a thread ID and priority and attempts to create the
file in the underlying RTOS. Valid priorities range from 1 through 31,
where 1 is the highest priority and 31 is the lowest. If successful,
the function should return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_thread_create(int thread_id, int priority, void (*entry_function)(void))
{
}
/* This function resumes the specified thread. If successful, the function should
return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_thread_resume(int thread_id)
{
}
/* This function suspends the specified thread. If successful, the function should
return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_thread_suspend(int thread_id)
{
}
/* This function relinquishes to other ready threads at the same
priority. */
void tm_thread_relinquish(void)
{
}
/* This function suspends the specified thread for the specified number
of seconds. If successful, the function should return TM_SUCCESS.
Otherwise, TM_ERROR should be returned. */
void tm_thread_sleep(int seconds)
{
}
/* This function creates the specified queue. If successful, the function should
return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_queue_create(int queue_id)
{
}
/* This function sends a 16-byte message to the specified queue. If successful,
the function should return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_queue_send(int queue_id, unsigned long *message_ptr)
{
}
/* This function receives a 16-byte message from the specified queue. If successful,
the function should return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_queue_receive(int queue_id, unsigned long *message_ptr)
{
}
/* This function creates the specified semaphore. If successful, the function should
return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_semaphore_create(int semaphore_id)
{
}
/* This function gets the specified semaphore. If successful, the function should
return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_semaphore_get(int semaphore_id)
{
}
/* This function puts the specified semaphore. If successful, the function should
return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_semaphore_put(int semaphore_id)
{
}
/* This function creates the specified memory pool that can support one or more
allocations of 128 bytes. If successful, the function should
return TM_SUCCESS. Otherwise, TM_ERROR should be returned. */
int tm_memory_pool_create(int pool_id)
{
}
/* This function allocates a 128 byte block from the specified memory pool.
If successful, the function should return TM_SUCCESS. Otherwise, TM_ERROR
should be returned. */
int tm_memory_pool_allocate(int pool_id, unsigned char **memory_ptr)
{
}
/* This function releases a previously allocated 128 byte block from the specified
memory pool. If successful, the function should return TM_SUCCESS. Otherwise, TM_ERROR
should be returned. */
int tm_memory_pool_deallocate(int pool_id, unsigned char *memory_ptr)
{
}
|
