Merge pull request #510 from eclipse-threadx/devv6.5.0.202601_rel

Merge changes ahead of the v6.5.0.202601 release

13 files changed, 319 insertions, 361 deletions

diff --git a/utility/benchmarks/thread_metric/thread_metric_readme.txt b/utility/benchmarks/thread_metric/thread_metric_readme.txt
index 70896efb..044f7ee2 100644
--- a/utility/benchmarks/thread_metric/thread_metric_readme.txt
+++ b/utility/benchmarks/thread_metric/thread_metric_readme.txt
@@ -1,4 +1,4 @@
-              Thread-Metric RTOS Test Suite 
+              Thread-Metric RTOS Test Suite
 
 
 1. Thread-Metric Test Suite
@@ -6,46 +6,46 @@
 The Thread-Metric test suite consists of 8 distinct RTOS
 tests that are designed to highlight commonly used aspects
 of an RTOS. The test measures the total number of RTOS events
-that can be processed during a specific timer interval. A 30 
-second time interval is recommended. 
+that can be processed during a specific timer interval. A 30
+second time interval is recommended.
 
-1.1. Basic Processing Test    
+1.1. Basic Processing Test
 
-This is the baseline test consisting of a single thread. This 
-should execute the same on every operating system. Test values 
-from testing with different RTOS products should be scaled 
+This is the baseline test consisting of a single thread. This
+should execute the same on every operating system. Test values
+from testing with different RTOS products should be scaled
 relative to the difference between the values of this test.
 
 1.2. Cooperative Scheduling Test
 
-This test consists of 5 threads created at the same priority that 
-voluntarily release control to each other in a round-robin fashion.  
-Each thread will increment its run counter and then relinquish to 
-the next thread.  At the end of the test the counters will be verified 
-to make sure they are valid (should all be within 1 of the same 
-value). If valid, the numbers will be summed and presented as the 
+This test consists of 5 threads created at the same priority that
+voluntarily release control to each other in a round-robin fashion.
+Each thread will increment its run counter and then relinquish to
+the next thread.  At the end of the test the counters will be verified
+to make sure they are valid (should all be within 1 of the same
+value). If valid, the numbers will be summed and presented as the
 result of the cooperative scheduling test.
 
 1.3. Preemptive Scheduling Test
 
-This test consists of 5 threads that each have a unique priority. 
-In this test, all threads except the lowest priority thread are 
-left in a suspended state. The lowest priority thread will resume 
-the next highest priority thread.  That thread will resume the 
-next highest priority thread and so on until the highest priority 
-thread executes. Each thread will increment its run count and then 
-call thread suspend.  Eventually the processing will return to the 
-lowest priority thread, which is still in the middle of the thread 
-resume call. Once processing returns to the lowest priority thread, 
-it will increment its run counter and once again resume the next 
+This test consists of 5 threads that each have a unique priority.
+In this test, all threads except the lowest priority thread are
+left in a suspended state. The lowest priority thread will resume
+the next highest priority thread.  That thread will resume the
+next highest priority thread and so on until the highest priority
+thread executes. Each thread will increment its run count and then
+call thread suspend.  Eventually the processing will return to the
+lowest priority thread, which is still in the middle of the thread
+resume call. Once processing returns to the lowest priority thread,
+it will increment its run counter and once again resume the next
 highest priority thread - starting the whole process over once again.
 
 1.4. Interrupt Processing Test
 
-This test consists of a single thread. The thread will cause an 
-interrupt (typically implemented as a trap), which will result in 
-a call to the interrupt handler. The interrupt handler will 
-increment a counter and then post to a semaphore. After the 
+This test consists of a single thread. The thread will cause an
+interrupt (typically implemented as a trap), which will result in
+a call to the interrupt handler. The interrupt handler will
+increment a counter and then post to a semaphore. After the
 interrupt handler completes, processing returns to the test
 thread that initiated the interrupt. The thread then retrieves
 the semaphore set by the interrupt handler, increments a counter
@@ -54,26 +54,26 @@ and then generates another interrupt.
 1.5. Interrupt Preemption Processing Test
 
 This test is similar to the previous interrupt test. The big
-difference is the interrupt handler in this test resumes a 
-higher priority thread, which causes thread preemption.  
+difference is the interrupt handler in this test resumes a
+higher priority thread, which causes thread preemption.
 
 1.6. Message Processing Test
 
-This test consists of a thread sending a 16 byte message to a 
-queue and retrieving the same 16 byte message from the queue.  
-After the send/receive sequence is complete, the thread will 
+This test consists of a thread sending a 16 byte message to a
+queue and retrieving the same 16 byte message from the queue.
+After the send/receive sequence is complete, the thread will
 increment its run counter.
 
 1.4. Synchronization Processing Test
 
-This test consists of a thread getting a semaphore and then 
-immediately releasing it. After the get/put cycle completes, 
+This test consists of a thread getting a semaphore and then
+immediately releasing it. After the get/put cycle completes,
 the thread will increment its run counter.
 
 1.5. RTOS Memory allocation
 
-This test consists of a thread allocating a 128-byte block and 
-releasing the same block. After the block is released, the thread 
+This test consists of a thread allocating a 128-byte block and
+releasing the same block. After the block is released, the thread
 will increment its run counter.
 
 
@@ -104,8 +104,8 @@ tm_message_processing_test.c                Message exchange processing test
 tm_synchronization_processing_test.c        Semaphore get/put processing test
 tm_memory_allocation_test.c                 Basic memory allocation test
 tm_porting_layer.h                          Port specific information, including
-                                              in-line assembly instruction to 
-                                              cause an interrupt for the 
+                                              in-line assembly instruction to
+                                              cause an interrupt for the
                                               interrupt processing tests
 tm_porting_layer_template.c                 Generic template for RTOS porting
                                               layer
@@ -114,93 +114,93 @@ tm_porting_layer_threadx.c                  Specific porting layer source
 
 2.1 Porting Layer
 
-As for the porting layer defined in tm_porting_layer_template.c, this file contain 
-shell services of the generic RTOS services used by the actual tests. The 
-shell services provide the mapping between the tests and the underlying RTOS.  
-The following generic API's are required to map any RTOS to the performance 
+As for the porting layer defined in tm_porting_layer_template.c, this file contain
+shell services of the generic RTOS services used by the actual tests. The
+shell services provide the mapping between the tests and the underlying RTOS.
+The following generic API's are required to map any RTOS to the performance
 measurement tests:
 
 
     void  tm_initialize(void (*test_initialization_function)(void));
 
-    This function is typically called by the application from its 
-    main() function. It is responsible for providing all the RTOS 
-    initialization, calling the test initialization function as 
+    This function is typically called by the application from its
+    main() function. It is responsible for providing all the RTOS
+    initialization, calling the test initialization function as
     specified, and then starting the RTOS.
 
     int  tm_thread_create(int thread_id, int priority, void (*entry_function)(void));
 
-    This function creates a thread of the specified priority where 1 is 
-    the highest and 16 is the lowest.  If successful, TM_SUCCESS 
-    returned. If an error occurs, TM_ERROR is returned. The created thread 
+    This function creates a thread of the specified priority where 1 is
+    the highest and 16 is the lowest.  If successful, TM_SUCCESS
+    returned. If an error occurs, TM_ERROR is returned. The created thread
     is not started.
 
     int  tm_thread_resume(int thread_id);
 
-    This function resumes the previously created thread specified by 
+    This function resumes the previously created thread specified by
     thread_id. If successful, a TM_SUCCESS is returned.
 
     int  tm_thread_suspend(int thread_id);
 
-    This function suspend the previously created thread specified by 
+    This function suspend the previously created thread specified by
     thread_id. If successful, a TM_SUCCESS is returned.
 
     void  tm_thread_relinquish(void);
 
-    This function lets all other threads of same priority execute 
+    This function lets all other threads of same priority execute
     before the calling thread runs again.
 
     void  tm_thread_sleep(int seconds);
 
-    This function suspends the calling thread for the specified 
+    This function suspends the calling thread for the specified
     number of seconds.
 
     int  tm_queue_create(int queue_id);
 
-    This function creates a queue with a capacity to hold at least 
+    This function creates a queue with a capacity to hold at least
     one 16-byte message. If successful, a TM_SUCCESS is returned.
 
     int  tm_queue_send(int queue_id, unsigned long *message_ptr);
 
-    This function sends a message to the previously created queue.  
+    This function sends a message to the previously created queue.
     If successful, a TM_SUCCESS is returned.
 
     int  tm_queue_receive(int queue_id, unsigned long *message_ptr);
 
-    This function receives a message from the previously created 
+    This function receives a message from the previously created
     queue. If successful, a TM_SUCCESS is returned.
 
     int  tm_semaphore_create(int semaphore_id);
 
-    This function creates a binary semaphore. If successful, a 
+    This function creates a binary semaphore. If successful, a
     TM_SUCCESS is returned.
 
     int  tm_semaphore_get(int semaphore_id);
 
-    This function gets the previously created binary semaphore.  
+    This function gets the previously created binary semaphore.
     If successful, a TM_SUCCESS is returned.
 
     int  tm_semaphore_put(int semaphore_id);
 
-    This function puts the previously created binary semaphore. 
+    This function puts the previously created binary semaphore.
     If successful, a TM_SUCCESS is returned.
 
     int  tm_memory_pool_create(int pool_id);
 
-    This function creates a memory pool able to satisfy at least one 
+    This function creates a memory pool able to satisfy at least one
     128-byte block of memory. If successful, a TM_SUCCESS is returned.
 
     int  tm_memory_pool_allocate(int pool_id, unsigned char **memory_ptr);
 
-    This function allocates a 128-byte block of memory from the 
-    previously created memory pool. If successful, a TM_SUCCESS 
-    is returned along with the pointer to the allocated memory 
+    This function allocates a 128-byte block of memory from the
+    previously created memory pool. If successful, a TM_SUCCESS
+    is returned along with the pointer to the allocated memory
     in the "memory_ptr" variable.
 
     int  tm_memory_pool_deallocate(int pool_id, unsigned char *memory_ptr);
 
-    This function releases the previously allocated 128-byte block 
-    of memory. If successful, a TM_SUCCESS is returned. 
+    This function releases the previously allocated 128-byte block
+    of memory. If successful, a TM_SUCCESS is returned.
 
 
 2.2 Porting Requirements
@@ -208,20 +208,20 @@ measurement tests:
 The following requirements are made in order to ensure fair benchmarks
 are achieved on each RTOS performing the test:
 
-    1. Time period should be 30 seconds. This will ensure the printf 
+    1. Time period should be 30 seconds. This will ensure the printf
        processing in the reporting thread is insignificant.
 
-    2. The porting layer services are implemented inside of 
+    2. The porting layer services are implemented inside of
        tm_porting_layer_[RTOS].c and NOT as macros.
 
     3. The tm_thread_sleep service is implemented by a 10ms RTOS
        periodic interrupt source.
 
-    4. Locking regions of the tests and/or the RTOS in cache is 
+    4. Locking regions of the tests and/or the RTOS in cache is
        not allowed.
 
     5. The Interrupt Processing and Interrupt Preemption Processing tests
-       require an instruction that generates an interrupt. Please refer 
-       to tm_porting_layer.h for an example implementation. 
+       require an instruction that generates an interrupt. Please refer
+       to tm_porting_layer.h for an example implementation.
 
 
diff --git a/utility/benchmarks/thread_metric/threadx_example/tm_porting_layer_threadx.c b/utility/benchmarks/thread_metric/threadx_example/tm_porting_layer_threadx.c
index 405d9223..7490da44 100644
--- a/utility/benchmarks/thread_metric/threadx_example/tm_porting_layer_threadx.c
+++ b/utility/benchmarks/thread_metric/threadx_example/tm_porting_layer_threadx.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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 (ThreadX Example)                                     */
@@ -26,7 +27,7 @@
 #endif
 
 
-/* For smallest size, the ThreadX library and application code should be built 
+/* For smallest size, the ThreadX library and application code should be built
    with the following options defined (easiest to add in tx_port.h):
 
 #define TX_ENABLE_EXECUTION_CHANGE_NOTIFY
@@ -110,7 +111,7 @@ void            (*tm_initialization_function)(void);
 VOID  tm_thread_entry(ULONG thread_input);
 
 
-/* This function called from main performs basic RTOS initialization, 
+/* 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))
 {
@@ -119,13 +120,13 @@ void  tm_initialize(void (*test_initialization_function)(void))
     tm_initialization_function =  test_initialization_function;
 
     /* Call the previously defined initialization function.  */
-    (tm_initialization_function)();   
+    (tm_initialization_function)();
 }
 
 
 /* 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, 
+   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))
 {
@@ -197,7 +198,7 @@ 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. 
+   of seconds.  If successful, the function should return TM_SUCCESS.
    Otherwise, TM_ERROR should be returned.  */
 void tm_thread_sleep(int seconds)
 {
@@ -216,7 +217,7 @@ UINT    status;
 
 
     /* Create the specified queue with 16-byte messages.  */
-    status =  tx_queue_create(&tm_queue_array[queue_id], "Thread-Metric test", TX_4_ULONG, 
+    status =  tx_queue_create(&tm_queue_array[queue_id], "Thread-Metric test", TX_4_ULONG,
                               &tm_queue_memory_area[queue_id*TM_THREADX_QUEUE_SIZE], TM_THREADX_QUEUE_SIZE);
 
     /* Determine if the queue create was successful.  */
@@ -227,7 +228,7 @@ UINT    status;
 }
 
 
-/* This function sends a 16-byte message to the specified queue.  If successful, 
+/* 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)
 {
@@ -246,7 +247,7 @@ UINT    status;
 }
 
 
-/* This function receives a 16-byte message from the specified queue.  If successful, 
+/* 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)
 {
@@ -342,8 +343,8 @@ UINT    status;
 }
 
 
-/* This function allocates a 128 byte block from the specified memory pool.  
-   If successful, the function should return TM_SUCCESS. Otherwise, TM_ERROR 
+/* 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)
 {
@@ -362,8 +363,8 @@ UINT    status;
 }
 
 
-/* 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 
+/* 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)
 {
diff --git a/utility/benchmarks/thread_metric/tm_api.h b/utility/benchmarks/thread_metric/tm_api.h
index 85c8982c..74ac6b11 100644
--- a/utility/benchmarks/thread_metric/tm_api.h
+++ b/utility/benchmarks/thread_metric/tm_api.h
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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                                               */
 /**                                                                       */
 /** Application Interface (API)                                           */
@@ -19,31 +20,25 @@
 /**************************************************************************/
 
 
-/**************************************************************************/ 
-/*                                                                        */ 
-/*  APPLICATION INTERFACE DEFINITION                       RELEASE        */ 
-/*                                                                        */ 
-/*    tm_api.h                                            PORTABLE C      */ 
-/*                                                           6.1.7        */ 
-/*  AUTHOR                                                                */ 
-/*                                                                        */ 
-/*    William E. Lamie, Microsoft Corporation                             */ 
-/*                                                                        */ 
-/*  DESCRIPTION                                                           */ 
-/*                                                                        */ 
-/*    This file defines the basic Application Interface (API)             */ 
+/**************************************************************************/
+/*                                                                        */
+/*  APPLICATION INTERFACE DEFINITION                       RELEASE        */
+/*                                                                        */
+/*    tm_api.h                                            PORTABLE C      */
+/*                                                           6.1.7        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    William E. Lamie, Microsoft Corporation                             */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
+/*    This file defines the basic Application Interface (API)             */
 /*    implementation source code for the Thread-Metrics performance       */
 /*    test suite. All service prototypes and data structure definitions   */
-/*    are defined in this file.                                           */ 
-/*                                                                        */ 
-/*  RELEASE HISTORY                                                       */ 
-/*                                                                        */ 
-/*    DATE              NAME                      DESCRIPTION             */ 
-/*                                                                        */ 
-/*  10-15-2021     William E. Lamie         Initial Version 6.1.7         */
-/*                                                                        */ 
-/**************************************************************************/ 
-  
+/*    are defined in this file.                                           */
+/*                                                                        */
+/**************************************************************************/
+
 #ifndef  TM_API_H
 #define  TM_API_H
 
diff --git a/utility/benchmarks/thread_metric/tm_basic_processing_test.c b/utility/benchmarks/thread_metric/tm_basic_processing_test.c
index 27f3e48e..f1c4fa22 100644
--- a/utility/benchmarks/thread_metric/tm_basic_processing_test.c
+++ b/utility/benchmarks/thread_metric/tm_basic_processing_test.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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                                               */
 /**                                                                       */
 /**   Basic Processing Test                                               */
@@ -19,28 +20,22 @@
 /**************************************************************************/
 
 
-/**************************************************************************/ 
-/*                                                                        */ 
-/*  FUNCTION                                               RELEASE        */ 
-/*                                                                        */ 
-/*    tm_basic_processing_test                            PORTABLE C      */ 
-/*                                                           6.1.7        */ 
-/*  AUTHOR                                                                */ 
-/*                                                                        */ 
-/*    William E. Lamie, Microsoft Corporation                             */ 
-/*                                                                        */ 
-/*  DESCRIPTION                                                           */ 
-/*                                                                        */ 
+/**************************************************************************/
+/*                                                                        */
+/*  FUNCTION                                               RELEASE        */
+/*                                                                        */
+/*    tm_basic_processing_test                            PORTABLE C      */
+/*                                                           6.1.7        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    William E. Lamie, Microsoft Corporation                             */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
 /*    This file defines the basic test for determining board processing   */
 /*    capabilities                                                        */
-/*                                                                        */ 
-/*  RELEASE HISTORY                                                       */ 
-/*                                                                        */ 
-/*    DATE              NAME                      DESCRIPTION             */ 
-/*                                                                        */ 
-/*  10-15-2021     William E. Lamie         Initial Version 6.1.7         */
-/*                                                                        */ 
-/**************************************************************************/ 
+/*                                                                        */
+/**************************************************************************/
 #include "tm_api.h"
 
 
@@ -49,8 +44,8 @@
 unsigned long   tm_basic_processing_counter;
 
 
-/* Test array.  We will just do a series of calculations on the 
-   test array to eat up processing bandwidth. The idea is that 
+/* Test array.  We will just do a series of calculations on the
+   test array to eat up processing bandwidth. The idea is that
    all RTOSes should produce the same metric here if everything
    else is equal, e.g. processor speed, memory speed, etc.  */
 
@@ -92,7 +87,7 @@ void  tm_basic_processing_initialize(void)
     /* Resume thread 0.  */
     tm_thread_resume(0);
 
-    /* Create the reporting thread. It will preempt the other 
+    /* Create the reporting thread. It will preempt the other
        threads and print out the test results.  */
     tm_thread_create(5, 2, tm_basic_processing_thread_report);
     tm_thread_resume(5);
@@ -116,9 +111,9 @@ int     i;
     while(1)
     {
 
-        /* Loop through the basic processing array, add the previous 
+        /* Loop through the basic processing array, add the previous
            contents with the contents of the tm_basic_processing_counter
-           and xor the result with the previous value...   just to eat 
+           and xor the result with the previous value...   just to eat
            up some time.  */
         for (i = 0; i < 1024; i++)
         {
diff --git a/utility/benchmarks/thread_metric/tm_cooperative_scheduling_test.c b/utility/benchmarks/thread_metric/tm_cooperative_scheduling_test.c
index b444c723..31d18c18 100644
--- a/utility/benchmarks/thread_metric/tm_cooperative_scheduling_test.c
+++ b/utility/benchmarks/thread_metric/tm_cooperative_scheduling_test.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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                                               */
 /**                                                                       */
 /**   Cooperative Scheduling Test                                         */
@@ -18,27 +19,21 @@
 /**************************************************************************/
 /**************************************************************************/
 
-/**************************************************************************/ 
-/*                                                                        */ 
-/*  FUNCTION                                               RELEASE        */ 
-/*                                                                        */ 
-/*    tm_cooperative_scheduling_test                      PORTABLE C      */ 
-/*                                                           6.1.7        */ 
-/*  AUTHOR                                                                */ 
-/*                                                                        */ 
-/*    William E. Lamie, Microsoft Corporation                             */ 
-/*                                                                        */ 
-/*  DESCRIPTION                                                           */ 
-/*                                                                        */ 
+/**************************************************************************/
+/*                                                                        */
+/*  FUNCTION                                               RELEASE        */
+/*                                                                        */
+/*    tm_cooperative_scheduling_test                      PORTABLE C      */
+/*                                                           6.1.7        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    William E. Lamie, Microsoft Corporation                             */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
 /*    This file defines the cooperative scheduling test.                  */
-/*                                                                        */ 
-/*  RELEASE HISTORY                                                       */ 
-/*                                                                        */ 
-/*    DATE              NAME                      DESCRIPTION             */ 
-/*                                                                        */ 
-/*  10-15-2021     William E. Lamie         Initial Version 6.1.7         */
-/*                                                                        */ 
-/**************************************************************************/ 
+/*                                                                        */
+/**************************************************************************/
 #include "tm_api.h"
 
 
@@ -99,7 +94,7 @@ void  tm_cooperative_scheduling_initialize(void)
     tm_thread_resume(3);
     tm_thread_resume(4);
 
-    /* Create the reporting thread. It will preempt the other 
+    /* Create the reporting thread. It will preempt the other
        threads and print out the test results.  */
     tm_thread_create(5, 2, tm_cooperative_thread_report);
     tm_thread_resume(5);
@@ -112,7 +107,7 @@ void  tm_cooperative_thread_0_entry(void)
 
     while(1)
     {
-      
+
         /* Relinquish to all other threads at same priority.  */
         tm_thread_relinquish();
 
@@ -217,7 +212,7 @@ unsigned long   average;
 
         /* Calculate the average of all the counters.  */
         average =  total/5;
-		
+
 		/* WCC - integrity check */
 		printf("tm_cooperative_thread_0_counter: %d\n", tm_cooperative_thread_0_counter);
 		printf("tm_cooperative_thread_1_counter: %d\n", tm_cooperative_thread_1_counter);
@@ -226,15 +221,15 @@ unsigned long   average;
 		printf("tm_cooperative_thread_4_counter: %d\n", tm_cooperative_thread_4_counter);
 
         /* See if there are any errors.  */
-        if ((tm_cooperative_thread_0_counter < (average - 1)) || 
+        if ((tm_cooperative_thread_0_counter < (average - 1)) ||
             (tm_cooperative_thread_0_counter > (average + 1)) ||
-            (tm_cooperative_thread_1_counter < (average - 1)) || 
+            (tm_cooperative_thread_1_counter < (average - 1)) ||
             (tm_cooperative_thread_1_counter > (average + 1)) ||
-            (tm_cooperative_thread_2_counter < (average - 1)) || 
+            (tm_cooperative_thread_2_counter < (average - 1)) ||
             (tm_cooperative_thread_2_counter > (average + 1)) ||
-            (tm_cooperative_thread_3_counter < (average - 1)) || 
+            (tm_cooperative_thread_3_counter < (average - 1)) ||
             (tm_cooperative_thread_3_counter > (average + 1)) ||
-            (tm_cooperative_thread_4_counter < (average - 1)) || 
+            (tm_cooperative_thread_4_counter < (average - 1)) ||
             (tm_cooperative_thread_4_counter > (average + 1)))
         {
 
diff --git a/utility/benchmarks/thread_metric/tm_interrupt_preemption_processing_test.c b/utility/benchmarks/thread_metric/tm_interrupt_preemption_processing_test.c
index 3ed64a78..5b6aeec2 100644
--- a/utility/benchmarks/thread_metric/tm_interrupt_preemption_processing_test.c
+++ b/utility/benchmarks/thread_metric/tm_interrupt_preemption_processing_test.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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                                               */
 /**                                                                       */
 /**   Interrupt Preemption Processing Test                                */
@@ -19,27 +20,21 @@
 /**************************************************************************/
 
 
-/**************************************************************************/ 
-/*                                                                        */ 
-/*  FUNCTION                                               RELEASE        */ 
-/*                                                                        */ 
-/*    tm_interrupt_preemption_processing_test             PORTABLE C      */ 
-/*                                                           6.1.7        */ 
-/*  AUTHOR                                                                */ 
-/*                                                                        */ 
-/*    William E. Lamie, Microsoft Corporation                             */ 
-/*                                                                        */ 
-/*  DESCRIPTION                                                           */ 
-/*                                                                        */ 
+/**************************************************************************/
+/*                                                                        */
+/*  FUNCTION                                               RELEASE        */
+/*                                                                        */
+/*    tm_interrupt_preemption_processing_test             PORTABLE C      */
+/*                                                           6.1.7        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    William E. Lamie, Microsoft Corporation                             */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
 /*    This file defines the preemptive scheduling test.                   */
-/*                                                                        */ 
-/*  RELEASE HISTORY                                                       */ 
-/*                                                                        */ 
-/*    DATE              NAME                      DESCRIPTION             */ 
-/*                                                                        */ 
-/*  10-15-2021     William E. Lamie         Initial Version 6.1.7         */
-/*                                                                        */ 
-/**************************************************************************/ 
+/*                                                                        */
+/**************************************************************************/
 
 #include "tm_api.h"
 
@@ -97,14 +92,14 @@ void  tm_interrupt_preemption_processing_initialize(void)
     /* Resume just thread 1.  */
     tm_thread_resume(1);
 
-    /* Create the reporting thread. It will preempt the other 
+    /* Create the reporting thread. It will preempt the other
        threads and print out the test results.  */
     tm_thread_create(5, 2, tm_interrupt_preemption_thread_report);
     tm_thread_resume(5);
 }
 
 
-/* Define the interrupt thread.  This thread is resumed from the 
+/* Define the interrupt thread.  This thread is resumed from the
    interrupt handler.  It runs and suspends.  */
 void  tm_interrupt_preemption_thread_0_entry(void)
 {
@@ -115,7 +110,7 @@ void  tm_interrupt_preemption_thread_0_entry(void)
         /* Increment this thread's counter.  */
         tm_interrupt_preemption_thread_0_counter++;
 
-        /* Suspend. This will allow the thread generating the 
+        /* Suspend. This will allow the thread generating the
            interrupt to run again.  */
         tm_thread_suspend(0);
     }
@@ -128,7 +123,7 @@ void  tm_interrupt_preemption_thread_1_entry(void)
     while(1)
     {
 
-        /* Force an interrupt. The underlying RTOS must see that the 
+        /* Force an interrupt. The underlying RTOS must see that the
            the interrupt handler is called from the appropriate software
            interrupt or trap. */
         TM_CAUSE_INTERRUPT
@@ -192,11 +187,11 @@ unsigned long   average;
         average =  total/3;
 
         /* See if there are any errors.  */
-        if ((tm_interrupt_preemption_thread_0_counter < (average - 1)) || 
+        if ((tm_interrupt_preemption_thread_0_counter < (average - 1)) ||
             (tm_interrupt_preemption_thread_0_counter > (average + 1)) ||
-            (tm_interrupt_preemption_thread_1_counter < (average - 1)) || 
+            (tm_interrupt_preemption_thread_1_counter < (average - 1)) ||
             (tm_interrupt_preemption_thread_1_counter > (average + 1)) ||
-            (tm_interrupt_preemption_handler_counter < (average - 1)) || 
+            (tm_interrupt_preemption_handler_counter < (average - 1)) ||
             (tm_interrupt_preemption_handler_counter > (average + 1)))
         {
 
diff --git a/utility/benchmarks/thread_metric/tm_interrupt_processing_test.c b/utility/benchmarks/thread_metric/tm_interrupt_processing_test.c
index 6591593e..69d156d9 100644
--- a/utility/benchmarks/thread_metric/tm_interrupt_processing_test.c
+++ b/utility/benchmarks/thread_metric/tm_interrupt_processing_test.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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                                               */
 /**                                                                       */
 /**   Interrupt Processing Test                                           */
@@ -18,27 +19,21 @@
 /**************************************************************************/
 /**************************************************************************/
 
-/**************************************************************************/ 
-/*                                                                        */ 
-/*  FUNCTION                                               RELEASE        */ 
-/*                                                                        */ 
-/*    tm_interrupt_processing_test                        PORTABLE C      */ 
-/*                                                           6.1.7        */ 
-/*  AUTHOR                                                                */ 
-/*                                                                        */ 
-/*    William E. Lamie, Microsoft Corporation                             */ 
-/*                                                                        */ 
-/*  DESCRIPTION                                                           */ 
-/*                                                                        */ 
+/**************************************************************************/
+/*                                                                        */
+/*  FUNCTION                                               RELEASE        */
+/*                                                                        */
+/*    tm_interrupt_processing_test                        PORTABLE C      */
+/*                                                           6.1.7        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    William E. Lamie, Microsoft Corporation                             */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
 /*    This file defines the No-preemption interrupt processing test.      */
-/*                                                                        */ 
-/*  RELEASE HISTORY                                                       */ 
-/*                                                                        */ 
-/*    DATE              NAME                      DESCRIPTION             */ 
-/*                                                                        */ 
-/*  10-15-2021     William E. Lamie         Initial Version 6.1.7         */
-/*                                                                        */ 
-/**************************************************************************/ 
+/*                                                                        */
+/**************************************************************************/
 #include "tm_api.h"
 
 
@@ -87,14 +82,14 @@ void  tm_interrupt_processing_initialize(void)
     /* Create thread that generates the interrupt at priority 10.  */
     tm_thread_create(0, 10, tm_interrupt_thread_0_entry);
 
-    /* Create a semaphore that will be posted from the interrupt 
+    /* Create a semaphore that will be posted from the interrupt
        handler.  */
     tm_semaphore_create(0);
 
     /* Resume just thread 0.  */
     tm_thread_resume(0);
 
-    /* Create the reporting thread. It will preempt the other 
+    /* Create the reporting thread. It will preempt the other
        threads and print out the test results.  */
     tm_thread_create(5, 2, tm_interrupt_thread_report);
     tm_thread_resume(5);
@@ -118,13 +113,13 @@ int status;
     while(1)
     {
 
-        /* Force an interrupt. The underlying RTOS must see that the 
+        /* Force an interrupt. The underlying RTOS must see that the
            the interrupt handler is called from the appropriate software
            interrupt or trap. */
        TM_CAUSE_INTERRUPT
 
         /* We won't get back here until the interrupt processing is complete,
-           including the setting of the semaphore from the interrupt 
+           including the setting of the semaphore from the interrupt
            handler.  */
 
         /* Pickup the semaphore set by the interrupt handler. */
@@ -189,9 +184,9 @@ unsigned long   average;
         average =  total/2;
 
         /* See if there are any errors.  */
-        if ((tm_interrupt_thread_0_counter < (average - 1)) || 
+        if ((tm_interrupt_thread_0_counter < (average - 1)) ||
             (tm_interrupt_thread_0_counter > (average + 1)) ||
-            (tm_interrupt_handler_counter < (average - 1)) || 
+            (tm_interrupt_handler_counter < (average - 1)) ||
             (tm_interrupt_handler_counter > (average + 1)))
         {
 
diff --git a/utility/benchmarks/thread_metric/tm_memory_allocation_test.c b/utility/benchmarks/thread_metric/tm_memory_allocation_test.c
index 9e88861f..fc1c40d7 100644
--- a/utility/benchmarks/thread_metric/tm_memory_allocation_test.c
+++ b/utility/benchmarks/thread_metric/tm_memory_allocation_test.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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                                               */
 /**                                                                       */
 /**   Memory Allocation Test                                              */
@@ -18,27 +19,21 @@
 /**************************************************************************/
 /**************************************************************************/
 
-/**************************************************************************/ 
-/*                                                                        */ 
-/*  FUNCTION                                               RELEASE        */ 
-/*                                                                        */ 
-/*    tm_memory_allocation_test                           PORTABLE C      */ 
-/*                                                           6.1.7        */ 
-/*  AUTHOR                                                                */ 
-/*                                                                        */ 
-/*    William E. Lamie, Microsoft Corporation                             */ 
-/*                                                                        */ 
-/*  DESCRIPTION                                                           */ 
-/*                                                                        */ 
+/**************************************************************************/
+/*                                                                        */
+/*  FUNCTION                                               RELEASE        */
+/*                                                                        */
+/*    tm_memory_allocation_test                           PORTABLE C      */
+/*                                                           6.1.7        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    William E. Lamie, Microsoft Corporation                             */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
 /*    This file defines the Message exchange processing test.             */
-/*                                                                        */ 
-/*  RELEASE HISTORY                                                       */ 
-/*                                                                        */ 
-/*    DATE              NAME                      DESCRIPTION             */ 
-/*                                                                        */ 
-/*  10-15-2021     William E. Lamie         Initial Version 6.1.7         */
-/*                                                                        */ 
-/**************************************************************************/ 
+/*                                                                        */
+/**************************************************************************/
 #include "tm_api.h"
 
 
@@ -86,7 +81,7 @@ void  tm_memory_allocation_initialize(void)
     /* Create a memory pool.  */
     tm_memory_pool_create(0);
 
-    /* Create the reporting thread. It will preempt the other 
+    /* Create the reporting thread. It will preempt the other
        threads and print out the test results.  */
     tm_thread_create(5, 2, tm_memory_allocation_thread_report);
     tm_thread_resume(5);
diff --git a/utility/benchmarks/thread_metric/tm_message_processing_test.c b/utility/benchmarks/thread_metric/tm_message_processing_test.c
index c709252b..f82da79e 100644
--- a/utility/benchmarks/thread_metric/tm_message_processing_test.c
+++ b/utility/benchmarks/thread_metric/tm_message_processing_test.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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                                               */
 /**                                                                       */
 /**   Message Processing Test                                             */
@@ -19,27 +20,21 @@
 /**************************************************************************/
 
 
-/**************************************************************************/ 
-/*                                                                        */ 
-/*  FUCTION                                                RELEASE        */ 
-/*                                                                        */ 
-/*    tm_message_processing_test                          PORTABLE C      */ 
-/*                                                           6.1.7        */ 
-/*  AUTHOR                                                                */ 
-/*                                                                        */ 
-/*    William E. Lamie, Microsoft Corporation                             */ 
-/*                                                                        */ 
-/*  DESCRIPTION                                                           */ 
-/*                                                                        */ 
+/**************************************************************************/
+/*                                                                        */
+/*  FUCTION                                                RELEASE        */
+/*                                                                        */
+/*    tm_message_processing_test                          PORTABLE C      */
+/*                                                           6.1.7        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    William E. Lamie, Microsoft Corporation                             */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
 /*    Basic test for message exchange processing.                         */
-/*                                                                        */ 
-/*  RELEASE HISTORY                                                       */ 
-/*                                                                        */ 
-/*    DATE              NAME                      DESCRIPTION             */ 
-/*                                                                        */ 
-/*  10-15-2021     William E. Lamie         Initial Version 6.1.7         */
-/*                                                                        */ 
-/**************************************************************************/ 
+/*                                                                        */
+/**************************************************************************/
 #include "tm_api.h"
 
 
@@ -89,7 +84,7 @@ void  tm_message_processing_initialize(void)
     /* Create a queue for the message passing.  */
     tm_queue_create(0);
 
-    /* Create the reporting thread. It will preempt the other 
+    /* Create the reporting thread. It will preempt the other
        threads and print out the test results.  */
     tm_thread_create(5, 2, tm_message_processing_thread_report);
     tm_thread_resume(5);
@@ -107,7 +102,7 @@ void  tm_message_processing_thread_0_entry(void)
     tm_message_sent[3] =  0x77778888;
 
     while(1)
-    {   	
+    {
         /* Send a message to the queue.  */
         tm_queue_send(0, tm_message_sent);
 
diff --git a/utility/benchmarks/thread_metric/tm_porting_layer.h b/utility/benchmarks/thread_metric/tm_porting_layer.h
index 3e9e2d63..ec1b7a26 100644
--- a/utility/benchmarks/thread_metric/tm_porting_layer.h
+++ b/utility/benchmarks/thread_metric/tm_porting_layer.h
@@ -1,10 +1,11 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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
  **************************************************************************/
 
@@ -14,9 +15,9 @@
 #include <stdio.h>
 
 
-/* Define the TRAP instruction. This is used by the Interrupt Processing and Interrupt Preemption Processing tests. 
-   The SVC instruction below is for Cortex-M architectures using IAR tools. This will likely need to be modified 
-   for different processors and/or development tools. 
+/* Define the TRAP instruction. This is used by the Interrupt Processing and Interrupt Preemption Processing tests.
+   The SVC instruction below is for Cortex-M architectures using IAR tools. This will likely need to be modified
+   for different processors and/or development tools.
 
    Note also that for the Interrupt Processing test there is the assumption that the SVC ISR looks like:
 
diff --git a/utility/benchmarks/thread_metric/tm_porting_layer_template.c b/utility/benchmarks/thread_metric/tm_porting_layer_template.c
index c0460802..fcbc59a8 100644
--- a/utility/benchmarks/thread_metric/tm_porting_layer_template.c
+++ b/utility/benchmarks/thread_metric/tm_porting_layer_template.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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)               */
@@ -24,7 +25,7 @@
 #include    "tm_api.h"
 
 
-/* This function called from main performs basic RTOS initialization, 
+/* 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))
 {
@@ -33,8 +34,8 @@ 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, 
+   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))
 {
@@ -67,7 +68,7 @@ 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. 
+   of seconds.  If successful, the function should return TM_SUCCESS.
    Otherwise, TM_ERROR should be returned.  */
 void tm_thread_sleep(int seconds)
 {
@@ -83,7 +84,7 @@ int  tm_queue_create(int queue_id)
 }
 
 
-/* This function sends a 16-byte message to the specified queue.  If successful, 
+/* 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)
 {
@@ -91,7 +92,7 @@ int  tm_queue_send(int queue_id, unsigned long *message_ptr)
 }
 
 
-/* This function receives a 16-byte message from the specified queue.  If successful, 
+/* 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)
 {
@@ -132,8 +133,8 @@ 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 
+/* 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)
 {
@@ -141,8 +142,8 @@ 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 
+/* 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)
 {
diff --git a/utility/benchmarks/thread_metric/tm_preemptive_scheduling_test.c b/utility/benchmarks/thread_metric/tm_preemptive_scheduling_test.c
index 95ee4be8..ef3222f3 100644
--- a/utility/benchmarks/thread_metric/tm_preemptive_scheduling_test.c
+++ b/utility/benchmarks/thread_metric/tm_preemptive_scheduling_test.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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                                               */
 /**                                                                       */
 /**   Preemptive Scheduling Test                                          */
@@ -18,27 +19,21 @@
 /**************************************************************************/
 /**************************************************************************/
 
-/**************************************************************************/ 
-/*                                                                        */ 
-/*  FUNCTION                                               RELEASE        */ 
-/*                                                                        */ 
-/*    tm_preemptive_scheduling_test                       PORTABLE C      */ 
-/*                                                           6.1.7        */ 
-/*  AUTHOR                                                                */ 
-/*                                                                        */ 
-/*    William E. Lamie, Microsoft Corporation                             */ 
-/*                                                                        */ 
-/*  DESCRIPTION                                                           */ 
-/*                                                                        */ 
+/**************************************************************************/
+/*                                                                        */
+/*  FUNCTION                                               RELEASE        */
+/*                                                                        */
+/*    tm_preemptive_scheduling_test                       PORTABLE C      */
+/*                                                           6.1.7        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    William E. Lamie, Microsoft Corporation                             */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
 /*    This file defines the preemptive scheduling test.                   */
-/*                                                                        */ 
-/*  RELEASE HISTORY                                                       */ 
-/*                                                                        */ 
-/*    DATE              NAME                      DESCRIPTION             */ 
-/*                                                                        */ 
-/*  10-15-2021     William E. Lamie         Initial Version 6.1.7         */
-/*                                                                        */ 
-/**************************************************************************/ 
+/*                                                                        */
+/**************************************************************************/
 #include "tm_api.h"
 
 
@@ -103,7 +98,7 @@ void  tm_preemptive_scheduling_initialize(void)
     /* Resume just thread 0.  */
     tm_thread_resume(0);
 
-    /* Create the reporting thread. It will preempt the other 
+    /* Create the reporting thread. It will preempt the other
        threads and print out the test results.  */
     tm_thread_create(5, 2, tm_preemptive_thread_report);
     tm_thread_resume(5);
@@ -245,15 +240,15 @@ unsigned long   average;
         average =  total/5;
 
         /* See if there are any errors.  */
-        if ((tm_preemptive_thread_0_counter < (average - 1)) || 
+        if ((tm_preemptive_thread_0_counter < (average - 1)) ||
             (tm_preemptive_thread_0_counter > (average + 1)) ||
-            (tm_preemptive_thread_1_counter < (average - 1)) || 
+            (tm_preemptive_thread_1_counter < (average - 1)) ||
             (tm_preemptive_thread_1_counter > (average + 1)) ||
-            (tm_preemptive_thread_2_counter < (average - 1)) || 
+            (tm_preemptive_thread_2_counter < (average - 1)) ||
             (tm_preemptive_thread_2_counter > (average + 1)) ||
-            (tm_preemptive_thread_3_counter < (average - 1)) || 
+            (tm_preemptive_thread_3_counter < (average - 1)) ||
             (tm_preemptive_thread_3_counter > (average + 1)) ||
-            (tm_preemptive_thread_4_counter < (average - 1)) || 
+            (tm_preemptive_thread_4_counter < (average - 1)) ||
             (tm_preemptive_thread_4_counter > (average + 1)))
         {
 
diff --git a/utility/benchmarks/thread_metric/tm_synchronization_processing_test.c b/utility/benchmarks/thread_metric/tm_synchronization_processing_test.c
index 103ad7ea..6fa2a187 100644
--- a/utility/benchmarks/thread_metric/tm_synchronization_processing_test.c
+++ b/utility/benchmarks/thread_metric/tm_synchronization_processing_test.c
@@ -1,16 +1,17 @@
 /***************************************************************************
- * Copyright (c) 2024 Microsoft Corporation 
- * 
+ * 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                                               */
 /**                                                                       */
 /**   Synchronization Processing Test                                     */
@@ -18,27 +19,21 @@
 /**************************************************************************/
 /**************************************************************************/
 
-/**************************************************************************/ 
-/*                                                                        */ 
-/*  FUNCTION                                               RELEASE        */ 
-/*                                                                        */ 
-/*    tm_synchronization_processing_test                  PORTABLE C      */ 
-/*                                                           6.1.7        */ 
-/*  AUTHOR                                                                */ 
-/*                                                                        */ 
-/*    William E. Lamie, Microsoft Corporation                             */ 
-/*                                                                        */ 
-/*  DESCRIPTION                                                           */ 
-/*                                                                        */ 
+/**************************************************************************/
+/*                                                                        */
+/*  FUNCTION                                               RELEASE        */
+/*                                                                        */
+/*    tm_synchronization_processing_test                  PORTABLE C      */
+/*                                                           6.1.7        */
+/*  AUTHOR                                                                */
+/*                                                                        */
+/*    William E. Lamie, Microsoft Corporation                             */
+/*                                                                        */
+/*  DESCRIPTION                                                           */
+/*                                                                        */
 /*    This file defines the Semaphore get/put processing test.            */
-/*                                                                        */ 
-/*  RELEASE HISTORY                                                       */ 
-/*                                                                        */ 
-/*    DATE              NAME                      DESCRIPTION             */ 
-/*                                                                        */ 
-/*  10-15-2021     William E. Lamie         Initial Version 6.1.7         */
-/*                                                                        */ 
-/**************************************************************************/ 
+/*                                                                        */
+/**************************************************************************/
 #include "tm_api.h"
 
 
@@ -86,7 +81,7 @@ void  tm_synchronization_processing_initialize(void)
     /* Create a semaphore for the test.  */
     tm_semaphore_create(0);
 
-    /* Create the reporting thread. It will preempt the other 
+    /* Create the reporting thread. It will preempt the other
        threads and print out the test results.  */
     tm_thread_create(5, 2, tm_synchronization_processing_thread_report);
     tm_thread_resume(5);