[OpenMP][NFC] Format all files in OpenMP

[tianshilei1992]

Summary

This patch just executed clang-format on all source files of OpenMP,
excluding all test cases. Here is the Python script:

import glob
import subprocess

worklist = []

for f in glob.glob('llvm-project/openmp/**', recursive=True):
  if f.endswith('.h') or f.endswith('.hpp') or f.endswith('.c') or f.endswith('.cpp') or f.endswith('.cu') or f.endswith('.hip'):
    if '/tests/' in f or '/test/' in f:
      continue
    worklist.append(f)

for f in worklist:
  subprocess.Popen(['clang-format', f, '-i'])

[AndreyChurbanov]

I am afraid such action may be needed regularly, unless we freeze the clang-format version and write it in the documentation.
Because each version of clang-format may produce different result of formatting, unfortunately.
At least that was the case couple of years ago.

[tianshilei1992]

In D95318#2518566, @AndreyChurbanov wrote:

I am afraid such action may be needed regularly, unless we freeze the clang-format version and write it in the documentation.
Because each version of clang-format may produce different result of formatting, unfortunately.
At least that was the case couple of years ago.

Unluckily yes. The last time we did whole project format is probably three years ago, so I guess it's fine.

[jdoerfert]

In D95318#2518566, @AndreyChurbanov wrote:

I am afraid such action may be needed regularly, unless we freeze the clang-format version and write it in the documentation.
Because each version of clang-format may produce different result of formatting, unfortunately.
At least that was the case couple of years ago.

I propose the following:

1. Clang format the repo, or parts of it (libomptarget for example) [optional!]
2. From now on forward, require each patch to be clang formatted, with git-clang-format or similar.
3. If it is beneficial for a specific piece of code to be formatted explicitly before a diff is applied, do so in a NFC pre-commit.
4. If we went with 1., we can from time to time redo 1. but from my experience with the Attributor this is mostly necessary because 1) was violated.

We *should not* freeze the clang-format version. We *should* write it in the documentation if we require 2), as we *should* write that doxygen comments are necessary and LLVM formatting is preferred. If a difference in formatting is from clang-format changes, rule 3. might apply but that is arguably not a problem.

I guess we should bring this up Wednesday.

[JonChesterfield]

There is a 'correct' version of clang-format to use. It's whatever phab runs as part of the auto-checking machinery. Hopefully that's clang-format from trunk, as that one is always available on disk, but it might also be the one from the last release.

Aside from clang-format, changes to this library are plagued by clang-tidy warnings. Some are fixable - our_function can become ourFunction. Some are not, such as warnings on uint32_t. Some might be - errors on unrecognised intrinsics because it assumes x64 (or at least, doesn't assume amdgcn/nvptx), or warnings about <gelf.h> not being found.

I'm in favour of running (preferably the above version) of clang-format across everything, ideally at a moment when there aren't a lot of large open reviews. Arcanist barks at me when I forget to clang-format the change, so perhaps that will suffice to avoid needing this again in a year or so.

[tianshilei1992]

Discussion are still open. ;-)

openmp/libomptarget/deviceRTLs/common/omptarget.h

 //===---- omptarget.h - OpenMP GPU initialization ---------------- CUDA -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the declarations of all library macros, types,
 // and functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_H
 #define OMPTARGET_H
 
-#include "target_impl.h"
-#include "common/debug.h"     // debug
-#include "interface.h" // interfaces with omp, compiler, and user
+#include "common/debug.h" // debug
 #include "common/state-queue.h"
 #include "common/support.h"
+#include "interface.h" // interfaces with omp, compiler, and user
+#include "target_impl.h"
 
 #define OMPTARGET_NVPTX_VERSION 1.1
 
 // used by the library for the interface with the app
 #define DISPATCH_FINISHED 0
 #define DISPATCH_NOTFINISHED 1
 
 // used by dynamic scheduling
 #define FINISHED 0
 #define NOT_FINISHED 1
 #define LAST_CHUNK 2
 
 #define BARRIER_COUNTER 0
 #define ORDERED_COUNTER 1
 
 // arguments needed for L0 parallelism only.
 class omptarget_nvptx_SharedArgs {
 public:
   // All these methods must be called by the master thread only.
   INLINE void Init() {
-    args  = buffer;
+    args = buffer;
     nArgs = MAX_SHARED_ARGS;
   }
   INLINE void DeInit() {
     // Free any memory allocated for outlined parallel function with a large
     // number of arguments.
     if (nArgs > MAX_SHARED_ARGS) {
       SafeFree(args, "new extended args");
       Init();
     }
   }
   INLINE void EnsureSize(size_t size) {
     if (size > nArgs) {
       if (nArgs > MAX_SHARED_ARGS) {
         SafeFree(args, "new extended args");
       }
       args = (void **)SafeMalloc(size * sizeof(void *), "new extended args");
       nArgs = size;
     }
   }
   // Called by all threads.
   INLINE void **GetArgs() const { return args; };
+
 private:
   // buffer of pre-allocated arguments.
   void *buffer[MAX_SHARED_ARGS];
   // pointer to arguments buffer.
   // starts off as a pointer to 'buffer' but can be dynamically allocated.
   void **args;
   // starts off as MAX_SHARED_ARGS but can increase in size.
   uint32_t nArgs;
 };
 
-extern DEVICE SHARED omptarget_nvptx_SharedArgs
-    omptarget_nvptx_globalArgs;
+extern DEVICE SHARED omptarget_nvptx_SharedArgs omptarget_nvptx_globalArgs;
 
 // Worker slot type which is initialized with the default worker slot
 // size of 4*32 bytes.
 struct __kmpc_data_sharing_slot {
   __kmpc_data_sharing_slot *Next;
   __kmpc_data_sharing_slot *Prev;
   void *PrevSlotStackPtr;
   void *DataEnd;
   char Data[DS_Worker_Warp_Slot_Size];
 };
 
 // Data structure to keep in shared memory that traces the current slot, stack,
 // and frame pointer as well as the active threads that didn't exit the current
 // environment.
 struct DataSharingStateTy {
   __kmpc_data_sharing_slot *SlotPtr[DS_Max_Warp_Number];
   void *StackPtr[DS_Max_Warp_Number];
-  void * volatile FramePtr[DS_Max_Warp_Number];
+  void *volatile FramePtr[DS_Max_Warp_Number];
   __kmpc_impl_lanemask_t ActiveThreads[DS_Max_Warp_Number];
 };
 
 extern DEVICE SHARED DataSharingStateTy DataSharingState;
 
 ////////////////////////////////////////////////////////////////////////////////
 // task ICV and (implicit & explicit) task state
 

 ////////////////////////////////////////////////////////////////////////////////
 // global data tables
 ////////////////////////////////////////////////////////////////////////////////
 
 extern DEVICE omptarget_nvptx_SimpleMemoryManager
     omptarget_nvptx_simpleMemoryManager;
 extern DEVICE SHARED uint32_t usedMemIdx;
 extern DEVICE SHARED uint32_t usedSlotIdx;
-extern DEVICE SHARED uint8_t
-    parallelLevel[MAX_THREADS_PER_TEAM / WARPSIZE];
+extern DEVICE SHARED uint8_t parallelLevel[MAX_THREADS_PER_TEAM / WARPSIZE];
 extern DEVICE SHARED uint16_t threadLimit;
 extern DEVICE SHARED uint16_t threadsInTeam;
 extern DEVICE SHARED uint16_t nThreads;
 extern DEVICE SHARED
     omptarget_nvptx_ThreadPrivateContext *omptarget_nvptx_threadPrivateContext;
 
 extern DEVICE SHARED uint32_t execution_param;
 extern DEVICE SHARED void *ReductionScratchpadPtr;
 
 ////////////////////////////////////////////////////////////////////////////////
 // work function (outlined parallel/simd functions) and arguments.
 // needed for L1 parallelism only.
 ////////////////////////////////////////////////////////////////////////////////
 
 typedef void *omptarget_nvptx_WorkFn;
-extern volatile DEVICE SHARED omptarget_nvptx_WorkFn
-    omptarget_nvptx_workFn;
+extern volatile DEVICE SHARED omptarget_nvptx_WorkFn omptarget_nvptx_workFn;
 
 ////////////////////////////////////////////////////////////////////////////////
 // get private data structures
 ////////////////////////////////////////////////////////////////////////////////
 
 INLINE omptarget_nvptx_TeamDescr &getMyTeamDescriptor();
 INLINE omptarget_nvptx_WorkDescr &getMyWorkDescriptor();
 INLINE omptarget_nvptx_TaskDescr *

openmp/libomptarget/deviceRTLs/common/omptargeti.h

 // and functions.
 //
 //===----------------------------------------------------------------------===//
 
 ////////////////////////////////////////////////////////////////////////////////
 // Task Descriptor
 ////////////////////////////////////////////////////////////////////////////////
 
 INLINE omp_sched_t omptarget_nvptx_TaskDescr::GetRuntimeSched() const {
   // sched starts from 1..4; encode it as 0..3; so add 1 here
   uint8_t rc = (items.flags & TaskDescr_SchedMask) + 1;
   return (omp_sched_t)rc;
 }
 
 INLINE void omptarget_nvptx_TaskDescr::SetRuntimeSched(omp_sched_t sched) {
   // sched starts from 1..4; encode it as 0..3; so sub 1 here
   uint8_t val = ((uint8_t)sched) - 1;
   // clear current sched
   items.flags &= ~TaskDescr_SchedMask;
   // set new sched
   items.flags |= val;
 }
 
-INLINE void
-omptarget_nvptx_TaskDescr::InitLevelZeroTaskDescr() {
+INLINE void omptarget_nvptx_TaskDescr::InitLevelZeroTaskDescr() {
   // slow method
   // flag:
   //   default sched is static,
   //   dyn is off (unused now anyway, but may need to sample from host ?)
   //   not in parallel
 
   items.flags = 0;
   items.threadId = 0;         // is master
   items.runtimeChunkSize = 1; // preferred chunking statik with chunk 1
 }
 
 // This is called when all threads are started together in SPMD mode.
 // OMP directives include target parallel, target distribute parallel for, etc.
 INLINE void omptarget_nvptx_TaskDescr::InitLevelOneTaskDescr(
     omptarget_nvptx_TaskDescr *parentTaskDescr) {
   // slow method
   // flag:
   //   default sched is static,
   //   dyn is off (unused now anyway, but may need to sample from host ?)
   //   in L1 parallel
 
-  items.flags =
-      TaskDescr_InPar | TaskDescr_IsParConstr; // set flag to parallel
+  items.flags = TaskDescr_InPar | TaskDescr_IsParConstr; // set flag to parallel
   items.threadId =
-      GetThreadIdInBlock(); // get ids from cuda (only called for 1st level)
+      GetThreadIdInBlock();   // get ids from cuda (only called for 1st level)
   items.runtimeChunkSize = 1; // preferred chunking statik with chunk 1
   prev = parentTaskDescr;
 }
 
 INLINE void omptarget_nvptx_TaskDescr::CopyData(
     omptarget_nvptx_TaskDescr *sourceTaskDescr) {
   items = sourceTaskDescr->items;
 }

openmp/libomptarget/deviceRTLs/common/src/cancel.cu

 //===------ cancel.cu - NVPTX OpenMP cancel interface ------------ CUDA -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Interface to be used in the implementation of OpenMP cancel.
 //
 //===----------------------------------------------------------------------===//
 #pragma omp declare target
 
-#include "interface.h"
 #include "common/debug.h"
+#include "interface.h"
 
 EXTERN int32_t __kmpc_cancellationpoint(kmp_Ident *loc, int32_t global_tid,
                                         int32_t cancelVal) {
   PRINT(LD_IO, "call kmpc_cancellationpoint(cancel val %d)\n", (int)cancelVal);
   // disabled
   return 0;
 }
 
 EXTERN int32_t __kmpc_cancel(kmp_Ident *loc, int32_t global_tid,
                              int32_t cancelVal) {
   PRINT(LD_IO, "call kmpc_cancel(cancel val %d)\n", (int)cancelVal);
   // disabled
   return 0;
 }
 
 #pragma omp end declare target

openmp/libomptarget/deviceRTLs/common/src/critical.cu

 //===------ critical.cu - NVPTX OpenMP critical ------------------ CUDA -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the implementation of critical with KMPC interface
 //
 //===----------------------------------------------------------------------===//
 #pragma omp declare target
 
-#include "interface.h"
 #include "common/debug.h"
+#include "interface.h"
 
 EXTERN
 void __kmpc_critical(kmp_Ident *loc, int32_t global_tid,
                      kmp_CriticalName *lck) {
   PRINT0(LD_IO, "call to kmpc_critical()\n");
   omp_set_lock((omp_lock_t *)lck);
 }
 
 EXTERN
 void __kmpc_end_critical(kmp_Ident *loc, int32_t global_tid,
                          kmp_CriticalName *lck) {
   PRINT0(LD_IO, "call to kmpc_end_critical()\n");
   omp_unset_lock((omp_lock_t *)lck);
 }
 
 #pragma omp end declare target

openmp/libomptarget/deviceRTLs/common/src/data_sharing.cu

EXTERN void __kmpc_data_sharing_init_stack_spmd() {
   // statically allocated shared memory slots. The size of a shared memory
   // slot is pre-determined to be 256 bytes.
   if (GetThreadIdInBlock() == 0)
     data_sharing_init_stack_common();
 
   __kmpc_impl_threadfence_block();
 }
 
-INLINE static void* data_sharing_push_stack_common(size_t PushSize) {
+INLINE static void *data_sharing_push_stack_common(size_t PushSize) {
   ASSERT0(LT_FUSSY, isRuntimeInitialized(), "Expected initialized runtime.");
 
   // Only warp active master threads manage the stack.
   bool IsWarpMaster = (GetThreadIdInBlock() % WARPSIZE) == 0;
 
   // Add worst-case padding to DataSize so that future stack allocations are
   // correctly aligned.
   const size_t Alignment = 8;
if (EndAddress < RequestedEndAddress) {
 
       // Allocate at least the default size for each type of slot.
       // Master is a special case and even though there is only one thread,
       // it can share more things with the workers. For uniformity, it uses
       // the full size of a worker warp slot.
       size_t DefaultSlotSize = DS_Worker_Warp_Slot_Size;
       if (DefaultSlotSize > NewSize)
         NewSize = DefaultSlotSize;
-      NewSlot = (__kmpc_data_sharing_slot *) SafeMalloc(
+      NewSlot = (__kmpc_data_sharing_slot *)SafeMalloc(
           sizeof(__kmpc_data_sharing_slot) + NewSize,
           "Global memory slot allocation.");
 
       NewSlot->Next = 0;
       NewSlot->Prev = SlotP;
       NewSlot->PrevSlotStackPtr = StackP;
       NewSlot->DataEnd = &NewSlot->Data[0] + NewSize;
 
EXTERN void *__kmpc_data_sharing_push_stack(size_t DataSize,
   // i.e. one DataSize chunk per warp lane.
   // TODO: change WARPSIZE to the number of active threads in the warp.
   size_t PushSize = (isRuntimeUninitialized() || IsMasterThread(isSPMDMode()))
                         ? DataSize
                         : WARPSIZE * DataSize;
 
   // Compute the start address of the frame of each thread in the warp.
   uintptr_t FrameStartAddress =
-      (uintptr_t) data_sharing_push_stack_common(PushSize);
-  FrameStartAddress += (uintptr_t) (GetLaneId() * DataSize);
+      (uintptr_t)data_sharing_push_stack_common(PushSize);
+  FrameStartAddress += (uintptr_t)(GetLaneId() * DataSize);
   return (void *)FrameStartAddress;
 }
 
 // Pop the stack and free any memory which can be reclaimed.
 //
 // When the pop operation removes the last global memory slot,
 // reclaim all outstanding global memory slots since it is
 // likely we have reached the end of the kernel.

openmp/libomptarget/deviceRTLs/common/src/loop.cu

INLINE static uint64_t NextIter() {
     warp_res = Shuffle(active, warp_res, leader);
     return warp_res + rank;
   }
 
   INLINE static int DynamicNextChunk(T &lb, T &ub, T chunkSize,
                                      T loopLowerBound, T loopUpperBound) {
     T N = NextIter();
     lb = loopLowerBound + N * chunkSize;
-    ub = lb + chunkSize - 1;  // Clang uses i <= ub
+    ub = lb + chunkSize - 1; // Clang uses i <= ub
 
     // 3 result cases:
     //  a. lb and ub < loopUpperBound --> NOT_FINISHED
     //  b. lb < loopUpperBound and ub >= loopUpperBound: last chunk -->
     //  NOT_FINISHED
     //  c. lb and ub >= loopUpperBound: empty chunk --> FINISHED
     // a.
     if (lb <= loopUpperBound && ub < loopUpperBound) {

 // next
 EXTERN int __kmpc_dispatch_next_4(kmp_Ident *loc, int32_t tid, int32_t *p_last,
                                   int32_t *p_lb, int32_t *p_ub, int32_t *p_st) {
   PRINT0(LD_IO, "call kmpc_dispatch_next_4\n");
   return omptarget_nvptx_LoopSupport<int32_t, int32_t>::dispatch_next(
       loc, tid, p_last, p_lb, p_ub, p_st);
 }
 
-EXTERN int __kmpc_dispatch_next_4u(kmp_Ident *loc, int32_t tid,
-                                   int32_t *p_last, uint32_t *p_lb,
-                                   uint32_t *p_ub, int32_t *p_st) {
+EXTERN int __kmpc_dispatch_next_4u(kmp_Ident *loc, int32_t tid, int32_t *p_last,
+                                   uint32_t *p_lb, uint32_t *p_ub,
+                                   int32_t *p_st) {
   PRINT0(LD_IO, "call kmpc_dispatch_next_4u\n");
   return omptarget_nvptx_LoopSupport<uint32_t, int32_t>::dispatch_next(
       loc, tid, p_last, p_lb, p_ub, p_st);
 }
 
 EXTERN int __kmpc_dispatch_next_8(kmp_Ident *loc, int32_t tid, int32_t *p_last,
                                   int64_t *p_lb, int64_t *p_ub, int64_t *p_st) {
   PRINT0(LD_IO, "call kmpc_dispatch_next_8\n");
   return omptarget_nvptx_LoopSupport<int64_t, int64_t>::dispatch_next(
       loc, tid, p_last, p_lb, p_ub, p_st);
 }
 
-EXTERN int __kmpc_dispatch_next_8u(kmp_Ident *loc, int32_t tid,
-                                   int32_t *p_last, uint64_t *p_lb,
-                                   uint64_t *p_ub, int64_t *p_st) {
+EXTERN int __kmpc_dispatch_next_8u(kmp_Ident *loc, int32_t tid, int32_t *p_last,
+                                   uint64_t *p_lb, uint64_t *p_ub,
+                                   int64_t *p_st) {
   PRINT0(LD_IO, "call kmpc_dispatch_next_8u\n");
   return omptarget_nvptx_LoopSupport<uint64_t, int64_t>::dispatch_next(
       loc, tid, p_last, p_lb, p_ub, p_st);
 }
 
 // fini
 EXTERN void __kmpc_dispatch_fini_4(kmp_Ident *loc, int32_t tid) {
   PRINT0(LD_IO, "call kmpc_dispatch_fini_4\n");
void __kmpc_for_static_init_8u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
                                            int64_t incr, int64_t chunk) {
   PRINT0(LD_IO, "call kmpc_for_static_init_8u_simple_spmd\n");
   omptarget_nvptx_LoopSupport<uint64_t, int64_t>::for_static_init(
       global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
       /*IsSPMDExecutionMode=*/true);
 }
 
 EXTERN
-void __kmpc_for_static_init_4_simple_generic(
-    kmp_Ident *loc, int32_t global_tid, int32_t schedtype, int32_t *plastiter,
-    int32_t *plower, int32_t *pupper, int32_t *pstride, int32_t incr,
+void __kmpc_for_static_init_4_simple_generic(kmp_Ident *loc, int32_t global_tid,
+                                             int32_t schedtype,
+                                             int32_t *plastiter,
+                                             int32_t *plower, int32_t *pupper,
+                                             int32_t *pstride, int32_t incr,
                                              int32_t chunk) {
   PRINT0(LD_IO, "call kmpc_for_static_init_4_simple_generic\n");
   omptarget_nvptx_LoopSupport<int32_t, int32_t>::for_static_init(
       global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
       /*IsSPMDExecutionMode=*/false);
 }
 
 EXTERN
 void __kmpc_for_static_init_4u_simple_generic(
     kmp_Ident *loc, int32_t global_tid, int32_t schedtype, int32_t *plastiter,
     uint32_t *plower, uint32_t *pupper, int32_t *pstride, int32_t incr,
     int32_t chunk) {
   PRINT0(LD_IO, "call kmpc_for_static_init_4u_simple_generic\n");
   omptarget_nvptx_LoopSupport<uint32_t, int32_t>::for_static_init(
       global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
       /*IsSPMDExecutionMode=*/false);
 }
 
 EXTERN
-void __kmpc_for_static_init_8_simple_generic(
-    kmp_Ident *loc, int32_t global_tid, int32_t schedtype, int32_t *plastiter,
-    int64_t *plower, int64_t *pupper, int64_t *pstride, int64_t incr,
+void __kmpc_for_static_init_8_simple_generic(kmp_Ident *loc, int32_t global_tid,
+                                             int32_t schedtype,
+                                             int32_t *plastiter,
+                                             int64_t *plower, int64_t *pupper,
+                                             int64_t *pstride, int64_t incr,
                                              int64_t chunk) {
   PRINT0(LD_IO, "call kmpc_for_static_init_8_simple_generic\n");
   omptarget_nvptx_LoopSupport<int64_t, int64_t>::for_static_init(
       global_tid, schedtype, plastiter, plower, pupper, pstride, chunk,
       /*IsSPMDExecutionMode=*/false);
 }
 
 EXTERN
 void __kmpc_for_static_init_8u_simple_generic(

openmp/libomptarget/deviceRTLs/common/src/omp_data.cu

 //===------------ omp_data.cu - OpenMP GPU objects --------------- CUDA -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the data objects used on the GPU device.
 //
 //===----------------------------------------------------------------------===//
 #pragma omp declare target
 
-#include "common/omptarget.h"
 #include "common/device_environment.h"
+#include "common/omptarget.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // global device environment
 ////////////////////////////////////////////////////////////////////////////////
 
 DEVICE omptarget_device_environmentTy omptarget_device_environment;
 
 ////////////////////////////////////////////////////////////////////////////////
 // global data holding OpenMP state information
 ////////////////////////////////////////////////////////////////////////////////
 
 DEVICE
-    omptarget_nvptx_Queue<omptarget_nvptx_ThreadPrivateContext, OMP_STATE_COUNT>
-        omptarget_nvptx_device_State[MAX_SM];
 
-DEVICE omptarget_nvptx_SimpleMemoryManager
-    omptarget_nvptx_simpleMemoryManager;
+DEVICE omptarget_nvptx_SimpleMemoryManager omptarget_nvptx_simpleMemoryManager;
 DEVICE SHARED uint32_t usedMemIdx;
 DEVICE SHARED uint32_t usedSlotIdx;
 
 DEVICE SHARED uint8_t parallelLevel[MAX_THREADS_PER_TEAM / WARPSIZE];
 DEVICE SHARED uint16_t threadLimit;
 DEVICE SHARED uint16_t threadsInTeam;
 DEVICE SHARED uint16_t nThreads;
 // Pointer to this team's OpenMP state object

openmp/libomptarget/deviceRTLs/common/src/omptarget.cu

EXTERN void __kmpc_kernel_deinit(int16_t IsOMPRuntimeInitialized) {
   // Enqueue omp state object for use by another team.
   int slot = usedSlotIdx;
   omptarget_nvptx_device_State[slot].Enqueue(
       omptarget_nvptx_threadPrivateContext);
   // Done with work.  Kill the workers.
   omptarget_nvptx_workFn = 0;
 }
 
-EXTERN void __kmpc_spmd_kernel_init(int ThreadLimit, int16_t RequiresOMPRuntime) {
+EXTERN void __kmpc_spmd_kernel_init(int ThreadLimit,
+                                    int16_t RequiresOMPRuntime) {
   PRINT0(LD_IO, "call to __kmpc_spmd_kernel_init\n");
 
   setExecutionParameters(Spmd, RequiresOMPRuntime ? RuntimeInitialized
                                                   : RuntimeUninitialized);
   int threadId = GetThreadIdInBlock();
   if (threadId == 0) {
     usedSlotIdx = __kmpc_impl_smid() % MAX_SM;
     parallelLevel[0] =

openmp/libomptarget/deviceRTLs/common/src/parallel.cu

EXTERN void __kmpc_kernel_end_parallel() {
 
   // Reconverge the threads at the end of the parallel region to correctly
   // handle parallel levels.
   // In Cuda9+ in non-SPMD mode we have either 1 worker thread or the whole
   // warp. If only 1 thread is active, not need to reconverge the threads.
   // If we have the whole warp, reconverge all the threads in the warp before
   // actually trying to change the parallel level. Otherwise, parallel level can
   // be changed incorrectly because of threads divergence.
-    bool IsActiveParallelRegion = threadsInTeam != 1;
-    DecParallelLevel(IsActiveParallelRegion,
-                     IsActiveParallelRegion ? __kmpc_impl_all_lanes : 1u);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // support for parallel that goes sequential
 ////////////////////////////////////////////////////////////////////////////////
 
 EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid) {
   PRINT0(LD_IO, "call to __kmpc_serialized_parallel\n");

 
 ////////////////////////////////////////////////////////////////////////////////
 // push params
 ////////////////////////////////////////////////////////////////////////////////
 
 EXTERN void __kmpc_push_num_threads(kmp_Ident *loc, int32_t tid,
                                     int32_t num_threads) {
   PRINT(LD_IO, "call kmpc_push_num_threads %d\n", num_threads);
-  ASSERT0(LT_FUSSY, checkRuntimeInitialized(loc), "Runtime must be initialized.");
+  ASSERT0(LT_FUSSY, checkRuntimeInitialized(loc),
+          "Runtime must be initialized.");
   tid = GetLogicalThreadIdInBlock(checkSPMDMode(loc));
   omptarget_nvptx_threadPrivateContext->NumThreadsForNextParallel(tid) =
       num_threads;
 }
 
 // Do nothing. The host guarantees we started the requested number of
 // teams and we only need inspection of gridDim.
 
 EXTERN void __kmpc_push_num_teams(kmp_Ident *loc, int32_t tid,
                                   int32_t num_teams, int32_t thread_limit) {
   PRINT(LD_IO, "call kmpc_push_num_teams %d\n", (int)num_teams);
-  ASSERT0(LT_FUSSY, 0,
-          "should never have anything with new teams on device");
+  ASSERT0(LT_FUSSY, 0, "should never have anything with new teams on device");
 }
 
-EXTERN void __kmpc_push_proc_bind(kmp_Ident *loc, uint32_t tid,
-                                  int proc_bind) {
+EXTERN void __kmpc_push_proc_bind(kmp_Ident *loc, uint32_t tid, int proc_bind) {
   PRINT(LD_IO, "call kmpc_push_proc_bind %d\n", (int)proc_bind);
 }
 
 #pragma omp end declare target

openmp/libomptarget/deviceRTLs/common/src/reduction.cu

 EXTERN
 void __kmpc_nvptx_end_reduce_nowait(int32_t global_tid) {}
 
 EXTERN int32_t __kmpc_shuffle_int32(int32_t val, int16_t delta, int16_t size) {
   return __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, val, delta, size);
 }
 
 EXTERN int64_t __kmpc_shuffle_int64(int64_t val, int16_t delta, int16_t size) {
-   uint32_t lo, hi;
-   __kmpc_impl_unpack(val, lo, hi);
-   hi = __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, hi, delta, size);
-   lo = __kmpc_impl_shfl_down_sync(__kmpc_impl_all_lanes, lo, delta, size);
-   return __kmpc_impl_pack(lo, hi);
 }
 
 INLINE static void gpu_regular_warp_reduce(void *reduce_data,
                                            kmp_ShuffleReductFctPtr shflFct) {
   for (uint32_t mask = WARPSIZE / 2; mask > 0; mask /= 2) {
     shflFct(reduce_data, /*LaneId - not used= */ 0,
             /*Offset = */ mask, /*AlgoVersion=*/0);
   }

 static int32_t nvptx_parallel_reduce_nowait(
     int32_t global_tid, int32_t num_vars, size_t reduce_size, void *reduce_data,
     kmp_ShuffleReductFctPtr shflFct, kmp_InterWarpCopyFctPtr cpyFct,
     bool isSPMDExecutionMode, bool isRuntimeUninitialized) {
   uint32_t BlockThreadId = GetLogicalThreadIdInBlock(isSPMDExecutionMode);
   uint32_t NumThreads = GetNumberOfOmpThreads(isSPMDExecutionMode);
   if (NumThreads == 1)
     return 1;
     /*
      * This reduce function handles reduction within a team. It handles
      * parallel regions in both L1 and L2 parallelism levels. It also
      * supports Generic, SPMD, and NoOMP modes.
      *
      * 1. Reduce within a warp.
      * 2. Warp master copies value to warp 0 via shared memory.
      * 3. Warp 0 reduces to a single value.
      * 4. The reduced value is available in the thread that returns 1.
      */
 
 #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 700
   uint32_t WarpsNeeded = (NumThreads + WARPSIZE - 1) / WARPSIZE;
   uint32_t WarpId = BlockThreadId / WARPSIZE;
 
   // Volta execution model:
   // For the Generic execution mode a parallel region either has 1 thread and
   // beyond that, always a multiple of 32. For the SPMD execution mode we may

openmp/libomptarget/deviceRTLs/common/src/support.cu

 //===--------- support.cu - GPU OpenMP support functions --------- CUDA -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Wrapper implementation to some functions natively supported by the GPU.
 //
 //===----------------------------------------------------------------------===//
 #pragma omp declare target
 
-#include "common/support.h"
 #include "common/debug.h"
 #include "common/omptarget.h"
+#include "common/support.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Parameters
 ////////////////////////////////////////////////////////////////////////////////
 
 DEVICE void setExecutionParameters(ExecutionMode EMode, RuntimeMode RMode) {
   execution_param = EMode;
   execution_param |= RMode;
DEVICE bool checkSPMDMode(kmp_Ident *loc) {
   // combination of flags so we can return immediately.
   if (!(loc->reserved_2 & KMP_IDENT_SIMPLE_RT_MODE))
     return false;
 
   // We are in underfined state.
   return isSPMDMode();
 }
 
-DEVICE bool checkGenericMode(kmp_Ident *loc) {
-  return !checkSPMDMode(loc);
-}
+DEVICE bool checkGenericMode(kmp_Ident *loc) { return !checkSPMDMode(loc); }
 
 DEVICE bool checkRuntimeUninitialized(kmp_Ident *loc) {
   if (!loc)
     return isRuntimeUninitialized();
 
   // If runtime is required then we know we can't be
   // in the undefined mode. We can return immediately.
   if (!(loc->reserved_2 & KMP_IDENT_SIMPLE_RT_MODE))

 // The master thread id is the first thread (lane) of the last warp.
 // Thread id is 0 indexed.
 // E.g: If NumThreads is 33, master id is 32.
 //      If NumThreads is 64, master id is 32.
 //      If NumThreads is 97, master id is 96.
 //      If NumThreads is 1024, master id is 992.
 //
 // Called in Generic Execution Mode only.
-DEVICE int GetMasterThreadID() { return (GetNumberOfThreadsInBlock() - 1) & ~(WARPSIZE - 1); }
+DEVICE int GetMasterThreadID() {
+  return (GetNumberOfThreadsInBlock() - 1) & ~(WARPSIZE - 1);
+}
 
 // The last warp is reserved for the master; other warps are workers.
 // Called in Generic Execution Mode only.
 DEVICE int GetNumberOfWorkersInTeam() { return GetMasterThreadID(); }
 
 ////////////////////////////////////////////////////////////////////////////////
 // get thread id in team
 

openmp/libomptarget/deviceRTLs/common/src/task.cu

 //    - end
 //
 //===----------------------------------------------------------------------===//
 #pragma omp declare target
 
 #include "common/omptarget.h"
 
 EXTERN kmp_TaskDescr *__kmpc_omp_task_alloc(
-    kmp_Ident *loc,     // unused
+    kmp_Ident *loc,      // unused
     uint32_t global_tid, // unused
     int32_t flag, // unused (because in our impl, all are immediately exec
     size_t sizeOfTaskInclPrivate, size_t sizeOfSharedTable,
     kmp_TaskFctPtr taskSub) {
   PRINT(LD_IO,
         "call __kmpc_omp_task_alloc(size priv&struct %lld, shared %lld, "
         "fct 0x%llx)\n",
         (long long)sizeOfTaskInclPrivate, (long long)sizeOfSharedTable,

openmp/libomptarget/deviceRTLs/common/state-queuei.h

 }
 
 template <typename ElementType, uint32_t SIZE>
 INLINE uint32_t omptarget_nvptx_Queue<ElementType, SIZE>::DEQUEUE_TICKET() {
   return __kmpc_atomic_add((unsigned int *)&head, 1u);
 }
 
 template <typename ElementType, uint32_t SIZE>
-INLINE uint32_t
-omptarget_nvptx_Queue<ElementType, SIZE>::ID(uint32_t ticket) {
+INLINE uint32_t omptarget_nvptx_Queue<ElementType, SIZE>::ID(uint32_t ticket) {
   return (ticket / SIZE) * 2;
 }
 
 template <typename ElementType, uint32_t SIZE>
 INLINE bool omptarget_nvptx_Queue<ElementType, SIZE>::IsServing(uint32_t slot,
                                                                 uint32_t id) {
   return __kmpc_atomic_add((unsigned int *)&ids[slot], 0u) == id;
 }

openmp/libomptarget/deviceRTLs/common/support.h

 //===--------- support.h - OpenMP GPU support functions ---------- CUDA -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Wrapper to some functions natively supported by the GPU.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_SUPPORT_H
 #define OMPTARGET_SUPPORT_H
 
 #include "interface.h"
 #include "target_impl.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // Execution Parameters
 ////////////////////////////////////////////////////////////////////////////////
 enum ExecutionMode {
   Spmd = 0x00u,
   Generic = 0x01u,

 
 // get global ids to locate tread/team info (constant regardless of OMP)
 DEVICE int GetLogicalThreadIdInBlock(bool isSPMDExecutionMode);
 DEVICE int GetMasterThreadID();
 DEVICE int GetNumberOfWorkersInTeam();
 
 // get OpenMP thread and team ids
 DEVICE int GetOmpThreadId(int threadId,
-                          bool isSPMDExecutionMode);    // omp_thread_num
-DEVICE int GetOmpTeamId();                              // omp_team_num
+                          bool isSPMDExecutionMode); // omp_thread_num
+DEVICE int GetOmpTeamId();                           // omp_team_num
 
 // get OpenMP number of threads and team
 DEVICE int GetNumberOfOmpThreads(bool isSPMDExecutionMode); // omp_num_threads
 DEVICE int GetNumberOfOmpTeams();                           // omp_num_teams
 
 // get OpenMP number of procs
 DEVICE int GetNumberOfProcsInTeam(bool isSPMDExecutionMode);
 DEVICE int GetNumberOfProcsInDevice(bool isSPMDExecutionMode);

openmp/libomptarget/deviceRTLs/interface.h

 typedef enum omp_proc_bind_t {
   omp_proc_bind_false = 0,
   omp_proc_bind_true = 1,
   omp_proc_bind_master = 2,
   omp_proc_bind_close = 3,
   omp_proc_bind_spread = 4
 } omp_proc_bind_t;
 
 EXTERN double omp_get_wtick(void);
 EXTERN double omp_get_wtime(void);
 
 EXTERN void omp_set_num_threads(int num);
 EXTERN int omp_get_num_threads(void);
 EXTERN int omp_get_max_threads(void);
 EXTERN int omp_get_thread_limit(void);
 EXTERN int omp_get_thread_num(void);
 EXTERN int omp_get_num_procs(void);
 EXTERN int omp_in_parallel(void);
 EXTERN int omp_in_final(void);
 EXTERN void omp_set_dynamic(int flag);
 EXTERN int omp_get_dynamic(void);
 EXTERN void omp_set_nested(int flag);
 EXTERN int omp_get_nested(void);
 EXTERN void omp_set_max_active_levels(int level);
 EXTERN int omp_get_max_active_levels(void);
 EXTERN int omp_get_level(void);
 EXTERN int omp_get_active_level(void);
 EXTERN int omp_get_ancestor_thread_num(int level);
 EXTERN int omp_get_team_size(int level);
 
 EXTERN void omp_init_lock(omp_lock_t *lock);
 EXTERN void omp_init_nest_lock(omp_nest_lock_t *lock);
 EXTERN void omp_destroy_lock(omp_lock_t *lock);
 EXTERN void omp_destroy_nest_lock(omp_nest_lock_t *lock);
 EXTERN void omp_set_lock(omp_lock_t *lock);
 EXTERN void omp_set_nest_lock(omp_nest_lock_t *lock);

 /*!
  * The ident structure that describes a source location.
  * The struct is identical to the one in the kmp.h file.
  * We maintain the same data structure for compatibility.
  */
 typedef int kmp_int32;
 typedef struct ident {
   kmp_int32 reserved_1; /**<  might be used in Fortran; see above  */
-  kmp_int32 flags; /**<  also f.flags; KMP_IDENT_xxx flags; KMP_IDENT_KMPC
+  kmp_int32 flags;      /**<  also f.flags; KMP_IDENT_xxx flags; KMP_IDENT_KMPC
                            identifies this union member  */
   kmp_int32 reserved_2; /**<  not really used in Fortran any more; see above */
   kmp_int32 reserved_3; /**<  source[4] in Fortran, do not use for C++  */
-  char const *psource; /**<  String describing the source location.
+  char const *psource;  /**<  String describing the source location.
                         The string is composed of semi-colon separated fields
                         which describe the source file, the function and a pair
                         of line numbers that delimit the construct. */
 } ident_t;
 
 // parallel defs
 typedef ident_t kmp_Ident;
 typedef void (*kmp_InterWarpCopyFctPtr)(void *src, int32_t warp_num);
 typedef void (*kmp_ShuffleReductFctPtr)(void *rhsData, int16_t lane_id,
                                         int16_t lane_offset,
                                         int16_t shortCircuit);

 // external interface
 ////////////////////////////////////////////////////////////////////////////////
 
 // parallel
 EXTERN int32_t __kmpc_global_thread_num(kmp_Ident *loc);
 EXTERN void __kmpc_push_num_threads(kmp_Ident *loc, int32_t global_tid,
                                     int32_t num_threads);
 EXTERN void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid);
-EXTERN void __kmpc_end_serialized_parallel(kmp_Ident *loc,
-                                           uint32_t global_tid);
+EXTERN void __kmpc_end_serialized_parallel(kmp_Ident *loc, uint32_t global_tid);
 EXTERN uint16_t __kmpc_parallel_level(kmp_Ident *loc, uint32_t global_tid);
 
 // proc bind
 EXTERN void __kmpc_push_proc_bind(kmp_Ident *loc, uint32_t global_tid,
                                   int proc_bind);
 EXTERN int omp_get_num_places(void);
 EXTERN int omp_get_place_num_procs(int place_num);
 EXTERN void omp_get_place_proc_ids(int place_num, int *ids);
void __kmpc_for_static_init_8_simple_spmd(kmp_Ident *loc, int32_t global_tid,
                                           int64_t chunk);
 EXTERN
 void __kmpc_for_static_init_8u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
                                            int32_t sched, int32_t *plastiter1,
                                            uint64_t *plower, uint64_t *pupper,
                                            int64_t *pstride, int64_t incr,
                                            int64_t chunk);
 EXTERN
-void __kmpc_for_static_init_4_simple_generic(kmp_Ident *loc,
-                                             int32_t global_tid, int32_t sched,
-                                             int32_t *plastiter,
+void __kmpc_for_static_init_4_simple_generic(kmp_Ident *loc, int32_t global_tid,
+                                             int32_t sched, int32_t *plastiter,
                                              int32_t *plower, int32_t *pupper,
                                              int32_t *pstride, int32_t incr,
                                              int32_t chunk);
 EXTERN
 void __kmpc_for_static_init_4u_simple_generic(
     kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter,
     uint32_t *plower, uint32_t *pupper, int32_t *pstride, int32_t incr,
     int32_t chunk);
 EXTERN
-void __kmpc_for_static_init_8_simple_generic(kmp_Ident *loc,
-                                             int32_t global_tid, int32_t sched,
-                                             int32_t *plastiter,
+void __kmpc_for_static_init_8_simple_generic(kmp_Ident *loc, int32_t global_tid,
+                                             int32_t sched, int32_t *plastiter,
                                              int64_t *plower, int64_t *pupper,
                                              int64_t *pstride, int64_t incr,
                                              int64_t chunk);
 EXTERN
 void __kmpc_for_static_init_8u_simple_generic(
     kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter1,
     uint64_t *plower, uint64_t *pupper, int64_t *pstride, int64_t incr,
     int64_t chunk);

 EXTERN void __kmpc_flush(kmp_Ident *loc);
 
 // vote
 EXTERN __kmpc_impl_lanemask_t __kmpc_warp_active_thread_mask();
 // syncwarp
 EXTERN void __kmpc_syncwarp(__kmpc_impl_lanemask_t);
 
 // tasks
-EXTERN kmp_TaskDescr *__kmpc_omp_task_alloc(kmp_Ident *loc,
-                                            uint32_t global_tid, int32_t flag,
+EXTERN kmp_TaskDescr *__kmpc_omp_task_alloc(kmp_Ident *loc, uint32_t global_tid,
+                                            int32_t flag,
                                             size_t sizeOfTaskInclPrivate,
                                             size_t sizeOfSharedTable,
                                             kmp_TaskFctPtr sub);
 EXTERN int32_t __kmpc_omp_task(kmp_Ident *loc, uint32_t global_tid,
                                kmp_TaskDescr *newLegacyTaskDescr);
 EXTERN int32_t __kmpc_omp_task_with_deps(kmp_Ident *loc, uint32_t global_tid,
                                          kmp_TaskDescr *newLegacyTaskDescr,
                                          int32_t depNum, void *depList,

 EXTERN void __kmpc_spmd_kernel_deinit_v2(int16_t RequiresOMPRuntime);
 EXTERN void __kmpc_kernel_prepare_parallel(void *WorkFn);
 EXTERN bool __kmpc_kernel_parallel(void **WorkFn);
 EXTERN void __kmpc_kernel_end_parallel();
 
 EXTERN void __kmpc_data_sharing_init_stack();
 EXTERN void __kmpc_data_sharing_init_stack_spmd();
 EXTERN void *__kmpc_data_sharing_coalesced_push_stack(size_t size,
                                                       int16_t UseSharedMemory);
-EXTERN void *__kmpc_data_sharing_push_stack(size_t size, int16_t UseSharedMemory);
+EXTERN void *__kmpc_data_sharing_push_stack(size_t size,
+                                            int16_t UseSharedMemory);
 EXTERN void __kmpc_data_sharing_pop_stack(void *a);
 EXTERN void __kmpc_begin_sharing_variables(void ***GlobalArgs, size_t nArgs);
 EXTERN void __kmpc_end_sharing_variables();
 EXTERN void __kmpc_get_shared_variables(void ***GlobalArgs);
 
 // SPMD execution mode interrogation function.
 EXTERN int8_t __kmpc_is_spmd_exec_mode();
 
 EXTERN void __kmpc_get_team_static_memory(int16_t isSPMDExecutionMode,
                                           const void *buf, size_t size,
                                           int16_t is_shared, const void **res);
 
 EXTERN void __kmpc_restore_team_static_memory(int16_t isSPMDExecutionMode,
                                               int16_t is_shared);
 
 #endif

openmp/libomptarget/deviceRTLs/nvptx/src/target_impl.h

 //===------------ target_impl.h - NVPTX OpenMP GPU options ------- CUDA -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Definitions of target specific functions
 //
 //===----------------------------------------------------------------------===//
 #ifndef _TARGET_IMPL_H_
 #define _TARGET_IMPL_H_
 
 #include <assert.h>
 #include <cuda.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "nvptx_interface.h"
 
 #define DEVICE __device__
 #define INLINE __forceinline__ DEVICE
 #define NOINLINE __noinline__ DEVICE
 #define SHARED __shared__
 #define ALIGN(N) __align__(N)
 
 ////////////////////////////////////////////////////////////////////////////////
 // Kernel options
 ////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////
 // The following def must match the absolute limit hardwired in the host RTL
 // max number of threads per team
 #define MAX_THREADS_PER_TEAM 1024
 
 #define WARPSIZE 32
 
-// Maximum number of preallocated arguments to an outlined parallel/simd function.
-// Anything more requires dynamic memory allocation.
+// Maximum number of preallocated arguments to an outlined parallel/simd
+// function. Anything more requires dynamic memory allocation.
 #define MAX_SHARED_ARGS 20
 
 // Maximum number of omp state objects per SM allocated statically in global
 // memory.
 #if __CUDA_ARCH__ >= 600
 #define OMP_STATE_COUNT 32
 #else
 #define OMP_STATE_COUNT 16

openmp/libomptarget/deviceRTLs/nvptx/src/target_impl.cu

 //===---------- target_impl.cu - NVPTX OpenMP GPU options ------- CUDA -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Definitions of target specific functions
 //
 //===----------------------------------------------------------------------===//
 #pragma omp declare target
 
-#include "target_impl.h"
 #include "common/debug.h"
+#include "target_impl.h"
 
 #include <cuda.h>
 
 // Forward declaration of CUDA primitives which will be evetually transformed
 // into LLVM intrinsics.
 extern "C" {
 unsigned int __activemask();
 unsigned int __ballot(unsigned);

openmp/libomptarget/include/Debug.h

 //===------- Debug.h - Target independent OpenMP target RTL -- C++ --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Routines used to provide debug messages and information from libomptarget
 // and plugin RTLs to the user.
 //
 // Each plugin RTL and libomptarget define TARGET_NAME and DEBUG_PREFIX for use
 // when sending messages to the user. These indicate which RTL sent the message
 //
 // Debug and information messages are controlled by the environment variables
 // LIBOMPTARGET_DEBUG and LIBOMPTARGET_INFO which is set upon initialization
-// of libomptarget or the plugin RTL. 
+// of libomptarget or the plugin RTL.
 //
 // To printf a pointer in hex with a fixed width of 16 digits and a leading 0x,
 // use printf("ptr=" DPxMOD "...\n", DPxPTR(ptr));
-// 
+//
 // DPxMOD expands to:
 //   "0x%0*" PRIxPTR
 // where PRIxPTR expands to an appropriate modifier for the type uintptr_t on a
 // specific platform, e.g. "lu" if uintptr_t is typedef'd as unsigned long:
 //   "0x%0*lu"
-// 
+//
 // Ultimately, the whole statement expands to:
 //   printf("ptr=0x%0*lu...\n",  // the 0* modifier expects an extra argument
 //                               // specifying the width of the output
 //   (int)(2*sizeof(uintptr_t)), // the extra argument specifying the width
 //                               // 8 digits for 32bit systems
 //                               // 16 digits for 64bit
 //   (uintptr_t) ptr);
 //

openmp/libomptarget/include/omptarget.h

 //===-------- omptarget.h - Target independent OpenMP target RTL -- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Interface to be used by Clang during the codegen of a
 // target region.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _OMPTARGET_H_
 #define _OMPTARGET_H_
 
-#include <stdint.h>
 #include <stddef.h>
+#include <stdint.h>
 
 #include <SourceInfo.h>
 
 #define OFFLOAD_SUCCESS (0)
 #define OFFLOAD_FAIL (~0)
 
-#define OFFLOAD_DEVICE_DEFAULT     -1
+#define OFFLOAD_DEVICE_DEFAULT -1
 
 /// Data attributes for each data reference used in an OpenMP target region.
 enum tgt_map_type {
   // No flags
-  OMP_TGT_MAPTYPE_NONE            = 0x000,
+  OMP_TGT_MAPTYPE_NONE = 0x000,
   // copy data from host to device
-  OMP_TGT_MAPTYPE_TO              = 0x001,
+  OMP_TGT_MAPTYPE_TO = 0x001,
   // copy data from device to host
-  OMP_TGT_MAPTYPE_FROM            = 0x002,
+  OMP_TGT_MAPTYPE_FROM = 0x002,
   // copy regardless of the reference count
-  OMP_TGT_MAPTYPE_ALWAYS          = 0x004,
+  OMP_TGT_MAPTYPE_ALWAYS = 0x004,
   // force unmapping of data
-  OMP_TGT_MAPTYPE_DELETE          = 0x008,
+  OMP_TGT_MAPTYPE_DELETE = 0x008,
   // map the pointer as well as the pointee
-  OMP_TGT_MAPTYPE_PTR_AND_OBJ     = 0x010,
+  OMP_TGT_MAPTYPE_PTR_AND_OBJ = 0x010,
   // pass device base address to kernel
-  OMP_TGT_MAPTYPE_TARGET_PARAM    = 0x020,
+  OMP_TGT_MAPTYPE_TARGET_PARAM = 0x020,
   // return base device address of mapped data
-  OMP_TGT_MAPTYPE_RETURN_PARAM    = 0x040,
+  OMP_TGT_MAPTYPE_RETURN_PARAM = 0x040,
   // private variable - not mapped
-  OMP_TGT_MAPTYPE_PRIVATE         = 0x080,
+  OMP_TGT_MAPTYPE_PRIVATE = 0x080,
   // copy by value - not mapped
-  OMP_TGT_MAPTYPE_LITERAL         = 0x100,
+  OMP_TGT_MAPTYPE_LITERAL = 0x100,
   // mapping is implicit
-  OMP_TGT_MAPTYPE_IMPLICIT        = 0x200,
+  OMP_TGT_MAPTYPE_IMPLICIT = 0x200,
   // copy data to device
-  OMP_TGT_MAPTYPE_CLOSE           = 0x400,
+  OMP_TGT_MAPTYPE_CLOSE = 0x400,
   // runtime error if not already allocated
-  OMP_TGT_MAPTYPE_PRESENT         = 0x1000,
+  OMP_TGT_MAPTYPE_PRESENT = 0x1000,
   // descriptor for non-contiguous target-update
-  OMP_TGT_MAPTYPE_NON_CONTIG      = 0x100000000000,
+  OMP_TGT_MAPTYPE_NON_CONTIG = 0x100000000000,
   // member of struct, member given by [16 MSBs] - 1
-  OMP_TGT_MAPTYPE_MEMBER_OF       = 0xffff000000000000
+  OMP_TGT_MAPTYPE_MEMBER_OF = 0xffff000000000000
 };
 
 enum OpenMPOffloadingDeclareTargetFlags {
   /// Mark the entry as having a 'link' attribute.
   OMP_DECLARE_TARGET_LINK = 0x01,
   /// Mark the entry as being a global constructor.
   OMP_DECLARE_TARGET_CTOR = 0x02,
   /// Mark the entry as being a global destructor.
   OMP_DECLARE_TARGET_DTOR = 0x04
 };
 
 enum OpenMPOffloadingRequiresDirFlags {
   /// flag undefined.
-  OMP_REQ_UNDEFINED               = 0x000,
+  OMP_REQ_UNDEFINED = 0x000,
   /// no requires directive present.
-  OMP_REQ_NONE                    = 0x001,
+  OMP_REQ_NONE = 0x001,
   /// reverse_offload clause.
-  OMP_REQ_REVERSE_OFFLOAD         = 0x002,
+  OMP_REQ_REVERSE_OFFLOAD = 0x002,
   /// unified_address clause.
-  OMP_REQ_UNIFIED_ADDRESS         = 0x004,
+  OMP_REQ_UNIFIED_ADDRESS = 0x004,
   /// unified_shared_memory clause.
-  OMP_REQ_UNIFIED_SHARED_MEMORY   = 0x008,
+  OMP_REQ_UNIFIED_SHARED_MEMORY = 0x008,
   /// dynamic_allocators clause.
-  OMP_REQ_DYNAMIC_ALLOCATORS      = 0x010
+  OMP_REQ_DYNAMIC_ALLOCATORS = 0x010
 };
 
 /// This struct is a record of an entry point or global. For a function
 /// entry point the size is expected to be zero
 struct __tgt_offload_entry {
-  void *addr;   // Pointer to the offload entry info (function or global)
-  char *name;   // Name of the function or global
-  size_t size;  // Size of the entry info (0 if it is a function)
-  int32_t flags; // Flags associated with the entry, e.g. 'link'.
+  void *addr;       // Pointer to the offload entry info (function or global)
+  char *name;       // Name of the function or global
+  size_t size;      // Size of the entry info (0 if it is a function)
+  int32_t flags;    // Flags associated with the entry, e.g. 'link'.
   int32_t reserved; // Reserved, to be used by the runtime library.
 };
 
 /// This struct is a record of the device image information
 struct __tgt_device_image {
   void *ImageStart;                  // Pointer to the target code start
   void *ImageEnd;                    // Pointer to the target code end
   __tgt_offload_entry *EntriesBegin; // Begin of table with all target entries
   __tgt_offload_entry *EntriesEnd;   // End of table (non inclusive)
 };
 
 /// This struct is a record of all the host code that may be offloaded to a
 /// target.
 struct __tgt_bin_desc {
-  int32_t NumDeviceImages;           // Number of device types supported
-  __tgt_device_image *DeviceImages;  // Array of device images (1 per dev. type)
+  int32_t NumDeviceImages;          // Number of device types supported
+  __tgt_device_image *DeviceImages; // Array of device images (1 per dev. type)
   __tgt_offload_entry *HostEntriesBegin; // Begin of table with all host entries
   __tgt_offload_entry *HostEntriesEnd;   // End of table (non inclusive)
 };
 
 /// This struct contains the offload entries identified by the target runtime
 struct __tgt_target_table {
   __tgt_offload_entry *EntriesBegin; // Begin of the table with all the entries
   __tgt_offload_entry

 #endif
 
 int omp_get_num_devices(void);
 int omp_get_initial_device(void);
 void *omp_target_alloc(size_t size, int device_num);
 void omp_target_free(void *device_ptr, int device_num);
 int omp_target_is_present(void *ptr, int device_num);
 int omp_target_memcpy(void *dst, void *src, size_t length, size_t dst_offset,
                       size_t src_offset, int dst_device, int src_device);
 int omp_target_memcpy_rect(void *dst, void *src, size_t element_size,
-    int num_dims, const size_t *volume, const size_t *dst_offsets,
-    const size_t *src_offsets, const size_t *dst_dimensions,
-    const size_t *src_dimensions, int dst_device, int src_device);
+                           int num_dims, const size_t *volume,
+                           const size_t *dst_offsets, const size_t *src_offsets,
+                           const size_t *dst_dimensions,
+                           const size_t *src_dimensions, int dst_device,
+                           int src_device);
 int omp_target_associate_ptr(void *host_ptr, void *device_ptr, size_t size,
                              size_t device_offset, int device_num);
 int omp_target_disassociate_ptr(void *host_ptr, int device_num);
 
 /// add the clauses of the requires directives in a given file
 void __tgt_register_requires(int64_t flags);
 
 /// adds a target shared library to the target execution image
 void __tgt_register_lib(__tgt_bin_desc *desc);
 

openmp/libomptarget/plugins/generic-elf-64bit/src/rtl.cpp

 //===-RTLs/generic-64bit/src/rtl.cpp - Target RTLs Implementation - C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // RTL for generic 64-bit machine
 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
 #include <cstdio>
-#include <cstring>
 #include <cstdlib>
+#include <cstring>
 #include <dlfcn.h>
 #include <ffi.h>
 #include <gelf.h>
 #include <link.h>
 #include <list>
 #include <string>
 #include <vector>
 
 #include "Debug.h"
 #include "omptargetplugin.h"
 
public:
   __tgt_target_table *getOffloadEntriesTable(int32_t device_id) {
     assert(device_id < (int32_t)FuncGblEntries.size() &&
            "Unexpected device id!");
     FuncOrGblEntryTy &E = FuncGblEntries[device_id].back();
 
     return &E.Table;
   }
 
-  RTLDeviceInfoTy(int32_t num_devices) {
-
-    FuncGblEntries.resize(num_devices);
-  }
+  RTLDeviceInfoTy(int32_t num_devices) { FuncGblEntries.resize(num_devices); }
 
   ~RTLDeviceInfoTy() {
     // Close dynamic libraries
     for (auto &lib : DynLibs) {
       if (lib.Handle) {
         dlclose(lib.Handle);
         remove(lib.FileName);
       }
__tgt_target_table *__tgt_rtl_load_binary(int32_t device_id,
 
   struct link_map *libInfo = (struct link_map *)Lib.Handle;
 
   // The place where the entries info is loaded is the library base address
   // plus the offset determined from the ELF file.
   Elf64_Addr entries_addr = libInfo->l_addr + entries_offset;
 
   DP("Pointer to first entry to be loaded is (" DPxMOD ").\n",
-      DPxPTR(entries_addr));
 
   // Table of pointers to all the entries in the target.
   __tgt_offload_entry *entries_table = (__tgt_offload_entry *)entries_addr;
 
   __tgt_offload_entry *entries_begin = &entries_table[0];
   __tgt_offload_entry *entries_end = entries_begin + NumEntries;
 
   if (!entries_begin) {
     DP("Can't obtain entries begin\n");
     elf_end(e);
     return NULL;
   }
 
   DP("Entries table range is (" DPxMOD ")->(" DPxMOD ")\n",
-      DPxPTR(entries_begin), DPxPTR(entries_end));
   DeviceInfo.createOffloadTable(device_id, entries_begin, entries_end);
 
   elf_end(e);
 
   return DeviceInfo.getOffloadEntriesTable(device_id);
 }
 
 void *__tgt_rtl_data_alloc(int32_t device_id, int64_t size, void *hst_ptr) {
int32_t __tgt_rtl_run_target_team_region(int32_t device_id, void *tgt_entry_ptr,
   assert(status == FFI_OK && "Unable to prepare target launch!");
 
   if (status != FFI_OK)
     return OFFLOAD_FAIL;
 
   DP("Running entry point at " DPxMOD "...\n", DPxPTR(tgt_entry_ptr));
 
   void (*entry)(void);
-  *((void**) &entry) = tgt_entry_ptr;
+  *((void **)&entry) = tgt_entry_ptr;
   ffi_call(&cif, entry, NULL, &args[0]);
   return OFFLOAD_SUCCESS;
 }
 
 int32_t __tgt_rtl_run_target_region(int32_t device_id, void *tgt_entry_ptr,
                                     void **tgt_args, ptrdiff_t *tgt_offsets,
                                     int32_t arg_num) {
   // use one team and one thread.
   return __tgt_rtl_run_target_team_region(device_id, tgt_entry_ptr, tgt_args,
                                           tgt_offsets, arg_num, 1, 1, 0);
 }
 
 #ifdef __cplusplus
 }
 #endif

openmp/libomptarget/plugins/ve/src/rtl.cpp

 #include <algorithm>
 #include <cassert>
 #include <cerrno>
 #include <cstring>
 #include <list>
 #include <stdlib.h>
 #include <string>
 #include <sys/stat.h>
 #include <ve_offload.h>
 #include <vector>
 #include <veosinfo/veosinfo.h>
 
 #include "Debug.h"
 #include "omptargetplugin.h"
 
 #ifndef TARGET_NAME
 #define TARGET_NAME VE
for (__tgt_offload_entry *i = HostBegin; i != HostEnd; ++i) {
       __tgt_offload_entry Entry;
 
       if (!SymbolTargetAddr) {
         DP("Symbol %s not found in target image\n", SymbolName);
         Entry = {NULL, NULL, 0, 0, 0};
       } else {
         DP("Found symbol %s successfully in target image (addr: %p)\n",
            SymbolName, reinterpret_cast<void *>(SymbolTargetAddr));
-        Entry = { reinterpret_cast<void *>(SymbolTargetAddr),
-                  i->name,
-                  i->size,
-                  i->flags,
-                  0 };
+        Entry = {reinterpret_cast<void *>(SymbolTargetAddr), i->name, i->size,
+                 i->flags, 0};
       }
 
       T.push_back(Entry);
     }
 
     FuncOrGblEntry[device_id].back().Table.EntriesBegin = &T.front();
     FuncOrGblEntry[device_id].back().Table.EntriesEnd = &T.back() + 1;
   }
static int target_run_function_wait(uint32_t DeviceID, uint64_t FuncAddr,
   if (ret != 0) {
     DP("Waiting for entry point %p failed (Error code %d)\n",
        reinterpret_cast<void *>(FuncAddr), ret);
     return OFFLOAD_FAIL;
   }
   return OFFLOAD_SUCCESS;
 }
 
-
 // Return the number of available devices of the type supported by the
 // target RTL.
 int32_t __tgt_rtl_number_of_devices(void) { return DeviceInfo.NodeIds.size(); }
 
 // Return an integer different from zero if the provided device image can be
 // supported by the runtime. The functionality is similar to comparing the
 // result of __tgt__rtl__load__binary to NULL. However, this is meant to be a
 // lightweight query to determine if the RTL is suitable for an image without
if (DeviceInfo.ProcHandles[ID] == NULL) {
     DeviceInfo.ProcHandles[ID] = proc_handle;
     DP("Aurora device successfully initialized: proc_handle=%p", proc_handle);
   }
 
   ret = veo_alloc_mem(DeviceInfo.ProcHandles[ID], &addr, Size);
   DP("Allocate target memory: device=%d, target addr=%p, size=%" PRIu64 "\n",
      ID, reinterpret_cast<void *>(addr), Size);
   if (ret != 0) {
-    DP("veo_alloc_mem(%d, %p, %" PRIu64 ") failed with error code %d\n",
-       ID, reinterpret_cast<void *>(addr), Size, ret);
+    DP("veo_alloc_mem(%d, %p, %" PRIu64 ") failed with error code %d\n", ID,
+       reinterpret_cast<void *>(addr), Size, ret);
     return NULL;
   }
 
   return reinterpret_cast<void *>(addr);
 }
 
 // Pass the data content to the target device using the target address.
 // In case of success, return zero. Otherwise, return an error code.
if (ret != 0) {
     return OFFLOAD_FAIL;
   }
   return OFFLOAD_SUCCESS;
 }
 
 // De-allocate the data referenced by target ptr on the device. In case of
 // success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_data_delete(int32_t ID, void *TargetPtr) {
-  int ret =  veo_free_mem(DeviceInfo.ProcHandles[ID], (uint64_t)TargetPtr);
+  int ret = veo_free_mem(DeviceInfo.ProcHandles[ID], (uint64_t)TargetPtr);
 
   if (ret != 0) {
     DP("veo_free_mem() failed with error code %d\n", ret);
     return OFFLOAD_FAIL;
   }
   return OFFLOAD_SUCCESS;
 }
 
if (TargetArgs == NULL) {
     DP("Could not allocate VEO args\n");
     return OFFLOAD_FAIL;
   }
 
   for (int i = 0; i < NumArgs; ++i) {
     ret = veo_args_set_u64(TargetArgs, i, (intptr_t)Args[i]);
 
     if (ret != 0) {
-      DP("veo_args_set_u64() has returned %d for argnum=%d and value %p\n",
-         ret, i, Args[i]);
+      DP("veo_args_set_u64() has returned %d for argnum=%d and value %p\n", ret,
+         i, Args[i]);
       return OFFLOAD_FAIL;
     }
   }
 
   uint64_t RetVal;
   if (target_run_function_wait(ID, reinterpret_cast<uint64_t>(Entry),
                                TargetArgs, &RetVal) != OFFLOAD_SUCCESS) {
     veo_args_free(TargetArgs);

openmp/libomptarget/src/api.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "device.h"
 #include "private.h"
 #include "rtl.h"
 
 #include <climits>
-#include <cstring>
 #include <cstdlib>
+#include <cstring>
 
 EXTERN int omp_get_num_devices(void) {
   TIMESCOPE();
   PM->RTLsMtx.lock();
   size_t DevicesSize = PM->Devices.size();
   PM->RTLsMtx.unlock();
 
   DP("Call to omp_get_num_devices returning %zd\n", DevicesSize);
 
   return DevicesSize;
 }
 
 EXTERN int omp_get_initial_device(void) {
   TIMESCOPE();
   int hostDevice = omp_get_num_devices();
   DP("Call to omp_get_initial_device returning %d\n", hostDevice);
   return hostDevice;
 }
 
 EXTERN void *omp_target_alloc(size_t size, int device_num) {
   TIMESCOPE();
   DP("Call to omp_target_alloc for device %d requesting %zu bytes\n",
-      device_num, size);
 
   if (size <= 0) {
     DP("Call to omp_target_alloc with non-positive length\n");
     return NULL;
   }
 
   void *rc = NULL;
 
EXTERN void *omp_target_alloc(size_t size, int device_num) {
   rc = PM->Devices[device_num].allocData(size);
   DP("omp_target_alloc returns device ptr " DPxMOD "\n", DPxPTR(rc));
   return rc;
 }
 
 EXTERN void omp_target_free(void *device_ptr, int device_num) {
   TIMESCOPE();
   DP("Call to omp_target_free for device %d and address " DPxMOD "\n",
-      device_num, DPxPTR(device_ptr));
 
   if (!device_ptr) {
     DP("Call to omp_target_free with NULL ptr\n");
     return;
   }
 
   if (device_num == omp_get_initial_device()) {
     free(device_ptr);
     DP("omp_target_free deallocated host ptr\n");
     return;
   }
 
   if (!device_is_ready(device_num)) {
     DP("omp_target_free returns, nothing to do\n");
     return;
   }
 
   PM->Devices[device_num].deleteData(device_ptr);
   DP("omp_target_free deallocated device ptr\n");
 }
 
 EXTERN int omp_target_is_present(void *ptr, int device_num) {
   TIMESCOPE();
   DP("Call to omp_target_is_present for device %d and address " DPxMOD "\n",
-      device_num, DPxPTR(ptr));
 
   if (!ptr) {
     DP("Call to omp_target_is_present with NULL ptr, returning false\n");
     return false;
   }
 
   if (device_num == omp_get_initial_device()) {
     DP("Call to omp_target_is_present on host, returning true\n");
     return true;
   }
 
   PM->RTLsMtx.lock();
   size_t DevicesSize = PM->Devices.size();
   PM->RTLsMtx.unlock();
   if (DevicesSize <= (size_t)device_num) {
     DP("Call to omp_target_is_present with invalid device ID, returning "
-        "false\n");
     return false;
   }
 
   DeviceTy &Device = PM->Devices[device_num];
   bool IsLast; // not used
   bool IsHostPtr;
   void *TgtPtr = Device.getTgtPtrBegin(ptr, 0, IsLast, false, IsHostPtr);
   int rc = (TgtPtr != NULL);
   // Under unified memory the host pointer can be returned by the
   // getTgtPtrBegin() function which means that there is no device
   // corresponding point for ptr. This function should return false
   // in that situation.
   if (PM->RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY)
     rc = !IsHostPtr;
   DP("Call to omp_target_is_present returns %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_target_memcpy(void *dst, void *src, size_t length,
-    size_t dst_offset, size_t src_offset, int dst_device, int src_device) {
+                             size_t dst_offset, size_t src_offset,
+                             int dst_device, int src_device) {
   TIMESCOPE();
   DP("Call to omp_target_memcpy, dst device %d, src device %d, "
-      "dst addr " DPxMOD ", src addr " DPxMOD ", dst offset %zu, "
-      "src offset %zu, length %zu\n", dst_device, src_device, DPxPTR(dst),
-      DPxPTR(src), dst_offset, src_offset, length);
+     "src offset %zu, length %zu\n",
+     dst_device, src_device, DPxPTR(dst), DPxPTR(src), dst_offset, src_offset,
+     length);
 
   if (!dst || !src || length <= 0) {
     if (length == 0) {
       DP("Call to omp_target_memcpy with zero length, nothing to do\n");
       return OFFLOAD_SUCCESS;
     }
 
     REPORT("Call to omp_target_memcpy with invalid arguments\n");
if (src_device == omp_get_initial_device() &&
     free(buffer);
   }
 
   DP("omp_target_memcpy returns %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_target_memcpy_rect(void *dst, void *src, size_t element_size,
-    int num_dims, const size_t *volume, const size_t *dst_offsets,
-    const size_t *src_offsets, const size_t *dst_dimensions,
-    const size_t *src_dimensions, int dst_device, int src_device) {
+                                  int num_dims, const size_t *volume,
+                                  const size_t *dst_offsets,
+                                  const size_t *src_offsets,
+                                  const size_t *dst_dimensions,
+                                  const size_t *src_dimensions, int dst_device,
+                                  int src_device) {
   TIMESCOPE();
   DP("Call to omp_target_memcpy_rect, dst device %d, src device %d, "
-      "dst addr " DPxMOD ", src addr " DPxMOD ", dst offsets " DPxMOD ", "
-      "src offsets " DPxMOD ", dst dims " DPxMOD ", src dims " DPxMOD ", "
-      "volume " DPxMOD ", element size %zu, num_dims %d\n", dst_device,
-      src_device, DPxPTR(dst), DPxPTR(src), DPxPTR(dst_offsets),
-      DPxPTR(src_offsets), DPxPTR(dst_dimensions), DPxPTR(src_dimensions),
-      DPxPTR(volume), element_size, num_dims);
+     "volume " DPxMOD ", element size %zu, num_dims %d\n",
+     dst_device, src_device, DPxPTR(dst), DPxPTR(src), DPxPTR(dst_offsets),
 
   if (!(dst || src)) {
     DP("Call to omp_target_memcpy_rect returns max supported dimensions %d\n",
-        INT_MAX);
     return INT_MAX;
   }
 
   if (!dst || !src || element_size < 1 || num_dims < 1 || !volume ||
       !dst_offsets || !src_offsets || !dst_dimensions || !src_dimensions) {
     REPORT("Call to omp_target_memcpy_rect with invalid arguments\n");
     return OFFLOAD_FAIL;
   }
 
   int rc;
   if (num_dims == 1) {
-    rc = omp_target_memcpy(dst, src, element_size * volume[0],
-        element_size * dst_offsets[0], element_size * src_offsets[0],
-        dst_device, src_device);
+    rc = omp_target_memcpy(
+        dst, src, element_size * volume[0], element_size * dst_offsets[0],
+        element_size * src_offsets[0], dst_device, src_device);
   } else {
     size_t dst_slice_size = element_size;
     size_t src_slice_size = element_size;
-    for (int i=1; i<num_dims; ++i) {
+    for (int i = 1; i < num_dims; ++i) {
       dst_slice_size *= dst_dimensions[i];
       src_slice_size *= src_dimensions[i];
     }
 
     size_t dst_off = dst_offsets[0] * dst_slice_size;
     size_t src_off = src_offsets[0] * src_slice_size;
-    for (size_t i=0; i<volume[0]; ++i) {
-      rc = omp_target_memcpy_rect((char *) dst + dst_off + dst_slice_size * i,
-          (char *) src + src_off + src_slice_size * i, element_size,
+    for (size_t i = 0; i < volume[0]; ++i) {
+      rc = omp_target_memcpy_rect(
+          (char *)dst + dst_off + dst_slice_size * i,
+          (char *)src + src_off + src_slice_size * i, element_size,
           num_dims - 1, volume + 1, dst_offsets + 1, src_offsets + 1,
           dst_dimensions + 1, src_dimensions + 1, dst_device, src_device);
 
       if (rc) {
         DP("Recursive call to omp_target_memcpy_rect returns unsuccessfully\n");
         return rc;
       }
     }
   }
 
   DP("omp_target_memcpy_rect returns %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_target_associate_ptr(void *host_ptr, void *device_ptr,
-    size_t size, size_t device_offset, int device_num) {
+                                    size_t size, size_t device_offset,
+                                    int device_num) {
   TIMESCOPE();
   DP("Call to omp_target_associate_ptr with host_ptr " DPxMOD ", "
-      "device_ptr " DPxMOD ", size %zu, device_offset %zu, device_num %d\n",
-      DPxPTR(host_ptr), DPxPTR(device_ptr), size, device_offset, device_num);
 
   if (!host_ptr || !device_ptr || size <= 0) {
     REPORT("Call to omp_target_associate_ptr with invalid arguments\n");
     return OFFLOAD_FAIL;
   }
 
   if (device_num == omp_get_initial_device()) {
     REPORT("omp_target_associate_ptr: no association possible on the host\n");
EXTERN int omp_target_associate_ptr(void *host_ptr, void *device_ptr,
   int rc = Device.associatePtr(host_ptr, device_addr, size);
   DP("omp_target_associate_ptr returns %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_target_disassociate_ptr(void *host_ptr, int device_num) {
   TIMESCOPE();
   DP("Call to omp_target_disassociate_ptr with host_ptr " DPxMOD ", "
-      "device_num %d\n", DPxPTR(host_ptr), device_num);
+     "device_num %d\n",
+     DPxPTR(host_ptr), device_num);
 
   if (!host_ptr) {
     REPORT("Call to omp_target_associate_ptr with invalid host_ptr\n");
     return OFFLOAD_FAIL;
   }
 
   if (device_num == omp_get_initial_device()) {
     REPORT(

openmp/libomptarget/src/device.h

enum kmp_target_offload_kind {
   tgt_mandatory = 2
 };
 typedef enum kmp_target_offload_kind kmp_target_offload_kind_t;
 
 /// Map between host data and target data.
 struct HostDataToTargetTy {
   uintptr_t HstPtrBase; // host info.
   uintptr_t HstPtrBegin;
-  uintptr_t HstPtrEnd; // non-inclusive.
+  uintptr_t HstPtrEnd;       // non-inclusive.
   map_var_info_t HstPtrName; // Optional source name of mapped variable.
 
   uintptr_t TgtPtrBegin; // target info.
 
 private:
   /// use mutable to allow modification via std::set iterator which is const.
   mutable uint64_t RefCount;
   static const uint64_t INFRefCount = ~(uint64_t)0;
 
 public:
   HostDataToTargetTy(uintptr_t BP, uintptr_t B, uintptr_t E, uintptr_t TB,
                      map_var_info_t Name = nullptr, bool IsINF = false)
       : HstPtrBase(BP), HstPtrBegin(B), HstPtrEnd(E), HstPtrName(Name),
         TgtPtrBegin(TB), RefCount(IsINF ? INFRefCount : 1) {}
 
-  uint64_t getRefCount() const {
-    return RefCount;
-  }
+  uint64_t getRefCount() const { return RefCount; }
 
   uint64_t resetRefCount() const {
     if (RefCount != INFRefCount)
       RefCount = 1;
 
     return RefCount;
   }
 
uint64_t decRefCount() const {
     if (RefCount != INFRefCount) {
       assert(RefCount > 0 && "refcount underflow");
       --RefCount;
     }
 
     return RefCount;
   }
 
-  bool isRefCountInf() const {
-    return RefCount == INFRefCount;
-  }
+  bool isRefCountInf() const { return RefCount == INFRefCount; }
 };
 
 typedef uintptr_t HstPtrBeginTy;
 inline bool operator<(const HostDataToTargetTy &lhs, const HstPtrBeginTy &rhs) {
   return lhs.HstPtrBegin < rhs;
 }
 inline bool operator<(const HstPtrBeginTy &lhs, const HostDataToTargetTy &rhs) {
   return lhs < rhs.HstPtrBegin;
 }
 inline bool operator<(const HostDataToTargetTy &lhs,
                       const HostDataToTargetTy &rhs) {
   return lhs.HstPtrBegin < rhs.HstPtrBegin;
 }
 
 typedef std::set<HostDataToTargetTy, std::less<>> HostDataToTargetListTy;
 
 struct LookupResult {
   struct {
-    unsigned IsContained   : 1;
+    unsigned IsContained : 1;
     unsigned ExtendsBefore : 1;
-    unsigned ExtendsAfter  : 1;
+    unsigned ExtendsAfter : 1;
   } Flags;
 
   HostDataToTargetListTy::iterator Entry;
 
-  LookupResult() : Flags({0,0,0}), Entry() {}
+  LookupResult() : Flags({0, 0, 0}), Entry() {}
 };
 
 /// Map for shadow pointers
 struct ShadowPtrValTy {
   void *HstPtrVal;
   void *TgtPtrAddr;
   void *TgtPtrVal;
 };
struct DeviceTy {
   // provide a copy constructor and an assignment operator explicitly.
   DeviceTy(const DeviceTy &D);
 
   DeviceTy &operator=(const DeviceTy &D);
 
   ~DeviceTy();
 
   // Return true if data can be copied to DstDevice directly
-  bool isDataExchangable(const DeviceTy& DstDevice);
+  bool isDataExchangable(const DeviceTy &DstDevice);
 
   uint64_t getMapEntryRefCnt(void *HstPtrBegin);
   LookupResult lookupMapping(void *HstPtrBegin, int64_t Size);
   void *getOrAllocTgtPtr(void *HstPtrBegin, void *HstPtrBase, int64_t Size,
                          map_var_info_t HstPtrName, bool &IsNew,
                          bool &IsHostPtr, bool IsImplicit, bool UpdateRefCount,
                          bool HasCloseModifier, bool HasPresentModifier);
   void *getTgtPtrBegin(void *HstPtrBegin, int64_t Size);

openmp/libomptarget/src/device.cpp

int DeviceTy::associatePtr(void *HstPtrBegin, void *TgtPtrBegin, int64_t Size) {
 
   // Mapping does not exist, allocate it with refCount=INF
   HostDataToTargetTy newEntry((uintptr_t)HstPtrBegin /*HstPtrBase*/,
                               (uintptr_t)HstPtrBegin /*HstPtrBegin*/,
                               (uintptr_t)HstPtrBegin + Size /*HstPtrEnd*/,
                               (uintptr_t)TgtPtrBegin /*TgtPtrBegin*/, nullptr,
                               true /*IsRefCountINF*/);
 
-  DP("Creating new map entry: HstBase=" DPxMOD ", HstBegin=" DPxMOD ", HstEnd="
-      DPxMOD ", TgtBegin=" DPxMOD "\n", DPxPTR(newEntry.HstPtrBase),
-      DPxPTR(newEntry.HstPtrBegin), DPxPTR(newEntry.HstPtrEnd),
-      DPxPTR(newEntry.TgtPtrBegin));
+  DP("Creating new map entry: HstBase=" DPxMOD ", HstBegin=" DPxMOD
+     ", HstEnd=" DPxMOD ", TgtBegin=" DPxMOD "\n",
+     DPxPTR(newEntry.HstPtrBase), DPxPTR(newEntry.HstPtrBegin),
+     DPxPTR(newEntry.HstPtrEnd), DPxPTR(newEntry.TgtPtrBegin));
   HostDataToTargetMap.insert(newEntry);
 
   DataMapMtx.unlock();
 
   return OFFLOAD_SUCCESS;
 }
 
 int DeviceTy::disassociatePtr(void *HstPtrBegin) {
uint64_t DeviceTy::getMapEntryRefCnt(void *HstPtrBegin) {
   return RefCnt;
 }
 
 LookupResult DeviceTy::lookupMapping(void *HstPtrBegin, int64_t Size) {
   uintptr_t hp = (uintptr_t)HstPtrBegin;
   LookupResult lr;
 
   DP("Looking up mapping(HstPtrBegin=" DPxMOD ", Size=%" PRId64 ")...\n",
-      DPxPTR(hp), Size);
 
   if (HostDataToTargetMap.empty())
     return lr;
 
   auto upper = HostDataToTargetMap.upper_bound(hp);
   // check the left bin
   if (upper != HostDataToTargetMap.begin()) {
     lr.Entry = std::prev(upper);
     auto &HT = *lr.Entry;
     // Is it contained?
     lr.Flags.IsContained = hp >= HT.HstPtrBegin && hp < HT.HstPtrEnd &&
-        (hp+Size) <= HT.HstPtrEnd;
+                           (hp + Size) <= HT.HstPtrEnd;
     // Does it extend beyond the mapped region?
     lr.Flags.ExtendsAfter = hp < HT.HstPtrEnd && (hp + Size) > HT.HstPtrEnd;
   }
 
   // check the right bin
   if (!(lr.Flags.IsContained || lr.Flags.ExtendsAfter) &&
       upper != HostDataToTargetMap.end()) {
     lr.Entry = upper;
     auto &HT = *lr.Entry;
     // Does it extend into an already mapped region?
-    lr.Flags.ExtendsBefore = hp < HT.HstPtrBegin && (hp+Size) > HT.HstPtrBegin;
+    lr.Flags.ExtendsBefore =
+        hp < HT.HstPtrBegin && (hp + Size) > HT.HstPtrBegin;
     // Does it extend beyond the mapped region?
-    lr.Flags.ExtendsAfter = hp < HT.HstPtrEnd && (hp+Size) > HT.HstPtrEnd;
+    lr.Flags.ExtendsAfter = hp < HT.HstPtrEnd && (hp + Size) > HT.HstPtrEnd;
   }
 
   if (lr.Flags.ExtendsBefore) {
     DP("WARNING: Pointer is not mapped but section extends into already "
-        "mapped data\n");
   }
   if (lr.Flags.ExtendsAfter) {
     DP("WARNING: Pointer is already mapped but section extends beyond mapped "
-        "region\n");
   }
 
   return lr;
 }
 
 // Used by targetDataBegin
 // Return the target pointer begin (where the data will be moved).
 // Allocate memory if this is the first occurrence of this mapping.
INFO(OMP_INFOTYPE_MAPPING_EXISTS, DeviceID,
          (IsImplicit ? " (implicit)" : ""), DPxPTR(HstPtrBegin), DPxPTR(tp),
          Size, (UpdateRefCount ? " updated" : ""),
          HT.isRefCountInf() ? "INF" : std::to_string(HT.getRefCount()).c_str(),
          (HstPtrName) ? getNameFromMapping(HstPtrName).c_str() : "unknown");
     rc = (void *)tp;
   } else if ((lr.Flags.ExtendsBefore || lr.Flags.ExtendsAfter) && !IsImplicit) {
     // Explicit extension of mapped data - not allowed.
     MESSAGE("explicit extension not allowed: host address specified is " DPxMOD
-            " (%" PRId64 " bytes), but device allocation maps to host at "
-            DPxMOD " (%" PRId64 " bytes)",
+            " (%" PRId64
+            " bytes), but device allocation maps to host at " DPxMOD
+            " (%" PRId64 " bytes)",
             DPxPTR(HstPtrBegin), Size, DPxPTR(lr.Entry->HstPtrBegin),
             lr.Entry->HstPtrEnd - lr.Entry->HstPtrBegin);
     if (HasPresentModifier)
       MESSAGE("device mapping required by 'present' map type modifier does not "
               "exist for host address " DPxMOD " (%" PRId64 " bytes)",
               DPxPTR(HstPtrBegin), Size);
   } else if (PM->RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
              !HasCloseModifier) {
if (lr.Flags.IsContained ||
     auto &HT = *lr.Entry;
     IsLast = HT.getRefCount() == 1;
 
     if (!IsLast && UpdateRefCount)
       HT.decRefCount();
 
     uintptr_t tp = HT.TgtPtrBegin + ((uintptr_t)HstPtrBegin - HT.HstPtrBegin);
     DP("Mapping exists with HstPtrBegin=" DPxMOD ", TgtPtrBegin=" DPxMOD ", "
-        "Size=%" PRId64 ",%s RefCount=%s\n", DPxPTR(HstPtrBegin), DPxPTR(tp),
-        Size, (UpdateRefCount ? " updated" : ""),
-        HT.isRefCountInf() ? "INF" : std::to_string(HT.getRefCount()).c_str());
+       "Size=%" PRId64 ",%s RefCount=%s\n",
+       DPxPTR(HstPtrBegin), DPxPTR(tp), Size,
+       (UpdateRefCount ? " updated" : ""),
     rc = (void *)tp;
   } else if (PM->RTLs.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) {
     // If the value isn't found in the mapping and unified shared memory
     // is on then it means we have stumbled upon a value which we need to
     // use directly from the host.
     DP("Get HstPtrBegin " DPxMOD " Size=%" PRId64 " RefCount=%s\n",
-       DPxPTR((uintptr_t)HstPtrBegin), Size, (UpdateRefCount ? " updated" : ""));
+       DPxPTR((uintptr_t)HstPtrBegin), Size,
+       (UpdateRefCount ? " updated" : ""));
     IsHostPtr = true;
     rc = HstPtrBegin;
   }
 
   DataMapMtx.unlock();
   return rc;
 }
 
int DeviceTy::deallocTgtPtr(void *HstPtrBegin, int64_t Size, bool ForceDelete,
   DataMapMtx.lock();
   LookupResult lr = lookupMapping(HstPtrBegin, Size);
   if (lr.Flags.IsContained || lr.Flags.ExtendsBefore || lr.Flags.ExtendsAfter) {
     auto &HT = *lr.Entry;
     if (ForceDelete)
       HT.resetRefCount();
     if (HT.decRefCount() == 0) {
       DP("Deleting tgt data " DPxMOD " of size %" PRId64 "\n",
-          DPxPTR(HT.TgtPtrBegin), Size);
       deleteData((void *)HT.TgtPtrBegin);
       DP("Removing%s mapping with HstPtrBegin=" DPxMOD ", TgtPtrBegin=" DPxMOD
-          ", Size=%" PRId64 "\n", (ForceDelete ? " (forced)" : ""),
-          DPxPTR(HT.HstPtrBegin), DPxPTR(HT.TgtPtrBegin), Size);
+         ", Size=%" PRId64 "\n",
+         (ForceDelete ? " (forced)" : ""), DPxPTR(HT.HstPtrBegin),
+         DPxPTR(HT.TgtPtrBegin), Size);
       HostDataToTargetMap.erase(lr.Entry);
     }
     rc = OFFLOAD_SUCCESS;
   } else {
     REPORT("Section to delete (hst addr " DPxMOD ") does not exist in the"
            " allocated memory\n",
            DPxPTR(HstPtrBegin));
     rc = OFFLOAD_FAIL;
if (DevicesSize <= (size_t)device_num) {
     DP("Device ID  %d does not have a matching RTL\n", device_num);
     return false;
   }
 
   // Get device info
   DeviceTy &Device = PM->Devices[device_num];
 
   DP("Is the device %d (local ID %d) initialized? %d\n", device_num,
-       Device.RTLDeviceID, Device.IsInit);
 
   // Init the device if not done before
   if (!Device.IsInit && Device.initOnce() != OFFLOAD_SUCCESS) {
     DP("Failed to init device %d\n", device_num);
     return false;
   }
 
   DP("Device %d is ready to use.\n", device_num);
 
   return true;
 }

openmp/libomptarget/src/interface.cpp

EXTERN void __tgt_unregister_lib(__tgt_bin_desc *desc) {
   TIMESCOPE();
   PM->RTLs.UnregisterLib(desc);
 }
 
 /// creates host-to-target data mapping, stores it in the
 /// libomptarget.so internal structure (an entry in a stack of data maps)
 /// and passes the data to the device.
 EXTERN void __tgt_target_data_begin(int64_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
+                                    void **args_base, void **args,
+                                    int64_t *arg_sizes, int64_t *arg_types) {
   TIMESCOPE();
   __tgt_target_data_begin_mapper(nullptr, device_id, arg_num, args_base, args,
                                  arg_sizes, arg_types, nullptr, nullptr);
 }
 
 EXTERN void __tgt_target_data_begin_nowait(int64_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
-    int32_t depNum, void *depList, int32_t noAliasDepNum,
+                                           void **args_base, void **args,
+                                           int64_t *arg_sizes,
+                                           int64_t *arg_types, int32_t depNum,
+                                           void *depList, int32_t noAliasDepNum,
                                            void *noAliasDepList) {
   TIMESCOPE();
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 
   __tgt_target_data_begin_mapper(nullptr, device_id, arg_num, args_base, args,
                                  arg_sizes, arg_types, nullptr, nullptr);
 }
 
 EXTERN void __tgt_target_data_begin_mapper(ident_t *loc, int64_t device_id,
                                            int32_t arg_num, void **args_base,
                                            void **args, int64_t *arg_sizes,
                                            int64_t *arg_types,
                                            map_var_info_t *arg_names,
                                            void **arg_mappers) {
   TIMESCOPE();
-  if (IsOffloadDisabled()) return;
+  if (IsOffloadDisabled())
+    return;
 
   DP("Entering data begin region for device %" PRId64 " with %d mappings\n",
-      device_id, arg_num);
 
   // No devices available?
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
     DP("Use default device id %" PRId64 "\n", device_id);
   }
 
   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
EXTERN void __tgt_target_data_begin_nowait_mapper(
   __tgt_target_data_begin_mapper(loc, device_id, arg_num, args_base, args,
                                  arg_sizes, arg_types, arg_names, arg_mappers);
 }
 
 /// passes data from the target, releases target memory and destroys
 /// the host-target mapping (top entry from the stack of data maps)
 /// created by the last __tgt_target_data_begin.
 EXTERN void __tgt_target_data_end(int64_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
+                                  void **args_base, void **args,
+                                  int64_t *arg_sizes, int64_t *arg_types) {
   TIMESCOPE();
   __tgt_target_data_end_mapper(nullptr, device_id, arg_num, args_base, args,
                                arg_sizes, arg_types, nullptr, nullptr);
 }
 
 EXTERN void __tgt_target_data_end_nowait(int64_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
-    int32_t depNum, void *depList, int32_t noAliasDepNum,
+                                         void **args_base, void **args,
+                                         int64_t *arg_sizes, int64_t *arg_types,
+                                         int32_t depNum, void *depList,
+                                         int32_t noAliasDepNum,
                                          void *noAliasDepList) {
   TIMESCOPE();
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 
   __tgt_target_data_end_mapper(nullptr, device_id, arg_num, args_base, args,
                                arg_sizes, arg_types, nullptr, nullptr);
 }
 
 EXTERN void __tgt_target_data_end_mapper(ident_t *loc, int64_t device_id,
                                          int32_t arg_num, void **args_base,
                                          void **args, int64_t *arg_sizes,
                                          int64_t *arg_types,
                                          map_var_info_t *arg_names,
                                          void **arg_mappers) {
   TIMESCOPE();
-  if (IsOffloadDisabled()) return;
+  if (IsOffloadDisabled())
+    return;
   DP("Entering data end region with %d mappings\n", arg_num);
 
   // No devices available?
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
   }
 
   PM->RTLsMtx.lock();
if (!Device.IsInit) {
     HandleTargetOutcome(false, loc);
     return;
   }
 
   if (getInfoLevel() & OMP_INFOTYPE_KERNEL_ARGS)
     printKernelArguments(loc, device_id, arg_num, arg_sizes, arg_types,
                          arg_names, "Exiting OpenMP data region");
 #ifdef OMPTARGET_DEBUG
-  for (int i=0; i<arg_num; ++i) {
+  for (int i = 0; i < arg_num; ++i) {
     DP("Entry %2d: Base=" DPxMOD ", Begin=" DPxMOD ", Size=%" PRId64
        ", Type=0x%" PRIx64 ", Name=%s\n",
        i, DPxPTR(args_base[i]), DPxPTR(args[i]), arg_sizes[i], arg_types[i],
        (arg_names) ? getNameFromMapping(arg_names[i]).c_str() : "unknown");
   }
 #endif
 
   int rc = targetDataEnd(Device, arg_num, args_base, args, arg_sizes, arg_types,
EXTERN void __tgt_target_data_end_nowait_mapper(
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(loc, __kmpc_global_thread_num(loc));
 
   __tgt_target_data_end_mapper(loc, device_id, arg_num, args_base, args,
                                arg_sizes, arg_types, arg_names, arg_mappers);
 }
 
 EXTERN void __tgt_target_data_update(int64_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
+                                     void **args_base, void **args,
+                                     int64_t *arg_sizes, int64_t *arg_types) {
   TIMESCOPE();
   __tgt_target_data_update_mapper(nullptr, device_id, arg_num, args_base, args,
                                   arg_sizes, arg_types, nullptr, nullptr);
 }
 
-EXTERN void __tgt_target_data_update_nowait(int64_t device_id, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types,
-    int32_t depNum, void *depList, int32_t noAliasDepNum,
-    void *noAliasDepList) {
+EXTERN void __tgt_target_data_update_nowait(
+    int64_t device_id, int32_t arg_num, void **args_base, void **args,
+    int64_t *arg_sizes, int64_t *arg_types, int32_t depNum, void *depList,
+    int32_t noAliasDepNum, void *noAliasDepList) {
   TIMESCOPE();
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 
   __tgt_target_data_update_mapper(nullptr, device_id, arg_num, args_base, args,
                                   arg_sizes, arg_types, nullptr, nullptr);
 }
 
 EXTERN void __tgt_target_data_update_mapper(ident_t *loc, int64_t device_id,
                                             int32_t arg_num, void **args_base,
                                             void **args, int64_t *arg_sizes,
                                             int64_t *arg_types,
                                             map_var_info_t *arg_names,
                                             void **arg_mappers) {
   TIMESCOPE();
-  if (IsOffloadDisabled()) return;
+  if (IsOffloadDisabled())
+    return;
   DP("Entering data update with %d mappings\n", arg_num);
 
   // No devices available?
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
   }
 
   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
EXTERN void __tgt_target_data_update_nowait_mapper(
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(loc, __kmpc_global_thread_num(loc));
 
   __tgt_target_data_update_mapper(loc, device_id, arg_num, args_base, args,
                                   arg_sizes, arg_types, arg_names, arg_mappers);
 }
 
 EXTERN int __tgt_target(int64_t device_id, void *host_ptr, int32_t arg_num,
-    void **args_base, void **args, int64_t *arg_sizes, int64_t *arg_types) {
+                        void **args_base, void **args, int64_t *arg_sizes,
+                        int64_t *arg_types) {
   TIMESCOPE();
   return __tgt_target_mapper(nullptr, device_id, host_ptr, arg_num, args_base,
                              args, arg_sizes, arg_types, nullptr, nullptr);
 }
 
 EXTERN int __tgt_target_nowait(int64_t device_id, void *host_ptr,
-    int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
-    int64_t *arg_types, int32_t depNum, void *depList, int32_t noAliasDepNum,
-    void *noAliasDepList) {
+                               int32_t arg_num, void **args_base, void **args,
+                               int64_t *arg_sizes, int64_t *arg_types,
+                               int32_t depNum, void *depList,
+                               int32_t noAliasDepNum, void *noAliasDepList) {
   TIMESCOPE();
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 
   return __tgt_target_mapper(nullptr, device_id, host_ptr, arg_num, args_base,
                              args, arg_sizes, arg_types, nullptr, nullptr);
 }
 
 EXTERN int __tgt_target_mapper(ident_t *loc, int64_t device_id, void *host_ptr,
                                int32_t arg_num, void **args_base, void **args,
                                int64_t *arg_sizes, int64_t *arg_types,
                                map_var_info_t *arg_names, void **arg_mappers) {
   TIMESCOPE();
-  if (IsOffloadDisabled()) return OFFLOAD_FAIL;
-  DP("Entering target region with entry point " DPxMOD " and device Id %"
-      PRId64 "\n", DPxPTR(host_ptr), device_id);
+  if (IsOffloadDisabled())
+    return OFFLOAD_FAIL;
+  DP("Entering target region with entry point " DPxMOD " and device Id %" PRId64
+     "\n",
+     DPxPTR(host_ptr), device_id);
 
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
   }
 
   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
     REPORT("Failed to get device %" PRId64 " ready\n", device_id);
     HandleTargetOutcome(false, loc);
     return OFFLOAD_FAIL;
   }
 
   if (getInfoLevel() & OMP_INFOTYPE_KERNEL_ARGS)
     printKernelArguments(loc, device_id, arg_num, arg_sizes, arg_types,
                          arg_names, "Entering OpenMP kernel");
 #ifdef OMPTARGET_DEBUG
-  for (int i=0; i<arg_num; ++i) {
+  for (int i = 0; i < arg_num; ++i) {
     DP("Entry %2d: Base=" DPxMOD ", Begin=" DPxMOD ", Size=%" PRId64
        ", Type=0x%" PRIx64 ", Name=%s\n",
        i, DPxPTR(args_base[i]), DPxPTR(args[i]), arg_sizes[i], arg_types[i],
        (arg_names) ? getNameFromMapping(arg_names[i]).c_str() : "unknown");
   }
 #endif
 
   int rc = target(device_id, host_ptr, arg_num, args_base, args, arg_sizes,
EXTERN int __tgt_target_nowait_mapper(
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(loc, __kmpc_global_thread_num(loc));
 
   return __tgt_target_mapper(loc, device_id, host_ptr, arg_num, args_base, args,
                              arg_sizes, arg_types, arg_names, arg_mappers);
 }
 
 EXTERN int __tgt_target_teams(int64_t device_id, void *host_ptr,
-    int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
-    int64_t *arg_types, int32_t team_num, int32_t thread_limit) {
+                              int32_t arg_num, void **args_base, void **args,
+                              int64_t *arg_sizes, int64_t *arg_types,
+                              int32_t team_num, int32_t thread_limit) {
   TIMESCOPE();
   return __tgt_target_teams_mapper(nullptr, device_id, host_ptr, arg_num,
                                    args_base, args, arg_sizes, arg_types,
                                    nullptr, nullptr, team_num, thread_limit);
 }
 
 EXTERN int __tgt_target_teams_nowait(int64_t device_id, void *host_ptr,
-    int32_t arg_num, void **args_base, void **args, int64_t *arg_sizes,
-    int64_t *arg_types, int32_t team_num, int32_t thread_limit, int32_t depNum,
-    void *depList, int32_t noAliasDepNum, void *noAliasDepList) {
+                                     int32_t arg_num, void **args_base,
+                                     void **args, int64_t *arg_sizes,
+                                     int64_t *arg_types, int32_t team_num,
+                                     int32_t thread_limit, int32_t depNum,
+                                     void *depList, int32_t noAliasDepNum,
+                                     void *noAliasDepList) {
   TIMESCOPE();
   if (depNum + noAliasDepNum > 0)
     __kmpc_omp_taskwait(NULL, __kmpc_global_thread_num(NULL));
 
   return __tgt_target_teams_mapper(nullptr, device_id, host_ptr, arg_num,
                                    args_base, args, arg_sizes, arg_types,
                                    nullptr, nullptr, team_num, thread_limit);
 }
 
 EXTERN int __tgt_target_teams_mapper(ident_t *loc, int64_t device_id,
                                      void *host_ptr, int32_t arg_num,
                                      void **args_base, void **args,
                                      int64_t *arg_sizes, int64_t *arg_types,
                                      map_var_info_t *arg_names,
                                      void **arg_mappers, int32_t team_num,
                                      int32_t thread_limit) {
   TIMESCOPE();
-  if (IsOffloadDisabled()) return OFFLOAD_FAIL;
-  DP("Entering target region with entry point " DPxMOD " and device Id %"
-      PRId64 "\n", DPxPTR(host_ptr), device_id);
+  if (IsOffloadDisabled())
+    return OFFLOAD_FAIL;
+  DP("Entering target region with entry point " DPxMOD " and device Id %" PRId64
+     "\n",
+     DPxPTR(host_ptr), device_id);
 
   if (device_id == OFFLOAD_DEVICE_DEFAULT) {
     device_id = omp_get_default_device();
   }
 
   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
     REPORT("Failed to get device %" PRId64 " ready\n", device_id);
     HandleTargetOutcome(false, loc);
     return OFFLOAD_FAIL;
   }
 
   if (getInfoLevel() & OMP_INFOTYPE_KERNEL_ARGS)
     printKernelArguments(loc, device_id, arg_num, arg_sizes, arg_types,
                          arg_names, "Entering OpenMP kernel");
 #ifdef OMPTARGET_DEBUG
-  for (int i=0; i<arg_num; ++i) {
+  for (int i = 0; i < arg_num; ++i) {
     DP("Entry %2d: Base=" DPxMOD ", Begin=" DPxMOD ", Size=%" PRId64
        ", Type=0x%" PRIx64 ", Name=%s\n",
        i, DPxPTR(args_base[i]), DPxPTR(args[i]), arg_sizes[i], arg_types[i],
        (arg_names) ? getNameFromMapping(arg_names[i]).c_str() : "unknown");
   }
 #endif
 
   int rc = target(device_id, host_ptr, arg_num, args_base, args, arg_sizes,
EXTERN void __kmpc_push_target_tripcount(ident_t *loc, int64_t device_id,
 
   if (CheckDeviceAndCtors(device_id) != OFFLOAD_SUCCESS) {
     DP("Failed to get device %" PRId64 " ready\n", device_id);
     HandleTargetOutcome(false, loc);
     return;
   }
 
   DP("__kmpc_push_target_tripcount(%" PRId64 ", %" PRIu64 ")\n", device_id,
-      loop_tripcount);
   PM->TblMapMtx.lock();
   PM->Devices[device_id].LoopTripCnt.emplace(__kmpc_global_thread_num(NULL),
                                              loop_tripcount);
   PM->TblMapMtx.unlock();
 }

openmp/libomptarget/src/omptarget.cpp

  * by the CUDA plugin). By padding the begin address down to a multiple of 8 and
  * extending the size of the allocated chuck accordingly, the chuck on the
  * device will start at 0x200 with the padding (4 bytes), then &s1.b=0x204 and
  * &s1.p=0x208, as they should be to satisfy the alignment requirements.
  */
 static const int64_t Alignment = 8;
 
 /// Map global data and execute pending ctors
-static int InitLibrary(DeviceTy& Device) {
+static int InitLibrary(DeviceTy &Device) {
   /*
    * Map global data
    */
   int32_t device_id = Device.DeviceID;
   int rc = OFFLOAD_SUCCESS;
 
   Device.PendingGlobalsMtx.lock();
   PM->TrlTblMtx.lock();
assert(TransTable->TargetsImages.size() > (size_t)device_id &&
            "Not expecting a device ID outside the table's bounds!");
     __tgt_device_image *img = TransTable->TargetsImages[device_id];
     if (!img) {
       REPORT("No image loaded for device id %d.\n", device_id);
       rc = OFFLOAD_FAIL;
       break;
     }
     // 2) load image into the target table.
-    __tgt_target_table *TargetTable =
-        TransTable->TargetsTable[device_id] = Device.load_binary(img);
+    __tgt_target_table *TargetTable = TransTable->TargetsTable[device_id] =
+        Device.load_binary(img);
     // Unable to get table for this image: invalidate image and fail.
     if (!TargetTable) {
       REPORT("Unable to generate entries table for device id %d.\n", device_id);
       TransTable->TargetsImages[device_id] = 0;
       rc = OFFLOAD_FAIL;
       break;
     }
 
for (__tgt_offload_entry *CurrDeviceEntry = TargetTable->EntriesBegin,
 
         // Fortran may use multiple weak declarations for the same symbol,
         // therefore we must allow for multiple weak symbols to be loaded from
         // the fat binary. Treat these mappings as any other "regular" mapping.
         // Add entry to map.
         if (Device.getTgtPtrBegin(CurrHostEntry->addr, CurrHostEntry->size))
           continue;
         DP("Add mapping from host " DPxMOD " to device " DPxMOD " with size %zu"
-            "\n", DPxPTR(CurrHostEntry->addr), DPxPTR(CurrDeviceEntry->addr),
-            CurrDeviceEntry->size);
+           "\n",
+           DPxPTR(CurrHostEntry->addr), DPxPTR(CurrDeviceEntry->addr),
         Device.HostDataToTargetMap.emplace(
             (uintptr_t)CurrHostEntry->addr /*HstPtrBase*/,
             (uintptr_t)CurrHostEntry->addr /*HstPtrBegin*/,
             (uintptr_t)CurrHostEntry->addr + CurrHostEntry->size /*HstPtrEnd*/,
             (uintptr_t)CurrDeviceEntry->addr /*TgtPtrBegin*/, nullptr,
             true /*IsRefCountINF*/);
       }
     }
for (int32_t i = 0; i < arg_num; ++i) {
     void *HstPtrBase = args_base[i];
     int64_t data_size = arg_sizes[i];
     map_var_info_t HstPtrName = (!arg_names) ? nullptr : arg_names[i];
 
     // Adjust for proper alignment if this is a combined entry (for structs).
     // Look at the next argument - if that is MEMBER_OF this one, then this one
     // is a combined entry.
     int64_t padding = 0;
-    const int next_i = i+1;
+    const int next_i = i + 1;
     if (getParentIndex(arg_types[i]) < 0 && next_i < arg_num &&
         getParentIndex(arg_types[next_i]) == i) {
       padding = (int64_t)HstPtrBegin % Alignment;
       if (padding) {
         DP("Using a padding of %" PRId64 " bytes for begin address " DPxMOD
-            "\n", padding, DPxPTR(HstPtrBegin));
-        HstPtrBegin = (char *) HstPtrBegin - padding;
+           "\n",
+           padding, DPxPTR(HstPtrBegin));
+        HstPtrBegin = (char *)HstPtrBegin - padding;
         data_size += padding;
       }
     }
 
     // Address of pointer on the host and device, respectively.
     void *Pointer_HstPtrBegin, *PointerTgtPtrBegin;
     bool IsNew, Pointer_IsNew;
     bool IsHostPtr = false;
if (arg_types[i] & OMP_TGT_MAPTYPE_PTR_AND_OBJ) {
           HasPresentModifier);
       if (!PointerTgtPtrBegin) {
         REPORT("Call to getOrAllocTgtPtr returned null pointer (%s).\n",
                HasPresentModifier ? "'present' map type modifier"
                                   : "device failure or illegal mapping");
         return OFFLOAD_FAIL;
       }
       DP("There are %zu bytes allocated at target address " DPxMOD " - is%s new"
-          "\n", sizeof(void *), DPxPTR(PointerTgtPtrBegin),
-          (Pointer_IsNew ? "" : " not"));
+         "\n",
+         sizeof(void *), DPxPTR(PointerTgtPtrBegin),
       Pointer_HstPtrBegin = HstPtrBase;
       // modify current entry.
       HstPtrBase = *(void **)HstPtrBase;
       UpdateRef = true; // subsequently update ref count of pointee
     }
 
     void *TgtPtrBegin = Device.getOrAllocTgtPtr(
         HstPtrBegin, HstPtrBase, data_size, HstPtrName, IsNew, IsHostPtr,
         IsImplicit, UpdateRef, HasCloseModifier, HasPresentModifier);
     // If data_size==0, then the argument could be a zero-length pointer to
     // NULL, so getOrAlloc() returning NULL is not an error.
     if (!TgtPtrBegin && (data_size || HasPresentModifier)) {
       REPORT("Call to getOrAllocTgtPtr returned null pointer (%s).\n",
              HasPresentModifier ? "'present' map type modifier"
                                 : "device failure or illegal mapping");
       return OFFLOAD_FAIL;
     }
     DP("There are %" PRId64 " bytes allocated at target address " DPxMOD
-        " - is%s new\n", data_size, DPxPTR(TgtPtrBegin),
-        (IsNew ? "" : " not"));
+       " - is%s new\n",
+       data_size, DPxPTR(TgtPtrBegin), (IsNew ? "" : " not"));
 
     if (arg_types[i] & OMP_TGT_MAPTYPE_RETURN_PARAM) {
       uintptr_t Delta = (uintptr_t)HstPtrBegin - (uintptr_t)HstPtrBase;
       void *TgtPtrBase = (void *)((uintptr_t)TgtPtrBegin - Delta);
       DP("Returning device pointer " DPxMOD "\n", DPxPTR(TgtPtrBase));
       args_base[i] = TgtPtrBase;
     }
 

openmp/libomptarget/src/rtl.h

public:
 
   // Register a shared library with all (compatible) RTLs.
   void RegisterLib(__tgt_bin_desc *desc);
 
   // Unregister a shared library from all RTLs.
   void UnregisterLib(__tgt_bin_desc *desc);
 };
 
-
 /// Map between the host entry begin and the translation table. Each
 /// registered library gets one TranslationTable. Use the map from
 /// __tgt_offload_entry so that we may quickly determine whether we
 /// are trying to (re)register an existing lib or really have a new one.
 struct TranslationTable {
   __tgt_target_table HostTable;
 
   // Image assigned to a given device.

openmp/libomptarget/src/rtl.cpp

 //===----------- rtl.cpp - Target independent OpenMP target RTL -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Functionality for handling RTL plugins.
 //
 //===----------------------------------------------------------------------===//
 
+#include "rtl.h"
 #include "device.h"
 #include "private.h"
-#include "rtl.h"
 
 #include <cassert>
 #include <cstdlib>
 #include <cstring>
 #include <dlfcn.h>
 #include <mutex>
 #include <string>
 
#endif
 
   return;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Functionality for registering libs
 
 static void RegisterImageIntoTranslationTable(TranslationTable &TT,
-    RTLInfoTy &RTL, __tgt_device_image *image) {
+                                              RTLInfoTy &RTL,
+                                              __tgt_device_image *image) {
 
   // same size, as when we increase one, we also increase the other.
   assert(TT.TargetsTable.size() == TT.TargetsImages.size() &&
          "We should have as many images as we have tables!");
 
   // Resize the Targets Table and Images to accommodate the new targets if
   // required
   unsigned TargetsTableMinimumSize = RTL.Idx + RTL.NumberOfDevices;
for (int32_t i = 0; i < RTL.NumberOfDevices; ++i) {
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Functionality for registering Ctors/Dtors
 
 static void RegisterGlobalCtorsDtorsForImage(__tgt_bin_desc *desc,
-    __tgt_device_image *img, RTLInfoTy *RTL) {
+                                             __tgt_device_image *img,
+                                             RTLInfoTy *RTL) {
 
   for (int32_t i = 0; i < RTL->NumberOfDevices; ++i) {
     DeviceTy &Device = PM->Devices[RTL->Idx + i];
     Device.PendingGlobalsMtx.lock();
     Device.HasPendingGlobals = true;
     for (__tgt_offload_entry *entry = img->EntriesBegin;
          entry != img->EntriesEnd; ++entry) {
       if (entry->flags & OMP_DECLARE_TARGET_CTOR) {
         DP("Adding ctor " DPxMOD " to the pending list.\n",
-            DPxPTR(entry->addr));
         Device.PendingCtorsDtors[desc].PendingCtors.push_back(entry->addr);
       } else if (entry->flags & OMP_DECLARE_TARGET_DTOR) {
         // Dtors are pushed in reverse order so they are executed from end
         // to beginning when unregistering the library!
         DP("Adding dtor " DPxMOD " to the pending list.\n",
-            DPxPTR(entry->addr));
         Device.PendingCtorsDtors[desc].PendingDtors.push_front(entry->addr);
       }
 
       if (entry->flags & OMP_DECLARE_TARGET_LINK) {
         DP("The \"link\" attribute is not yet supported!\n");
       }
     }
     Device.PendingGlobalsMtx.unlock();
void RTLsTy::RegisterRequires(int64_t flags) {
 
   // If multiple compilation units are present enforce
   // consistency across all of them for require clauses:
   //  - reverse_offload
   //  - unified_address
   //  - unified_shared_memory
   if ((RequiresFlags & OMP_REQ_REVERSE_OFFLOAD) !=
       (flags & OMP_REQ_REVERSE_OFFLOAD)) {
-    FATAL_MESSAGE0(1,
-        "'#pragma omp requires reverse_offload' not used consistently!");
+    FATAL_MESSAGE0(
+        1, "'#pragma omp requires reverse_offload' not used consistently!");
   }
   if ((RequiresFlags & OMP_REQ_UNIFIED_ADDRESS) !=
-          (flags & OMP_REQ_UNIFIED_ADDRESS)) {
-    FATAL_MESSAGE0(1,
-        "'#pragma omp requires unified_address' not used consistently!");
+    FATAL_MESSAGE0(
+        1, "'#pragma omp requires unified_address' not used consistently!");
   }
   if ((RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) !=
-          (flags & OMP_REQ_UNIFIED_SHARED_MEMORY)) {
-    FATAL_MESSAGE0(1,
+    FATAL_MESSAGE0(
+        1,
         "'#pragma omp requires unified_shared_memory' not used consistently!");
   }
 
   // TODO: insert any other missing checks
 
   DP("New requires flags %" PRId64 " compatible with existing %" PRId64 "!\n",
      flags, RequiresFlags);
 }
for (int32_t i = 0; i < desc->NumDeviceImages; ++i) {
 
     RTLInfoTy *FoundRTL = NULL;
 
     // Scan the RTLs that have associated images until we find one that supports
     // the current image.
     for (auto &R : AllRTLs) {
       if (!R.is_valid_binary(img)) {
         DP("Image " DPxMOD " is NOT compatible with RTL %s!\n",
-            DPxPTR(img->ImageStart), R.RTLName.c_str());
         continue;
       }
 
       DP("Image " DPxMOD " is compatible with RTL %s!\n",
-          DPxPTR(img->ImageStart), R.RTLName.c_str());
 
       // If this RTL is not already in use, initialize it.
       if (!R.isUsed) {
         // Initialize the device information for the RTL we are about to use.
         DeviceTy device(&R);
         size_t Start = PM->Devices.size();
         PM->Devices.resize(Start + R.NumberOfDevices, device);
         for (int32_t device_id = 0; device_id < R.NumberOfDevices;
              device_id++) {
           // global device ID
           PM->Devices[Start + device_id].DeviceID = Start + device_id;
           // RTL local device ID
           PM->Devices[Start + device_id].RTLDeviceID = device_id;
         }
 
         // Initialize the index of this RTL and save it in the used RTLs.
         R.Idx = (UsedRTLs.empty())
                     ? 0
                     : UsedRTLs.back()->Idx + UsedRTLs.back()->NumberOfDevices;
-        assert((size_t) R.Idx == Start &&
+        assert((size_t)R.Idx == Start &&
                "RTL index should equal the number of devices used so far.");
         R.isUsed = true;
         UsedRTLs.push_back(&R);
 
         DP("RTL " DPxMOD " has index %d!\n", DPxPTR(R.LibraryHandler), R.Idx);
       }
 
       // Initialize (if necessary) translation table for this library.
       PM->TrlTblMtx.lock();
       if (!PM->HostEntriesBeginToTransTable.count(desc->HostEntriesBegin)) {
         TranslationTable &TransTable =
             (PM->HostEntriesBeginToTransTable)[desc->HostEntriesBegin];
         TransTable.HostTable.EntriesBegin = desc->HostEntriesBegin;
         TransTable.HostTable.EntriesEnd = desc->HostEntriesEnd;
       }
 
       // Retrieve translation table for this library.
       TranslationTable &TransTable =
           (PM->HostEntriesBeginToTransTable)[desc->HostEntriesBegin];
 
-      DP("Registering image " DPxMOD " with RTL %s!\n",
-          DPxPTR(img->ImageStart), R.RTLName.c_str());
+      DP("Registering image " DPxMOD " with RTL %s!\n", DPxPTR(img->ImageStart),
+         R.RTLName.c_str());
       RegisterImageIntoTranslationTable(TransTable, R, img);
       PM->TrlTblMtx.unlock();
       FoundRTL = &R;
 
       // Load ctors/dtors for static objects
       RegisterGlobalCtorsDtorsForImage(desc, img, FoundRTL);
 
       // if an RTL was found we are done - proceed to register the next image
for (int32_t i = 0; i < desc->NumDeviceImages; ++i) {
     // Scan the RTLs that have associated images until we find one that supports
     // the current image. We only need to scan RTLs that are already being used.
     for (auto *R : UsedRTLs) {
 
       assert(R->isUsed && "Expecting used RTLs.");
 
       if (!R->is_valid_binary(img)) {
         DP("Image " DPxMOD " is NOT compatible with RTL " DPxMOD "!\n",
-            DPxPTR(img->ImageStart), DPxPTR(R->LibraryHandler));
         continue;
       }
 
       DP("Image " DPxMOD " is compatible with RTL " DPxMOD "!\n",
-          DPxPTR(img->ImageStart), DPxPTR(R->LibraryHandler));
 
       FoundRTL = R;
 
       // Execute dtors for static objects if the device has been used, i.e.
       // if its PendingCtors list has been emptied.
       for (int32_t i = 0; i < FoundRTL->NumberOfDevices; ++i) {
         DeviceTy &Device = PM->Devices[FoundRTL->Idx + i];
         Device.PendingGlobalsMtx.lock();
         if (Device.PendingCtorsDtors[desc].PendingCtors.empty()) {
           for (auto &dtor : Device.PendingCtorsDtors[desc].PendingDtors) {
             int rc = target(Device.DeviceID, dtor, 0, nullptr, nullptr, nullptr,
                             nullptr, nullptr, nullptr, 1, 1, true /*team*/);
             if (rc != OFFLOAD_SUCCESS) {
               DP("Running destructor " DPxMOD " failed.\n", DPxPTR(dtor));
             }
           }
           // Remove this library's entry from PendingCtorsDtors
           Device.PendingCtorsDtors.erase(desc);
         }
         Device.PendingGlobalsMtx.unlock();
       }
 
       DP("Unregistered image " DPxMOD " from RTL " DPxMOD "!\n",
-          DPxPTR(img->ImageStart), DPxPTR(R->LibraryHandler));
 
       break;
     }
 
     // if no RTL was found proceed to unregister the next image
-    if (!FoundRTL){
+    if (!FoundRTL) {
       DP("No RTLs in use support the image " DPxMOD "!\n",
-          DPxPTR(img->ImageStart));
     }
   }
   PM->RTLsMtx.unlock();
   DP("Done unregistering images!\n");
 
   // Remove entries from PM->HostPtrToTableMap
   PM->TblMapMtx.lock();
   for (__tgt_offload_entry *cur = desc->HostEntriesBegin;
        cur < desc->HostEntriesEnd; ++cur) {
     PM->HostPtrToTableMap.erase(cur->addr);
   }
 
   // Remove translation table for this descriptor.
-  auto TransTable = PM->HostEntriesBeginToTransTable.find(desc->HostEntriesBegin);
+  auto TransTable =
+      PM->HostEntriesBeginToTransTable.find(desc->HostEntriesBegin);
   if (TransTable != PM->HostEntriesBeginToTransTable.end()) {
     DP("Removing translation table for descriptor " DPxMOD "\n",
-        DPxPTR(desc->HostEntriesBegin));
     PM->HostEntriesBeginToTransTable.erase(TransTable);
   } else {
     DP("Translation table for descriptor " DPxMOD " cannot be found, probably "
-        "it has been already removed.\n", DPxPTR(desc->HostEntriesBegin));
+       "it has been already removed.\n",
+       DPxPTR(desc->HostEntriesBegin));
   }
 
   PM->TblMapMtx.unlock();
 
   // TODO: Remove RTL and the devices it manages if it's not used anymore?
   // TODO: Write some RTL->unload_image(...) function?
 
   DP("Done unregistering library!\n");
 }

openmp/runtime/doc/doxygen/libomp_interface.h

-// This file does not contain any code; it just contains additional text and formatting
-// for doxygen.
-
+// This file does not contain any code; it just contains additional text and
+// formatting for doxygen.
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 /*! @mainpage LLVM  OpenMP* Runtime Library Interface
 @section sec_intro Introduction
 
 This document describes the interface provided by the
 LLVM  OpenMP\other runtime library to the compiler.
 Routines that are directly called as simple functions by user code are
 not currently described here, since their definition is in the OpenMP
 specification available from http://openmp.org
 
 The aim here is to explain the interface from the compiler to the runtime.
 
 The overall design is described, and each function in the interface
-has its own description. (At least, that's the ambition, we may not be there yet).
+has its own description. (At least, that's the ambition, we may not be there
+yet).
 
 @section sec_building Quickly Building the Runtime
 For the impatient, we cover building the runtime as the first topic here.
 
-CMake is used to build the OpenMP runtime.  For details and a full list of options for the CMake build system,
-see <tt>README.rst</tt> in the source code repository.  These instructions will provide the most typical build.
+CMake is used to build the OpenMP runtime.  For details and a full list of
+options for the CMake build system, see <tt>README.rst</tt> in the source code
+repository.  These instructions will provide the most typical build.
 
 In-LLVM-tree build:.
 @code
 $ cd where-you-want-to-live
 Check out openmp into llvm/projects
 $ cd where-you-want-to-build
 $ mkdir build && cd build
-$ cmake path/to/llvm -DCMAKE_C_COMPILER=<C compiler> -DCMAKE_CXX_COMPILER=<C++ compiler>
-$ make omp
+$ cmake path/to/llvm -DCMAKE_C_COMPILER=<C compiler> -DCMAKE_CXX_COMPILER=<C++
+compiler> $ make omp
 @endcode
 Out-of-LLVM-tree build:
 @code
 $ cd where-you-want-to-live
 Check out openmp
 $ cd where-you-want-to-live/openmp
 $ mkdir build && cd build
-$ cmake path/to/openmp -DCMAKE_C_COMPILER=<C compiler> -DCMAKE_CXX_COMPILER=<C++ compiler>
-$ make
+$ cmake path/to/openmp -DCMAKE_C_COMPILER=<C compiler> -DCMAKE_CXX_COMPILER=<C++
+compiler> $ make
 @endcode
 
 @section sec_supported Supported RTL Build Configurations
 
 The architectures supported are IA-32 architecture, Intel&reg;&nbsp; 64, and
 Intel&reg;&nbsp; Many Integrated Core Architecture.  The build configurations
 supported are shown in the table below.
 
 <table border=1>
 <tr><th> <th>icc/icl<th>gcc<th>clang
 <tr><td>Linux\other OS<td>Yes(1,5)<td>Yes(2,4)<td>Yes(4,6,7)
 <tr><td>FreeBSD\other<td>Yes(1,5)<td>Yes(2,4)<td>Yes(4,6,7,8)
 <tr><td>OS X\other<td>Yes(1,3,4)<td>No<td>Yes(4,6,7)
 <tr><td>Windows\other OS<td>Yes(1,4)<td>No<td>No
 </table>
-(1) On IA-32 architecture and Intel&reg;&nbsp; 64, icc/icl versions 12.x 
+(1) On IA-32 architecture and Intel&reg;&nbsp; 64, icc/icl versions 12.x
     are supported (12.1 is recommended).<br>
 (2) gcc version 4.7 is supported.<br>
 (3) For icc on OS X\other, OS X\other version 10.5.8 is supported.<br>
 (4) Intel&reg;&nbsp; Many Integrated Core Architecture not supported.<br>
-(5) On Intel&reg;&nbsp; Many Integrated Core Architecture, icc/icl versions 13.0 or later are required.<br>
-(6) Clang\other version 3.3 is supported.<br>
-(7) Clang\other currently does not offer a software-implemented 128 bit extended
+(5) On Intel&reg;&nbsp; Many Integrated Core Architecture, icc/icl versions 13.0
+or later are required.<br> (6) Clang\other version 3.3 is supported.<br> (7)
+Clang\other currently does not offer a software-implemented 128 bit extended
     precision type.  Thus, all entry points reliant on this type are removed
     from the library and cannot be called in the user program.  The following
     functions are not available:
 @code
     __kmpc_atomic_cmplx16_*
     __kmpc_atomic_float16_*
     __kmpc_atomic_*_fp
 @endcode

 @code
 static void outlinedFooBody()
 {
     ... do something ...
 }
 
 void foo()
 {
-    __OMP_runtime_fork(outlinedFooBody, (void*)0);   // Not the real function name!
+    __OMP_runtime_fork(outlinedFooBody, (void*)0);   // Not the real function
+name!
 }
 @endcode
 
 @subsection SEC_SHAREDVARS Addressing shared variables
 
-In real uses of the OpenMP\other API there are normally references 
-from the outlined code  to shared variables that are in scope in the containing function. 
-Therefore the containing function must be able to address 
-these variables. The runtime supports two alternate ways of doing
-this.
+In real uses of the OpenMP\other API there are normally references
+from the outlined code  to shared variables that are in scope in the containing
+function. Therefore the containing function must be able to address these
+variables. The runtime supports two alternate ways of doing this.
 
 @subsubsection SEC_SEC_OT Current Technique
 The technique currently supported by the runtime library is to receive
 a separate pointer to each shared variable that can be accessed from
 the outlined function.  This is what is shown in the example below.
 
 We hope soon to provide an alternative interface to support the
 alternate implementation described in the next section. The

 If it is hard to determine the stack layout of the parent while generating the
 outlined code, it is still possible to use this approach by collecting all of
 the variables in the parent that are accessed from outlined functions into
 a single `struct` which is placed on the stack, and whose address is passed
 to the outlined functions. In this way the offsets of the shared variables
 are known (since they are inside the struct) without needing to know
 the complete layout of the parent stack-frame. From the point of view
 of the runtime either of these techniques is equivalent, since in either
-case it only has to pass a single argument to the outlined function to allow 
+case it only has to pass a single argument to the outlined function to allow
 it to access shared variables.
 
 A scheme like this is how gcc\other generates outlined functions.
 
 @section SEC_INTERFACES Library Interfaces
-The library functions used for specific parts of the OpenMP\other language implementation
-are documented in different modules.
+The library functions used for specific parts of the OpenMP\other language
+implementation are documented in different modules.
 
  - @ref BASIC_TYPES fundamental types used by the runtime in many places
  - @ref DEPRECATED  functions that are in the library but are no longer required
  - @ref STARTUP_SHUTDOWN functions for initializing and finalizing the runtime
  - @ref PARALLEL functions for implementing `omp parallel`
  - @ref THREAD_STATES functions for supporting thread state inquiries
- - @ref WORK_SHARING functions for work sharing constructs such as `omp for`, `omp sections`
+ - @ref WORK_SHARING functions for work sharing constructs such as `omp for`,
+`omp sections`
  - @ref THREADPRIVATE functions to support thread private data, copyin etc
- - @ref SYNCHRONIZATION functions to support `omp critical`, `omp barrier`, `omp master`, reductions etc
+ - @ref SYNCHRONIZATION functions to support `omp critical`, `omp barrier`, `omp
+master`, reductions etc
  - @ref ATOMIC_OPS functions to support atomic operations
  - @ref STATS_GATHERING macros to support developer profiling of libomp
  - Documentation on tasking has still to be written...
 
 @section SEC_EXAMPLES Examples
 @subsection SEC_WORKSHARING_EXAMPLE Work Sharing Example
-This example shows the code generated for a parallel for with reduction and dynamic scheduling.
+This example shows the code generated for a parallel for with reduction and
+dynamic scheduling.
 
 @code
 extern float foo( void );
 
 int main () {
-    int i; 
-    float r = 0.0; 
-    #pragma omp parallel for schedule(dynamic) reduction(+:r) 
+    int i;
+    float r = 0.0;
+    #pragma omp parallel for schedule(dynamic) reduction(+:r)
     for ( i = 0; i < 10; i ++ ) {
-        r += foo(); 
+        r += foo();
     }
 }
 @endcode
 
 The transformed code looks like this.
 @code
-extern float foo( void ); 
+extern float foo( void );
 
 int main () {
-    static int zero = 0; 
-    auto int gtid; 
-    auto float r = 0.0; 
-    __kmpc_begin( & loc3, 0 ); 
+    static int zero = 0;
+    auto int gtid;
+    auto float r = 0.0;
+    __kmpc_begin( & loc3, 0 );
     // The gtid is not actually required in this example so could be omitted;
-    // We show its initialization here because it is often required for calls into
+    // We show its initialization here because it is often required for calls
+into
     // the runtime and should be locally cached like this.
-    gtid = __kmpc_global thread num( & loc3 ); 
-    __kmpc_fork call( & loc7, 1, main_7_parallel_3, & r ); 
-    __kmpc_end( & loc0 ); 
-    return 0; 
+    gtid = __kmpc_global thread num( & loc3 );
+    __kmpc_fork call( & loc7, 1, main_7_parallel_3, & r );
+    __kmpc_end( & loc0 );
+    return 0;
 }
 
-struct main_10_reduction_t_5 { float r_10_rpr; }; 
+struct main_10_reduction_t_5 { float r_10_rpr; };
 
 static kmp_critical_name lck = { 0 };
-static ident_t loc10; // loc10.flags should contain KMP_IDENT_ATOMIC_REDUCE bit set 
+static ident_t loc10; // loc10.flags should contain KMP_IDENT_ATOMIC_REDUCE bit
+set
                       // if compiler has generated an atomic reduction.
 
 void main_7_parallel_3( int *gtid, int *btid, float *r_7_shp ) {
-    auto int i_7_pr; 
-    auto int lower, upper, liter, incr; 
-    auto struct main_10_reduction_t_5 reduce; 
-    reduce.r_10_rpr = 0.F; 
-    liter = 0; 
-    __kmpc_dispatch_init_4( & loc7,*gtid, 35, 0, 9, 1, 1 ); 
-    while ( __kmpc_dispatch_next_4( & loc7, *gtid, & liter, & lower, & upper, & incr ) ) {
-        for( i_7_pr = lower; upper >= i_7_pr; i_7_pr ++ ) 
-          reduce.r_10_rpr += foo(); 
-    }
-    switch( __kmpc_reduce_nowait( & loc10, *gtid, 1, 4, & reduce, main_10_reduce_5, & lck ) ) {
-        case 1:
-           *r_7_shp += reduce.r_10_rpr;
+    auto int i_7_pr;
+    auto int lower, upper, liter, incr;
+    auto struct main_10_reduction_t_5 reduce;
+    reduce.r_10_rpr = 0.F;
+    liter = 0;
+    __kmpc_dispatch_init_4( & loc7,*gtid, 35, 0, 9, 1, 1 );
+    while ( __kmpc_dispatch_next_4( & loc7, *gtid, & liter, & lower, & upper, &
+incr ) ) { for( i_7_pr = lower; upper >= i_7_pr; i_7_pr ++ ) reduce.r_10_rpr +=
+foo();
+    }
+    switch( __kmpc_reduce_nowait( & loc10, *gtid, 1, 4, & reduce,
+main_10_reduce_5, & lck ) ) { case 1: *r_7_shp += reduce.r_10_rpr;
            __kmpc_end_reduce_nowait( & loc10, *gtid, & lck );
            break;
         case 2:
            __kmpc_atomic_float4_add( & loc10, *gtid, r_7_shp, reduce.r_10_rpr );
            break;
         default:;
     }
-} 
+}
 
-void main_10_reduce_5( struct main_10_reduction_t_5 *reduce_lhs, 
-                       struct main_10_reduction_t_5 *reduce_rhs ) 
-{ 
-    reduce_lhs->r_10_rpr += reduce_rhs->r_10_rpr; 
+void main_10_reduce_5( struct main_10_reduction_t_5 *reduce_lhs,
+                       struct main_10_reduction_t_5 *reduce_rhs )
+{
+    reduce_lhs->r_10_rpr += reduce_rhs->r_10_rpr;
 }
 @endcode
 
 @defgroup BASIC_TYPES Basic Types
 Types that are used throughout the runtime.
 
 @defgroup DEPRECATED Deprecated Functions
 Functions in this group are for backwards compatibility only, and
 should not be used in new code.
 
 @defgroup STARTUP_SHUTDOWN Startup and Shutdown
 These functions are for library initialization and shutdown.
 
 @defgroup PARALLEL Parallel (fork/join)
 These functions are used for implementing <tt>\#pragma omp parallel</tt>.
 
 @defgroup THREAD_STATES Thread Information
 These functions return information about the currently executing thread.
 
 @defgroup WORK_SHARING Work Sharing
-These functions are used for implementing 
-<tt>\#pragma omp for</tt>, <tt>\#pragma omp sections</tt>, <tt>\#pragma omp single</tt> and 
-<tt>\#pragma omp master</tt> constructs. 
+These functions are used for implementing
+<tt>\#pragma omp for</tt>, <tt>\#pragma omp sections</tt>, <tt>\#pragma omp
+single</tt> and <tt>\#pragma omp master</tt> constructs.
 
-When handling loops, there are different functions for each of the signed and unsigned 32 and 64 bit integer types
-which have the name suffixes `_4`, `_4u`, `_8` and `_8u`. The semantics of each of the functions is the same,
-so they are only described once.
-
-Static loop scheduling is handled by  @ref __kmpc_for_static_init_4 and friends. Only a single call is needed,
-since the iterations to be executed by any give thread can be determined as soon as the loop parameters are known.
-
-Dynamic scheduling is handled by the @ref __kmpc_dispatch_init_4 and @ref __kmpc_dispatch_next_4 functions. 
-The init function is called once in each thread outside the loop, while the next function is called each
-time that the previous chunk of work has been exhausted. 
+When handling loops, there are different functions for each of the signed and
+unsigned 32 and 64 bit integer types which have the name suffixes `_4`, `_4u`,
+`_8` and `_8u`. The semantics of each of the functions is the same, so they are
+only described once.
+
+Static loop scheduling is handled by  @ref __kmpc_for_static_init_4 and friends.
+Only a single call is needed, since the iterations to be executed by any give
+thread can be determined as soon as the loop parameters are known.
+
+Dynamic scheduling is handled by the @ref __kmpc_dispatch_init_4 and @ref
+__kmpc_dispatch_next_4 functions. The init function is called once in each
+thread outside the loop, while the next function is called each time that the
+previous chunk of work has been exhausted.
 
 @defgroup SYNCHRONIZATION Synchronization
 These functions are used for implementing barriers.
 
 @defgroup THREADPRIVATE Thread private data support
 These functions support copyin/out and thread private data.
 
 @defgroup STATS_GATHERING Statistics Gathering from OMPTB
-These macros support profiling the libomp library.  Use --stats=on when building with build.pl to enable
-and then use the KMP_* macros to profile (through counts or clock ticks) libomp during execution of an OpenMP program.
+These macros support profiling the libomp library.  Use --stats=on when building
+with build.pl to enable and then use the KMP_* macros to profile (through counts
+or clock ticks) libomp during execution of an OpenMP program.
 
 @section sec_stats_env_vars Environment Variables
 
-This section describes the environment variables relevant to stats-gathering in libomp
+This section describes the environment variables relevant to stats-gathering in
+libomp
 
 @code
 KMP_STATS_FILE
 @endcode
-This environment variable is set to an output filename that will be appended *NOT OVERWRITTEN* if it exists.  If this environment variable is undefined, the statistics will be output to stderr
+This environment variable is set to an output filename that will be appended
+*NOT OVERWRITTEN* if it exists.  If this environment variable is undefined, the
+statistics will be output to stderr
 
 @code
 KMP_STATS_THREADS
 @endcode
-This environment variable indicates to print thread-specific statistics as well as aggregate statistics.  Each thread's statistics will be shown as well as the collective sum of all threads.  The values "true", "on", "1", "yes" will all indicate to print per thread statistics.
+This environment variable indicates to print thread-specific statistics as well
+as aggregate statistics.  Each thread's statistics will be shown as well as the
+collective sum of all threads.  The values "true", "on", "1", "yes" will all
+indicate to print per thread statistics.
 
 @defgroup TASKING Tasking support
 These functions support tasking constructs.
 
 @defgroup USER User visible functions
-These functions can be called directly by the user, but are runtime library specific, rather than being OpenMP interfaces.
+These functions can be called directly by the user, but are runtime library
+specific, rather than being OpenMP interfaces.
 
 */
-

openmp/runtime/src/kmp.h

 #define SCHEDULE_WITHOUT_MODIFIERS(s)                                          \
   (enum sched_type)(                                                           \
       (s) & ~(kmp_sch_modifier_nonmonotonic | kmp_sch_modifier_monotonic))
 #define SCHEDULE_HAS_MONOTONIC(s) (((s)&kmp_sch_modifier_monotonic) != 0)
 #define SCHEDULE_HAS_NONMONOTONIC(s) (((s)&kmp_sch_modifier_nonmonotonic) != 0)
 #define SCHEDULE_HAS_NO_MODIFIERS(s)                                           \
   (((s) & (kmp_sch_modifier_nonmonotonic | kmp_sch_modifier_monotonic)) == 0)
 #define SCHEDULE_GET_MODIFIERS(s)                                              \
-  ((enum sched_type)(                                                          \
-      (s) & (kmp_sch_modifier_nonmonotonic | kmp_sch_modifier_monotonic)))
+  ((enum sched_type)((s) & (kmp_sch_modifier_nonmonotonic |                    \
+                            kmp_sch_modifier_monotonic)))
 #define SCHEDULE_SET_MODIFIERS(s, m)                                           \
   (s = (enum sched_type)((kmp_int32)s | (kmp_int32)m))
 #define SCHEDULE_NONMONOTONIC 0
 #define SCHEDULE_MONOTONIC 1
 
   kmp_sch_default = kmp_sch_static /**< default scheduling algorithm */
 };
 

 #if KMP_USE_MONITOR
 #define KMP_DEFAULT_MONITOR_STKSIZE ((size_t)(64 * 1024))
 #define KMP_MIN_MONITOR_WAKEUPS (1) // min times monitor wakes up per second
 #define KMP_MAX_MONITOR_WAKEUPS (1000) // max times monitor can wake up per sec
 
 /* Calculate new number of monitor wakeups for a specific block time based on
    previous monitor_wakeups. Only allow increasing number of wakeups */
 #define KMP_WAKEUPS_FROM_BLOCKTIME(blocktime, monitor_wakeups)                 \
-  (((blocktime) == KMP_MAX_BLOCKTIME)                                          \
-       ? (monitor_wakeups)                                                     \
-       : ((blocktime) == KMP_MIN_BLOCKTIME)                                    \
-             ? KMP_MAX_MONITOR_WAKEUPS                                         \
-             : ((monitor_wakeups) > (KMP_BLOCKTIME_MULTIPLIER / (blocktime)))  \
-                   ? (monitor_wakeups)                                         \
-                   : (KMP_BLOCKTIME_MULTIPLIER) / (blocktime))
+  (((blocktime) == KMP_MAX_BLOCKTIME)   ? (monitor_wakeups)                    \
+   : ((blocktime) == KMP_MIN_BLOCKTIME) ? KMP_MAX_MONITOR_WAKEUPS              \
+   : ((monitor_wakeups) > (KMP_BLOCKTIME_MULTIPLIER / (blocktime)))            \
+       ? (monitor_wakeups)                                                     \
 
 /* Calculate number of intervals for a specific block time based on
    monitor_wakeups */
 #define KMP_INTERVALS_FROM_BLOCKTIME(blocktime, monitor_wakeups)               \
   (((blocktime) + (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)) - 1) /        \
    (KMP_BLOCKTIME_MULTIPLIER / (monitor_wakeups)))
 #else
 #define KMP_BLOCKTIME(team, tid)                                               \

 #if KMP_HAVE_WAITPKG_INTRINSICS
 #if KMP_HAVE_IMMINTRIN_H
 #include <immintrin.h>
 #elif KMP_HAVE_INTRIN_H
 #include <intrin.h>
 #endif
 #endif // KMP_HAVE_WAITPKG_INTRINSICS
 KMP_ATTRIBUTE_TARGET_WAITPKG
-static inline int
-__kmp_tpause(uint32_t hint, uint64_t counter) {
+static inline int __kmp_tpause(uint32_t hint, uint64_t counter) {
 #if !KMP_HAVE_WAITPKG_INTRINSICS
   uint32_t timeHi = uint32_t(counter >> 32);
   uint32_t timeLo = uint32_t(counter & 0xffffffff);
   char flag;
   __asm__ volatile("#tpause\n.byte 0x66, 0x0F, 0xAE, 0xF1\n"
                    "setb   %0"
                    : "=r"(flag)
                    : "a"(timeLo), "d"(timeHi), "c"(hint)
                    :);
   return flag;
 #else
   return _tpause(hint, counter);
 #endif
 }
 KMP_ATTRIBUTE_TARGET_WAITPKG
-static inline void
-__kmp_umonitor(void *cacheline) {
+static inline void __kmp_umonitor(void *cacheline) {
 #if !KMP_HAVE_WAITPKG_INTRINSICS
   __asm__ volatile("# umonitor\n.byte 0xF3, 0x0F, 0xAE, 0x01 "
                    :
                    : "a"(cacheline)
                    :);
 #else
   _umonitor(cacheline);
 #endif
 }
 KMP_ATTRIBUTE_TARGET_WAITPKG
-static inline int
-__kmp_umwait(uint32_t hint, uint64_t counter) {
+static inline int __kmp_umwait(uint32_t hint, uint64_t counter) {
 #if !KMP_HAVE_WAITPKG_INTRINSICS
   uint32_t timeHi = uint32_t(counter >> 32);
   uint32_t timeLo = uint32_t(counter & 0xffffffff);
   char flag;
   __asm__ volatile("#umwait\n.byte 0xF2, 0x0F, 0xAE, 0xF1\n"
                    "setb   %0"
                    : "=r"(flag)
                    : "a"(timeLo), "d"(timeHi), "c"(hint)

 #define bs_reduction_barrier bs_plain_barrier
 #endif // KMP_FAST_REDUCTION_BARRIER
 
 typedef enum kmp_bar_pat { /* Barrier communication patterns */
                            bp_linear_bar =
                                0, /* Single level (degenerate) tree */
                            bp_tree_bar =
                                1, /* Balanced tree with branching factor 2^n */
-                           bp_hyper_bar =
-                               2, /* Hypercube-embedded tree with min branching
-                                     factor 2^n */
+                           bp_hyper_bar = 2, /* Hypercube-embedded tree with min
+                                                branching factor 2^n */
                            bp_hierarchical_bar = 3, /* Machine hierarchy tree */
                            bp_last_bar /* Placeholder to mark the end */
 } kmp_bar_pat_e;
 
 #define KMP_BARRIER_ICV_PUSH 1
 
 /* Record for holding the values of the internal controls stack records */
 typedef struct kmp_internal_control {

 typedef union KMP_ALIGN_CACHE kmp_info {
   double th_align; /* use worst case alignment */
   char th_pad[KMP_PAD(kmp_base_info_t, CACHE_LINE)];
   kmp_base_info_t th;
 } kmp_info_t;
 
 // OpenMP thread team data structures
 
-typedef struct kmp_base_data { volatile kmp_uint32 t_value; } kmp_base_data_t;
+typedef struct kmp_base_data {
+  volatile kmp_uint32 t_value;
+} kmp_base_data_t;
 
 typedef union KMP_ALIGN_CACHE kmp_sleep_team {
   double dt_align; /* use worst case alignment */
   char dt_pad[KMP_PAD(kmp_base_data_t, CACHE_LINE)];
   kmp_base_data_t dt;
 } kmp_sleep_team_t;
 
 typedef union KMP_ALIGN_CACHE kmp_ordered_team {

 #endif /* KMP_ADJUST_BLOCKTIME */
 #ifdef KMP_DFLT_NTH_CORES
 extern int __kmp_ncores; /* Total number of cores for threads placement */
 #endif
 /* Number of millisecs to delay on abort for Intel(R) VTune(TM) tools */
 extern int __kmp_abort_delay;
 
 extern int __kmp_need_register_atfork_specified;
-extern int
-    __kmp_need_register_atfork; /* At initialization, call pthread_atfork to
-                                   install fork handler */
+extern int __kmp_need_register_atfork; /* At initialization, call pthread_atfork
+                                          to install fork handler */
 extern int __kmp_gtid_mode; /* Method of getting gtid, values:
                                0 - not set, will be set at runtime
                                1 - using stack search
                                2 - dynamic TLS (pthread_getspecific(Linux* OS/OS
                                    X*) or TlsGetValue(Windows* OS))
                                3 - static TLS (__declspec(thread) __kmp_gtid),
                                    Linux* OS .so only.  */
 extern int
extern void __kmp_wait_4_ptr(void *spinner, kmp_uint32 checker,
                              kmp_uint32 (*pred)(void *, kmp_uint32), void *obj);
 
 extern void __kmp_wait_64(kmp_info_t *this_thr, kmp_flag_64<> *flag,
                           int final_spin
 #if USE_ITT_BUILD
                           ,
                           void *itt_sync_obj
 #endif
-                          );
 extern void __kmp_release_64(kmp_flag_64<> *flag);
 
 extern void __kmp_infinite_loop(void);
 
 extern void __kmp_cleanup(void);
 
 #if KMP_HANDLE_SIGNALS
 extern int __kmp_handle_signals;

 //
 
 extern int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int npr, int argc,
                                   void *argv[]
 #if OMPT_SUPPORT
                                   ,
                                   void **exit_frame_ptr
 #endif
-                                  );
 
 /* ------------------------------------------------------------------------ */
 
 KMP_EXPORT void __kmpc_begin(ident_t *, kmp_int32 flags);
 KMP_EXPORT void __kmpc_end(ident_t *);
 
 KMP_EXPORT void __kmpc_threadprivate_register_vec(ident_t *, void *data,
                                                   kmpc_ctor_vec ctor,

 /* OMP 3.0 tasking interface routines */
 KMP_EXPORT kmp_int32 __kmpc_omp_task(ident_t *loc_ref, kmp_int32 gtid,
                                      kmp_task_t *new_task);
 KMP_EXPORT kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
                                              kmp_int32 flags,
                                              size_t sizeof_kmp_task_t,
                                              size_t sizeof_shareds,
                                              kmp_routine_entry_t task_entry);
-KMP_EXPORT kmp_task_t *__kmpc_omp_target_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
-                                                    kmp_int32 flags,
-                                                    size_t sizeof_kmp_task_t,
-                                                    size_t sizeof_shareds,
-                                                    kmp_routine_entry_t task_entry,
-                                                    kmp_int64 device_id);
+KMP_EXPORT kmp_task_t *__kmpc_omp_target_task_alloc(
+    ident_t *loc_ref, kmp_int32 gtid, kmp_int32 flags, size_t sizeof_kmp_task_t,
+    size_t sizeof_shareds, kmp_routine_entry_t task_entry, kmp_int64 device_id);
 KMP_EXPORT void __kmpc_omp_task_begin_if0(ident_t *loc_ref, kmp_int32 gtid,
                                           kmp_task_t *task);
 KMP_EXPORT void __kmpc_omp_task_complete_if0(ident_t *loc_ref, kmp_int32 gtid,
                                              kmp_task_t *task);
 KMP_EXPORT kmp_int32 __kmpc_omp_task_parts(ident_t *loc_ref, kmp_int32 gtid,
                                            kmp_task_t *new_task);
 KMP_EXPORT kmp_int32 __kmpc_omp_taskwait(ident_t *loc_ref, kmp_int32 gtid);
 

openmp/runtime/src/kmp_affinity.h

public:
     }
     int get_system_affinity(bool abort_on_error) override {
       KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
                   "Illegal get affinity operation when not capable");
 #if KMP_OS_LINUX
       long retval =
           syscall(__NR_sched_getaffinity, 0, __kmp_affin_mask_size, mask);
 #elif KMP_OS_FREEBSD
-      int r =
-          pthread_getaffinity_np(pthread_self(), __kmp_affin_mask_size, reinterpret_cast<cpuset_t *>(mask));
+      int r = pthread_getaffinity_np(pthread_self(), __kmp_affin_mask_size,
+                                     reinterpret_cast<cpuset_t *>(mask));
       int retval = (r == 0 ? 0 : -1);
 #endif
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
         __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);
       }
       return error;
     }
     int set_system_affinity(bool abort_on_error) const override {
       KMP_ASSERT2(KMP_AFFINITY_CAPABLE(),
                   "Illegal set affinity operation when not capable");
 #if KMP_OS_LINUX
       long retval =
           syscall(__NR_sched_setaffinity, 0, __kmp_affin_mask_size, mask);
 #elif KMP_OS_FREEBSD
-      int r =
-          pthread_setaffinity_np(pthread_self(), __kmp_affin_mask_size, reinterpret_cast<cpuset_t *>(mask));
+      int r = pthread_setaffinity_np(pthread_self(), __kmp_affin_mask_size,
+                                     reinterpret_cast<cpuset_t *>(mask));
       int retval = (r == 0 ? 0 : -1);
 #endif
       if (retval >= 0) {
         return 0;
       }
       int error = errno;
       if (abort_on_error) {
         __kmp_fatal(KMP_MSG(FatalSysError), KMP_ERR(error), __kmp_msg_null);

openmp/runtime/src/kmp_affinity.cpp

 // HWLOC_OBJ_PU, then this will return the number of PU's under the SOCKET
 // object.
 static int __kmp_hwloc_get_nobjs_under_obj(hwloc_obj_t obj,
                                            hwloc_obj_type_t type) {
   int retval = 0;
   hwloc_obj_t first;
   for (first = hwloc_get_obj_below_by_type(__kmp_hwloc_topology, obj->type,
                                            obj->logical_index, type, 0);
-       first != NULL &&
-       hwloc_get_ancestor_obj_by_type(__kmp_hwloc_topology, obj->type, first) ==
-           obj;
+       first != NULL && hwloc_get_ancestor_obj_by_type(__kmp_hwloc_topology,
+                                                       obj->type, first) == obj;
        first = hwloc_get_next_obj_by_type(__kmp_hwloc_topology, first->type,
                                           first)) {
     ++retval;
   }
   return retval;
 }
 
 static int __kmp_hwloc_count_children_by_depth(hwloc_topology_t t,
static void __kmp_dispatch_set_hierarchy_values() {
   // Set the maximum number of L1's to number of cores
   // Set the maximum number of L2's to to either number of cores / 2 for
   // Intel(R) Xeon Phi(TM) coprocessor formally codenamed Knights Landing
   // Or the number of cores for Intel(R) Xeon(R) processors
   // Set the maximum number of NUMA nodes and L3's to number of packages
   __kmp_hier_max_units[kmp_hier_layer_e::LAYER_THREAD + 1] =
       nPackages * nCoresPerPkg * __kmp_nThreadsPerCore;
   __kmp_hier_max_units[kmp_hier_layer_e::LAYER_L1 + 1] = __kmp_ncores;
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS) && \
+#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS) &&   \
     KMP_MIC_SUPPORTED
   if (__kmp_mic_type >= mic3)
     __kmp_hier_max_units[kmp_hier_layer_e::LAYER_L2 + 1] = __kmp_ncores / 2;
   else
 #endif // KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
     __kmp_hier_max_units[kmp_hier_layer_e::LAYER_L2 + 1] = __kmp_ncores;
   __kmp_hier_max_units[kmp_hier_layer_e::LAYER_L3 + 1] = nPackages;
   __kmp_hier_max_units[kmp_hier_layer_e::LAYER_NUMA + 1] = nPackages;
   __kmp_hier_max_units[kmp_hier_layer_e::LAYER_LOOP + 1] = 1;
   // Set the number of threads per unit
   // Number of hardware threads per L1/L2/L3/NUMA/LOOP
   __kmp_hier_threads_per[kmp_hier_layer_e::LAYER_THREAD + 1] = 1;
   __kmp_hier_threads_per[kmp_hier_layer_e::LAYER_L1 + 1] =
       __kmp_nThreadsPerCore;
-#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS) && \
+#if KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_FREEBSD || KMP_OS_WINDOWS) &&   \
     KMP_MIC_SUPPORTED
   if (__kmp_mic_type >= mic3)
     __kmp_hier_threads_per[kmp_hier_layer_e::LAYER_L2 + 1] =
         2 * __kmp_nThreadsPerCore;
   else
 #endif // KMP_ARCH_X86_64 && (KMP_OS_LINUX || KMP_OS_WINDOWS)
     __kmp_hier_threads_per[kmp_hier_layer_e::LAYER_L2 + 1] =
         __kmp_nThreadsPerCore;
for (int i = 0; i < nPackages; ++i) {
               n_old++;
               ++proc_num;
             }
           }
         }
       }
     }
     KMP_DEBUG_ASSERT(n_old == nPackages * nCoresPerPkg * __kmp_nThreadsPerCore);
-    KMP_DEBUG_ASSERT(n_new ==
-                     __kmp_hws_socket.num * __kmp_hws_core.num *
+    KMP_DEBUG_ASSERT(n_new == __kmp_hws_socket.num * __kmp_hws_core.num *
                                   __kmp_hws_proc.num);
     nPackages = __kmp_hws_socket.num; // correct nPackages
     nCoresPerPkg = __kmp_hws_core.num; // correct nCoresPerPkg
     __kmp_nThreadsPerCore = __kmp_hws_proc.num; // correct __kmp_nThreadsPerCore
     __kmp_avail_proc = n_new; // correct avail_proc
     __kmp_ncores = nPackages * __kmp_hws_core.num; // correct ncores
   } // non-hwloc topology method
   if (pAddr) {
     __kmp_free(*pAddr);
else if (__kmp_affinity_top_method == affinity_top_method_hwloc) {
     }
     depth = __kmp_affinity_create_hwloc_map(&address2os, &msg_id);
     if (depth == 0) {
       KMP_EXIT_AFF_NONE;
     }
   }
 #endif // KMP_USE_HWLOC
 
-// If the user has specified that a particular topology discovery method is to be
-// used, then we abort if that method fails. The exception is group affinity,
-// which might have been implicitly set.
+  // If the user has specified that a particular topology discovery method is to
+  // be used, then we abort if that method fails. The exception is group
+  // affinity, which might have been implicitly set.
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 
   else if (__kmp_affinity_top_method == affinity_top_method_x2apicid) {
     if (__kmp_affinity_verbose) {
       KMP_INFORM(AffInfoStr, "KMP_AFFINITY", KMP_I18N_STR(Decodingx2APIC));
     }
 
if (address2os == NULL) {
     KMP_AFFINITY_DISABLE();
     return;
   }
 
   if (__kmp_affinity_gran == affinity_gran_tile
 #if KMP_USE_HWLOC
       && __kmp_tile_depth == 0
 #endif
-      ) {
     // tiles requested but not detected, warn user on this
     KMP_WARNING(AffTilesNoTiles, "KMP_AFFINITY");
   }
 
   __kmp_apply_thread_places(&address2os, depth);
 
   // Create the table of masks, indexed by thread Id.
   unsigned maxIndex;
if (__kmp_affinity_num_masks == 0) {
         KMP_WARNING(AffNoValidProcID);
       }
       __kmp_affinity_type = affinity_none;
       __kmp_create_affinity_none_places();
       return;
     }
     break;
 
     // The other affinity types rely on sorting the Addresses according to some
     // permutation of the machine topology tree. Set __kmp_affinity_compact and
     // __kmp_affinity_offset appropriately, then jump to a common code fragment
     // to do the sort and create the array of affinity masks.
 
   case affinity_logical:
     __kmp_affinity_compact = 0;
     if (__kmp_affinity_offset) {
       __kmp_affinity_offset =
           __kmp_nThreadsPerCore * __kmp_affinity_offset % __kmp_avail_proc;
     }
     goto sortAddresses;
int __kmp_aux_set_affinity(void **mask) {
   kmp_info_t *th;
   int retval;
 
   if (!KMP_AFFINITY_CAPABLE()) {
     return -1;
   }
 
   gtid = __kmp_entry_gtid();
-  KA_TRACE(1000, (""); {
+  KA_TRACE(
+      1000, (""); {
         char buf[KMP_AFFIN_MASK_PRINT_LEN];
         __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
                                   (kmp_affin_mask_t *)(*mask));
         __kmp_debug_printf(
-        "kmp_set_affinity: setting affinity mask for thread %d = %s\n", gtid,
-        buf);
+            "kmp_set_affinity: setting affinity mask for thread %d = %s\n",
+            gtid, buf);
       });
 
   if (__kmp_env_consistency_check) {
     if ((mask == NULL) || (*mask == NULL)) {
       KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity");
     } else {
       unsigned proc;
       int num_procs = 0;
 
int __kmp_aux_get_affinity(void **mask) {
   if (!KMP_AFFINITY_CAPABLE()) {
     return -1;
   }
 
   gtid = __kmp_entry_gtid();
   th = __kmp_threads[gtid];
   KMP_DEBUG_ASSERT(th->th.th_affin_mask != NULL);
 
-  KA_TRACE(1000, (""); {
+  KA_TRACE(
+      1000, (""); {
         char buf[KMP_AFFIN_MASK_PRINT_LEN];
         __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
                                   th->th.th_affin_mask);
-    __kmp_printf("kmp_get_affinity: stored affinity mask for thread %d = %s\n",
-                 gtid, buf);
+        __kmp_printf(
+            "kmp_get_affinity: stored affinity mask for thread %d = %s\n", gtid,
+            buf);
       });
 
   if (__kmp_env_consistency_check) {
     if ((mask == NULL) || (*mask == NULL)) {
       KMP_FATAL(AffinityInvalidMask, "kmp_get_affinity");
     }
   }
 
 #if !KMP_OS_WINDOWS
 
   retval = __kmp_get_system_affinity((kmp_affin_mask_t *)(*mask), FALSE);
-  KA_TRACE(1000, (""); {
+  KA_TRACE(
+      1000, (""); {
         char buf[KMP_AFFIN_MASK_PRINT_LEN];
         __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
                                   (kmp_affin_mask_t *)(*mask));
-    __kmp_printf("kmp_get_affinity: system affinity mask for thread %d = %s\n",
-                 gtid, buf);
+        __kmp_printf(
+            "kmp_get_affinity: system affinity mask for thread %d = %s\n", gtid,
+            buf);
       });
   return retval;
 
 #else
 
   KMP_CPU_COPY((kmp_affin_mask_t *)(*mask), th->th.th_affin_mask);
   return 0;
 
 #endif /* KMP_OS_WINDOWS */
#endif
   return __kmp_xproc;
 }
 
 int __kmp_aux_set_affinity_mask_proc(int proc, void **mask) {
   if (!KMP_AFFINITY_CAPABLE()) {
     return -1;
   }
 
-  KA_TRACE(1000, (""); {
+  KA_TRACE(
+      1000, (""); {
         int gtid = __kmp_entry_gtid();
         char buf[KMP_AFFIN_MASK_PRINT_LEN];
         __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
                                   (kmp_affin_mask_t *)(*mask));
         __kmp_debug_printf("kmp_set_affinity_mask_proc: setting proc %d in "
                            "affinity mask for thread %d = %s\n",
                            proc, gtid, buf);
       });
 
   if (__kmp_env_consistency_check) {
     if ((mask == NULL) || (*mask == NULL)) {
       KMP_FATAL(AffinityInvalidMask, "kmp_set_affinity_mask_proc");
     }
   }
 
   if ((proc < 0) || (proc >= __kmp_aux_get_affinity_max_proc())) {
     return -1;
   }
   if (!KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
     return -2;
   }
 
   KMP_CPU_SET(proc, (kmp_affin_mask_t *)(*mask));
   return 0;
 }
 
 int __kmp_aux_unset_affinity_mask_proc(int proc, void **mask) {
   if (!KMP_AFFINITY_CAPABLE()) {
     return -1;
   }
 
-  KA_TRACE(1000, (""); {
+  KA_TRACE(
+      1000, (""); {
         int gtid = __kmp_entry_gtid();
         char buf[KMP_AFFIN_MASK_PRINT_LEN];
         __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
                                   (kmp_affin_mask_t *)(*mask));
         __kmp_debug_printf("kmp_unset_affinity_mask_proc: unsetting proc %d in "
                            "affinity mask for thread %d = %s\n",
                            proc, gtid, buf);
       });
 
   if (__kmp_env_consistency_check) {
     if ((mask == NULL) || (*mask == NULL)) {
       KMP_FATAL(AffinityInvalidMask, "kmp_unset_affinity_mask_proc");
     }
   }
 
   if ((proc < 0) || (proc >= __kmp_aux_get_affinity_max_proc())) {
     return -1;
   }
   if (!KMP_CPU_ISSET(proc, __kmp_affin_fullMask)) {
     return -2;
   }
 
   KMP_CPU_CLR(proc, (kmp_affin_mask_t *)(*mask));
   return 0;
 }
 
 int __kmp_aux_get_affinity_mask_proc(int proc, void **mask) {
   if (!KMP_AFFINITY_CAPABLE()) {
     return -1;
   }
 
-  KA_TRACE(1000, (""); {
+  KA_TRACE(
+      1000, (""); {
         int gtid = __kmp_entry_gtid();
         char buf[KMP_AFFIN_MASK_PRINT_LEN];
         __kmp_affinity_print_mask(buf, KMP_AFFIN_MASK_PRINT_LEN,
                                   (kmp_affin_mask_t *)(*mask));
         __kmp_debug_printf("kmp_get_affinity_mask_proc: getting proc %d in "
                            "affinity mask for thread %d = %s\n",
                            proc, gtid, buf);
       });
 
   if (__kmp_env_consistency_check) {
     if ((mask == NULL) || (*mask == NULL)) {
       KMP_FATAL(AffinityInvalidMask, "kmp_get_affinity_mask_proc");
     }
   }
 
   if ((proc < 0) || (proc >= __kmp_aux_get_affinity_max_proc())) {

openmp/runtime/src/kmp_alloc.cpp

 }
 
 /* Chain together the free buffers by using the thread owner field */
 static void __kmp_bget_enqueue(kmp_info_t *th, void *buf
 #ifdef USE_QUEUING_LOCK_FOR_BGET
                                ,
                                kmp_int32 rel_gtid
 #endif
-                               ) {
   bfhead_t *b = BFH(((char *)buf) - sizeof(bhead_t));
 
   KMP_DEBUG_ASSERT(b->bh.bb.bsize != 0);
   KMP_DEBUG_ASSERT(((kmp_uintptr_t)TCR_PTR(b->bh.bb.bthr) & ~1) ==
                    (kmp_uintptr_t)th); // clear possible mark
 
   b->ql.blink = 0;
 
bth = (kmp_info_t *)((kmp_uintptr_t)TCR_PTR(b->bh.bb.bthr) &
                        ~1); // clear possible mark before comparison
   if (bth != th) {
     /* Add this buffer to be released by the owning thread later */
     __kmp_bget_enqueue(bth, buf
 #ifdef USE_QUEUING_LOCK_FOR_BGET
                        ,
                        __kmp_gtid_from_thread(th)
 #endif
-                           );
     return;
   }
 
   /* Buffer size must be negative, indicating that the buffer is allocated. */
   if (b->bh.bb.bsize >= 0) {
     bn = NULL;
   }
   KMP_DEBUG_ASSERT(b->bh.bb.bsize < 0);
void *___kmp_fast_allocate(kmp_info_t *this_thr, size_t size KMP_SRC_LOC_DECL) {
   } else {
     goto alloc_call; // 65 or more cache lines ( > 8KB ), don't use free lists
   }
 
   ptr = this_thr->th.th_free_lists[index].th_free_list_self;
   if (ptr != NULL) {
     // pop the head of no-sync free list
     this_thr->th.th_free_lists[index].th_free_list_self = *((void **)ptr);
-    KMP_DEBUG_ASSERT(
-        this_thr ==
-        ((kmp_mem_descr_t *)((kmp_uintptr_t)ptr - sizeof(kmp_mem_descr_t)))
+    KMP_DEBUG_ASSERT(this_thr == ((kmp_mem_descr_t *)((kmp_uintptr_t)ptr -
+                                                      sizeof(kmp_mem_descr_t)))
                                      ->ptr_aligned);
     goto end;
   }
   ptr = TCR_SYNC_PTR(this_thr->th.th_free_lists[index].th_free_list_sync);
   if (ptr != NULL) {
     // no-sync free list is empty, use sync free list (filled in by other
     // threads only)
     // pop the head of the sync free list, push NULL instead
     while (!KMP_COMPARE_AND_STORE_PTR(
         &this_thr->th.th_free_lists[index].th_free_list_sync, ptr, nullptr)) {
       KMP_CPU_PAUSE();
       ptr = TCR_SYNC_PTR(this_thr->th.th_free_lists[index].th_free_list_sync);
     }
     // push the rest of chain into no-sync free list (can be NULL if there was
     // the only block)
     this_thr->th.th_free_lists[index].th_free_list_self = *((void **)ptr);
-    KMP_DEBUG_ASSERT(
-        this_thr ==
-        ((kmp_mem_descr_t *)((kmp_uintptr_t)ptr - sizeof(kmp_mem_descr_t)))
+    KMP_DEBUG_ASSERT(this_thr == ((kmp_mem_descr_t *)((kmp_uintptr_t)ptr -
+                                                      sizeof(kmp_mem_descr_t)))
                                      ->ptr_aligned);
     goto end;
   }
 
 alloc_call:
   // haven't found block in the free lists, thus allocate it
   size = num_lines * DCACHE_LINE;
 
   alloc_size = size + sizeof(kmp_mem_descr_t) + DCACHE_LINE;

openmp/runtime/src/kmp_atomic.h

 // Atomic locks can easily become contended, so we use queuing locks for them.
 typedef kmp_queuing_lock_t kmp_atomic_lock_t;
 
 static inline void __kmp_acquire_atomic_lock(kmp_atomic_lock_t *lck,
                                              kmp_int32 gtid) {
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_mutex_acquire) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquire)(
-        ompt_mutex_atomic, 0, kmp_mutex_impl_queuing, (ompt_wait_id_t)(uintptr_t)lck,
-        OMPT_GET_RETURN_ADDRESS(0));
+        ompt_mutex_atomic, 0, kmp_mutex_impl_queuing,
+        (ompt_wait_id_t)(uintptr_t)lck, OMPT_GET_RETURN_ADDRESS(0));
   }
 #endif
 
   __kmp_acquire_queuing_lock(lck, gtid);
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_mutex_acquired) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
-        ompt_mutex_atomic, (ompt_wait_id_t)(uintptr_t)lck, OMPT_GET_RETURN_ADDRESS(0));
+        ompt_mutex_atomic, (ompt_wait_id_t)(uintptr_t)lck,
+        OMPT_GET_RETURN_ADDRESS(0));
   }
 #endif
 }
 
 static inline int __kmp_test_atomic_lock(kmp_atomic_lock_t *lck,
                                          kmp_int32 gtid) {
   return __kmp_test_queuing_lock(lck, gtid);
 }
 
 static inline void __kmp_release_atomic_lock(kmp_atomic_lock_t *lck,
                                              kmp_int32 gtid) {
   __kmp_release_queuing_lock(lck, gtid);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.ompt_callback_mutex_released) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_released)(
-        ompt_mutex_atomic, (ompt_wait_id_t)(uintptr_t)lck, OMPT_GET_RETURN_ADDRESS(0));
+        ompt_mutex_atomic, (ompt_wait_id_t)(uintptr_t)lck,
+        OMPT_GET_RETURN_ADDRESS(0));
   }
 #endif
 }
 
 static inline void __kmp_init_atomic_lock(kmp_atomic_lock_t *lck) {
   __kmp_init_queuing_lock(lck);
 }
 

openmp/runtime/src/kmp_atomic.cpp

void __kmpc_atomic_1(ident_t *id_ref, int gtid, void *lhs, void *rhs,
   KMP_DEBUG_ASSERT(__kmp_init_serial);
 
   if (
 #if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
       FALSE /* must use lock */
 #else
       TRUE
 #endif // KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
-      ) {
     kmp_int8 old_value, new_value;
 
     old_value = *(kmp_int8 *)lhs;
     (*f)(&new_value, &old_value, rhs);
 
     /* TODO: Should this be acquire or release? */
     while (!KMP_COMPARE_AND_STORE_ACQ8((kmp_int8 *)lhs, *(kmp_int8 *)&old_value,
                                        *(kmp_int8 *)&new_value)) {
       KMP_CPU_PAUSE();
 
       old_value = *(kmp_int8 *)lhs;
       (*f)(&new_value, &old_value, rhs);
     }
 
     return;
   } else {
     // All 1-byte data is of integer data type.
 
 #ifdef KMP_GOMP_COMPAT
     if (__kmp_atomic_mode == 2) {
       __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
     } else
 #endif /* KMP_GOMP_COMPAT */
       __kmp_acquire_atomic_lock(&__kmp_atomic_lock_1i, gtid);
 
void __kmpc_atomic_2(ident_t *id_ref, int gtid, void *lhs, void *rhs,
   if (
 #if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
       FALSE /* must use lock */
 #elif KMP_ARCH_X86 || KMP_ARCH_X86_64
       TRUE /* no alignment problems */
 #else
       !((kmp_uintptr_t)lhs & 0x1) /* make sure address is 2-byte aligned */
 #endif // KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
-      ) {
     kmp_int16 old_value, new_value;
 
     old_value = *(kmp_int16 *)lhs;
     (*f)(&new_value, &old_value, rhs);
 
     /* TODO: Should this be acquire or release? */
     while (!KMP_COMPARE_AND_STORE_ACQ16(
         (kmp_int16 *)lhs, *(kmp_int16 *)&old_value, *(kmp_int16 *)&new_value)) {
       KMP_CPU_PAUSE();
 
       old_value = *(kmp_int16 *)lhs;
       (*f)(&new_value, &old_value, rhs);
     }
 
     return;
   } else {
     // All 2-byte data is of integer data type.
 
 #ifdef KMP_GOMP_COMPAT
     if (__kmp_atomic_mode == 2) {
       __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
     } else
 #endif /* KMP_GOMP_COMPAT */
       __kmp_acquire_atomic_lock(&__kmp_atomic_lock_2i, gtid);
 
void __kmpc_atomic_4(ident_t *id_ref, int gtid, void *lhs, void *rhs,
   if (
 // FIXME: On IA-32 architecture, gcc uses cmpxchg only for 4-byte ints.
 // Gomp compatibility is broken if this routine is called for floats.
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
       TRUE /* no alignment problems */
 #else
       !((kmp_uintptr_t)lhs & 0x3) /* make sure address is 4-byte aligned */
 #endif // KMP_ARCH_X86 || KMP_ARCH_X86_64
-      ) {
     kmp_int32 old_value, new_value;
 
     old_value = *(kmp_int32 *)lhs;
     (*f)(&new_value, &old_value, rhs);
 
     /* TODO: Should this be acquire or release? */
     while (!KMP_COMPARE_AND_STORE_ACQ32(
         (kmp_int32 *)lhs, *(kmp_int32 *)&old_value, *(kmp_int32 *)&new_value)) {
       KMP_CPU_PAUSE();
 
       old_value = *(kmp_int32 *)lhs;
       (*f)(&new_value, &old_value, rhs);
     }
 
     return;
   } else {
     // Use __kmp_atomic_lock_4i for all 4-byte data,
     // even if it isn't of integer data type.
 
 #ifdef KMP_GOMP_COMPAT
     if (__kmp_atomic_mode == 2) {
       __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
     } else
 #endif /* KMP_GOMP_COMPAT */
       __kmp_acquire_atomic_lock(&__kmp_atomic_lock_4i, gtid);
 

 
 #if KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
       FALSE /* must use lock */
 #elif KMP_ARCH_X86 || KMP_ARCH_X86_64
       TRUE /* no alignment problems */
 #else
       !((kmp_uintptr_t)lhs & 0x7) /* make sure address is 8-byte aligned */
 #endif // KMP_ARCH_X86 && defined(KMP_GOMP_COMPAT)
-      ) {
     kmp_int64 old_value, new_value;
 
     old_value = *(kmp_int64 *)lhs;
     (*f)(&new_value, &old_value, rhs);
     /* TODO: Should this be acquire or release? */
     while (!KMP_COMPARE_AND_STORE_ACQ64(
         (kmp_int64 *)lhs, *(kmp_int64 *)&old_value, *(kmp_int64 *)&new_value)) {
       KMP_CPU_PAUSE();
 
       old_value = *(kmp_int64 *)lhs;
       (*f)(&new_value, &old_value, rhs);
     }
 
     return;
   } else {
     // Use __kmp_atomic_lock_8i for all 8-byte data,
     // even if it isn't of integer data type.
 
 #ifdef KMP_GOMP_COMPAT
     if (__kmp_atomic_mode == 2) {
       __kmp_acquire_atomic_lock(&__kmp_atomic_lock, gtid);
     } else
 #endif /* KMP_GOMP_COMPAT */
       __kmp_acquire_atomic_lock(&__kmp_atomic_lock_8i, gtid);
 

openmp/runtime/src/kmp_barrier.cpp

#endif /* KMP_CACHE_MANAGE */
             ("__kmp_linear_barrier_release: T#%d(%d:%d) releasing T#%d(%d:%d) "
              "go(%p): %u => %u\n",
              gtid, team->t.t_id, tid, other_threads[i]->th.th_info.ds.ds_gtid,
              team->t.t_id, i, &other_threads[i]->th.th_bar[bt].bb.b_go,
              other_threads[i]->th.th_bar[bt].bb.b_go,
              other_threads[i]->th.th_bar[bt].bb.b_go + KMP_BARRIER_STATE_BUMP));
         ANNOTATE_BARRIER_BEGIN(other_threads[i]);
         kmp_flag_64<> flag(&other_threads[i]->th.th_bar[bt].bb.b_go,
                            other_threads[i]);
         flag.release();
       }
     }
   } else { // Wait for the MASTER thread to release us
     KA_TRACE(20, ("__kmp_linear_barrier_release: T#%d wait go(%p) == %u\n",
                   gtid, &thr_bar->b_go, KMP_BARRIER_STATE_BUMP));
     if (cancellable) {
       kmp_flag_64<true, false> flag(&thr_bar->b_go, KMP_BARRIER_STATE_BUMP);

 static bool __kmp_linear_barrier_release_cancellable(
     enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
     int propagate_icvs USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
   return __kmp_linear_barrier_release_template<true>(
       bt, this_thr, gtid, tid, propagate_icvs USE_ITT_BUILD_ARG(itt_sync_obj));
 }
 
 // Tree barrier
-static void
-__kmp_tree_barrier_gather(enum barrier_type bt, kmp_info_t *this_thr, int gtid,
-                          int tid, void (*reduce)(void *, void *)
-                                       USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
+static void __kmp_tree_barrier_gather(
+    enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
+    void (*reduce)(void *, void *) USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
   KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_tree_gather);
   kmp_team_t *team = this_thr->th.th_team;
   kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
   kmp_info_t **other_threads = team->t.t_threads;
   kmp_uint32 nproc = this_thr->th.th_team_nproc;
   kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
   kmp_uint32 branch_factor = 1 << branch_bits;
   kmp_uint32 child;
#endif // KMP_BARRIER_ICV_PUSH
     } while (child <= branch_factor && child_tid < nproc);
   }
   KA_TRACE(
       20, ("__kmp_tree_barrier_release: T#%d(%d:%d) exit for barrier type %d\n",
            gtid, team->t.t_id, tid, bt));
 }
 
 // Hyper Barrier
-static void
-__kmp_hyper_barrier_gather(enum barrier_type bt, kmp_info_t *this_thr, int gtid,
-                           int tid, void (*reduce)(void *, void *)
-                                        USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
+static void __kmp_hyper_barrier_gather(
+    enum barrier_type bt, kmp_info_t *this_thr, int gtid, int tid,
+    void (*reduce)(void *, void *) USE_ITT_BUILD_ARG(void *itt_sync_obj)) {
   KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(KMP_hyper_gather);
   kmp_team_t *team = this_thr->th.th_team;
   kmp_bstate_t *thr_bar = &this_thr->th.th_bar[bt].bb;
   kmp_info_t **other_threads = team->t.t_threads;
   kmp_uint64 new_state = KMP_BARRIER_UNUSED_STATE;
   kmp_uint32 num_threads = this_thr->th.th_team_nproc;
   kmp_uint32 branch_bits = __kmp_barrier_gather_branch_bits[bt];
   kmp_uint32 branch_factor = 1 << branch_bits;
#if OMPT_OPTIONAL
     if (ompt_enabled.ompt_callback_sync_region) {
       ompt_callbacks.ompt_callback(ompt_callback_sync_region)(
           ompt_sync_region_barrier_implicit, ompt_scope_end, NULL, task_data,
           codeptr);
     }
 #endif
     if (!KMP_MASTER_TID(ds_tid) && ompt_enabled.ompt_callback_implicit_task) {
       ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
-          ompt_scope_end, NULL, task_data, 0, ds_tid, ompt_task_implicit); // TODO: Can this be ompt_task_initial?
+          ompt_scope_end, NULL, task_data, 0, ds_tid,
+          ompt_task_implicit); // TODO: Can this be ompt_task_initial?
     }
   }
 #endif
 
   // Early exit for reaping threads releasing forkjoin barrier
   if (TCR_4(__kmp_global.g.g_done)) {
     this_thr->th.th_task_team = NULL;
 
#if KMP_AFFINITY_SUPPORTED
   }
 #endif // KMP_AFFINITY_SUPPORTED
   // Perform the display affinity functionality
   if (__kmp_display_affinity) {
     if (team->t.t_display_affinity
 #if KMP_AFFINITY_SUPPORTED
         || (__kmp_affinity_type == affinity_balanced && team->t.t_size_changed)
 #endif
-            ) {
       // NULL means use the affinity-format-var ICV
       __kmp_aux_display_affinity(gtid, NULL);
       this_thr->th.th_prev_num_threads = team->t.t_nproc;
       this_thr->th.th_prev_level = team->t.t_level;
     }
   }
   if (!KMP_MASTER_TID(tid))
     KMP_CHECK_UPDATE(this_thr->th.th_def_allocator, team->t.t_def_allocator);

openmp/runtime/src/kmp_csupport.cpp

 #if INCLUDE_SSC_MARKS
     SSC_MARK_JOINING();
 #endif
     __kmp_join_call(loc, gtid
 #if OMPT_SUPPORT
                     ,
                     fork_context_intel
 #endif
-                    );
 
     va_end(ap);
   }
 
 #if KMP_STATS_ENABLED
   if (previous_state == stats_state_e::SERIAL_REGION) {
     KMP_EXCHANGE_PARTITIONED_TIMER(OMP_serial);
     KMP_SET_THREAD_STATE(previous_state);
__kmp_fork_call(
       loc, gtid, fork_context_intel, argc,
       VOLATILE_CAST(microtask_t) __kmp_teams_master, // "wrapped" task
       VOLATILE_CAST(launch_t) __kmp_invoke_teams_master, kmp_va_addr_of(ap));
   __kmp_join_call(loc, gtid
 #if OMPT_SUPPORT
                   ,
                   fork_context_intel
 #endif
-                  );
 
   // Pop current CG root off list
   KMP_DEBUG_ASSERT(this_thr->th.th_cg_roots);
   kmp_cg_root_t *tmp = this_thr->th.th_cg_roots;
   this_thr->th.th_cg_roots = tmp->up;
   KA_TRACE(100, ("__kmpc_fork_teams: Thread %p popping node %p and moving up"
                  " to node %p. cg_nthreads was %d\n",
                  this_thr, tmp, this_thr->th.th_cg_roots, tmp->cg_nthreads));
serial_team->t.t_dispatch->th_disp_buffer =
         serial_team->t.t_dispatch->th_disp_buffer->next;
     __kmp_free(disp_buffer);
   }
   this_thr->th.th_def_allocator = serial_team->t.t_def_allocator; // restore
 
   --serial_team->t.t_serialized;
   if (serial_team->t.t_serialized == 0) {
 
     /* return to the parallel section */
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
     if (__kmp_inherit_fp_control && serial_team->t.t_fp_control_saved) {
       __kmp_clear_x87_fpu_status_word();
       __kmp_load_x87_fpu_control_word(&serial_team->t.t_x87_fpu_control_word);
       __kmp_load_mxcsr(&serial_team->t.t_mxcsr);
     }
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */

 #endif
   else { // ticket, queuing or drdpa
     lck = __kmp_get_critical_section_ptr(crit, loc, global_tid);
   }
 
   if (__kmp_env_consistency_check)
     __kmp_push_sync(global_tid, ct_critical, loc, lck);
 
     // since the critical directive binds to all threads, not just the current
     // team we have to check this even if we are in a serialized team.
     // also, even if we are the uber thread, we still have to conduct the lock,
     // as we have to contend with sibling threads.
 
 #if USE_ITT_BUILD
   __kmp_itt_critical_acquiring(lck);
 #endif /* USE_ITT_BUILD */
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
   void *codeptr_ra = NULL;
   if (ompt_enabled.enabled) {

 #if USE_ITT_NOTIFY
   __kmp_threads[gtid]->th.th_ident = loc;
 #endif
   __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 
   if (!didit)
     (*cpy_func)(cpy_data, *data_ptr);
 
   // Consider next barrier a user-visible barrier for barrier region boundaries
   // Nesting checks are already handled by the single construct checks
   {
 #if OMPT_SUPPORT
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 #if USE_ITT_NOTIFY
     __kmp_threads[gtid]->th.th_ident = loc; // TODO: check if it is needed (e.g.
 // tasks can overwrite the location)
 #endif
     __kmp_barrier(bs_plain_barrier, gtid, FALSE, 0, NULL, NULL);
 #if OMPT_SUPPORT && OMPT_OPTIONAL
     if (ompt_enabled.enabled) {
       ompt_frame->enter_frame = ompt_data_none;
     }
 #endif
   }
 }
 
 /* -------------------------------------------------------------------------- */
 
 #define INIT_LOCK __kmp_init_user_lock_with_checks
 #define INIT_NESTED_LOCK __kmp_init_nested_user_lock_with_checks
if (ompt_enabled.ompt_callback_mutex_acquire) {
           ompt_mutex_nest_lock, omp_lock_hint_none,
           __ompt_get_mutex_impl_type(user_lock),
           (ompt_wait_id_t)(uintptr_t)user_lock, codeptr);
     }
   }
 #endif
   int acquire_status =
       KMP_D_LOCK_FUNC(user_lock, set)((kmp_dyna_lock_t *)user_lock, gtid);
-  (void) acquire_status;
+  (void)acquire_status;
 #if USE_ITT_BUILD
   __kmp_itt_lock_acquired((kmp_user_lock_p)user_lock);
 #endif
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   if (ompt_enabled.enabled) {
     if (acquire_status == KMP_LOCK_ACQUIRED_FIRST) {
       if (ompt_enabled.ompt_callback_mutex_acquired) {

 void __kmpc_unset_nest_lock(ident_t *loc, kmp_int32 gtid, void **user_lock) {
 #if KMP_USE_DYNAMIC_LOCK
 
 #if USE_ITT_BUILD
   __kmp_itt_lock_releasing((kmp_user_lock_p)user_lock);
 #endif
   int release_status =
       KMP_D_LOCK_FUNC(user_lock, unset)((kmp_dyna_lock_t *)user_lock, gtid);
-  (void) release_status;
+  (void)release_status;
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   // This is the case, if called from omp_init_lock_with_hint:
   void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
   if (!codeptr)
     codeptr = OMPT_GET_RETURN_ADDRESS(0);
   if (ompt_enabled.enabled) {
     if (release_status == KMP_LOCK_RELEASED) {
#if OMPT_SUPPORT && OMPT_OPTIONAL
   if (rc && ompt_enabled.ompt_callback_mutex_acquired) {
     ompt_callbacks.ompt_callback(ompt_callback_mutex_acquired)(
         ompt_mutex_lock, (ompt_wait_id_t)(uintptr_t)lck, codeptr);
   }
 #endif
 
   return (rc ? FTN_TRUE : FTN_FALSE);
 
   /* Can't use serial interval since not block structured */
 
 #endif // KMP_USE_DYNAMIC_LOCK
 }
 
 /* try to acquire the lock */
 int __kmpc_test_nest_lock(ident_t *loc, kmp_int32 gtid, void **user_lock) {
 #if KMP_USE_DYNAMIC_LOCK
   int rc;
if (rc == 1) {
         ompt_callbacks.ompt_callback(ompt_callback_nest_lock)(
             ompt_mutex_scope_begin, (ompt_wait_id_t)(uintptr_t)lck, codeptr);
       }
     }
   }
 #endif
   return rc;
 
   /* Can't use serial interval since not block structured */
 
 #endif // KMP_USE_DYNAMIC_LOCK
 }
 
 // Interface to fast scalable reduce methods routines
 
 // keep the selected method in a thread local structure for cross-function
 // usage: will be used in __kmpc_end_reduce* functions;

openmp/runtime/src/kmp_dispatch.cpp

if (nproc > 1 && ntc >= nproc) {
         __kmp_init_lock(pr->u.p.th_steal_lock);
       }
       break;
     } else {
       /* too few chunks: switching to kmp_sch_dynamic_chunked */
       schedule = kmp_sch_dynamic_chunked;
       KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d switching to "
                      "kmp_sch_dynamic_chunked\n",
-                      gtid));
       if (pr->u.p.parm1 <= 0)
         pr->u.p.parm1 = KMP_DEFAULT_CHUNK;
       break;
     } // if
   } // case
 #endif
   case kmp_sch_static_balanced: {
     T init, limit;

 
 // C75803
 #if ((KMP_OS_LINUX || KMP_OS_WINDOWS) && KMP_ARCH_X86) && (!defined(KMP_I8))
 #define GUIDED_ANALYTICAL_WORKAROUND (*(DBL *)&pr->u.p.parm3)
 #else
 #define GUIDED_ANALYTICAL_WORKAROUND (x)
 #endif
         /* dynamic-style scheduling offset */
-        pr->u.p.count = tc - __kmp_dispatch_guided_remaining(
-                                 tc, GUIDED_ANALYTICAL_WORKAROUND, cross) -
+        pr->u.p.count = tc -
+                        __kmp_dispatch_guided_remaining(
                         cross * chunk;
 #if KMP_USE_X87CONTROL
         // restore FPCW
         _control87(oldFpcw, _MCW_PC);
 #endif
       } // if
     } else {
       KD_TRACE(100, ("__kmp_dispatch_init_algorithm: T#%d falling-through to "
case kmp_sch_trapezoidal: {
     pr->u.p.parm4 = parm4;
   } // case
   break;
 
   default: {
     __kmp_fatal(KMP_MSG(UnknownSchedTypeDetected), // Primary message
                 KMP_HNT(GetNewerLibrary), // Hint
                 __kmp_msg_null // Variadic argument list terminator
-                );
   } break;
   } // switch
   pr->schedule = schedule;
 }
 
 #if KMP_USE_HIER_SCHED
 template <typename T>
 inline void __kmp_dispatch_init_hier_runtime(ident_t *loc, T lb, T ub,
case kmp_sch_trapezoidal: {
     } // if
   } // case
   break;
   default: {
     status = 0; // to avoid complaints on uninitialized variable use
     __kmp_fatal(KMP_MSG(UnknownSchedTypeDetected), // Primary message
                 KMP_HNT(GetNewerLibrary), // Hint
                 __kmp_msg_null // Variadic argument list terminator
-                );
   } break;
   } // switch
   if (p_last)
     *p_last = last;
 #ifdef KMP_DEBUG
   if (pr->flags.ordered) {
     char *buff;
     // create format specifiers before the debug output

 template <typename T>
 static int __kmp_dispatch_next(ident_t *loc, int gtid, kmp_int32 *p_last,
                                T *p_lb, T *p_ub,
                                typename traits_t<T>::signed_t *p_st
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                ,
                                void *codeptr
 #endif
-                               ) {
 
   typedef typename traits_t<T>::unsigned_t UT;
   typedef typename traits_t<T>::signed_t ST;
   // This is potentially slightly misleading, schedule(runtime) will appear here
   // even if the actual runtime schedule is static. (Which points out a
   // disadvantage of schedule(runtime): even when static scheduling is used it
   // costs more than a compile time choice to use static scheduling would.)
   KMP_TIME_PARTITIONED_BLOCK(OMP_loop_dynamic_scheduling);

 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   return __kmp_dispatch_next<kmp_int32>(loc, gtid, p_last, p_lb, p_ub, p_st
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                         ,
                                         OMPT_LOAD_RETURN_ADDRESS(gtid)
 #endif
-                                            );
 }
 
 /*!
 See @ref __kmpc_dispatch_next_4
 */
 int __kmpc_dispatch_next_4u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
                             kmp_uint32 *p_lb, kmp_uint32 *p_ub,
                             kmp_int32 *p_st) {
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   return __kmp_dispatch_next<kmp_uint32>(loc, gtid, p_last, p_lb, p_ub, p_st
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                          ,
                                          OMPT_LOAD_RETURN_ADDRESS(gtid)
 #endif
-                                             );
 }
 
 /*!
 See @ref __kmpc_dispatch_next_4
 */
 int __kmpc_dispatch_next_8(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
                            kmp_int64 *p_lb, kmp_int64 *p_ub, kmp_int64 *p_st) {
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   return __kmp_dispatch_next<kmp_int64>(loc, gtid, p_last, p_lb, p_ub, p_st
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                         ,
                                         OMPT_LOAD_RETURN_ADDRESS(gtid)
 #endif
-                                            );
 }
 
 /*!
 See @ref __kmpc_dispatch_next_4
 */
 int __kmpc_dispatch_next_8u(ident_t *loc, kmp_int32 gtid, kmp_int32 *p_last,
                             kmp_uint64 *p_lb, kmp_uint64 *p_ub,
                             kmp_int64 *p_st) {
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
   return __kmp_dispatch_next<kmp_uint64>(loc, gtid, p_last, p_lb, p_ub, p_st
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                          ,
                                          OMPT_LOAD_RETURN_ADDRESS(gtid)
 #endif
-                                             );
 }
 
 /*!
 @param loc Source code location
 @param gtid Global thread id
 
 Mark the end of a dynamic loop.
 */

 kmp_uint32 __kmp_le_4(kmp_uint32 value, kmp_uint32 checker) {
   return value <= checker;
 }
 
 kmp_uint32
 __kmp_wait_4(volatile kmp_uint32 *spinner, kmp_uint32 checker,
              kmp_uint32 (*pred)(kmp_uint32, kmp_uint32),
              void *obj // Higher-level synchronization object, or NULL.
-             ) {
   // note: we may not belong to a team at this point
   volatile kmp_uint32 *spin = spinner;
   kmp_uint32 check = checker;
   kmp_uint32 spins;
   kmp_uint32 (*f)(kmp_uint32, kmp_uint32) = pred;
   kmp_uint32 r;
 
   KMP_FSYNC_SPIN_INIT(obj, CCAST(kmp_uint32 *, spin));
) {
   }
   KMP_FSYNC_SPIN_ACQUIRED(obj);
   return r;
 }
 
 void __kmp_wait_4_ptr(void *spinner, kmp_uint32 checker,
                       kmp_uint32 (*pred)(void *, kmp_uint32),
                       void *obj // Higher-level synchronization object, or NULL.
-                      ) {
   // note: we may not belong to a team at this point
   void *spin = spinner;
   kmp_uint32 check = checker;
   kmp_uint32 spins;
   kmp_uint32 (*f)(void *, kmp_uint32) = pred;
 
   KMP_FSYNC_SPIN_INIT(obj, spin);
   KMP_INIT_YIELD(spins);

openmp/runtime/src/kmp_environment.cpp

characters, variables are separated with vertical bars, e. g.:
     Empty variables are allowed and ignored:
 
         "||KMP_WARNINGS=1||"
 */
 
 static void
 ___kmp_env_blk_parse_string(kmp_env_blk_t *block, // M: Env block to fill.
                             char const *env // I: String to parse.
-                            ) {
 
   char const chr_delimiter = '|';
   char const str_delimiter[] = {chr_delimiter, 0};
 
   char *bulk = NULL;
   kmp_env_var_t *vars = NULL;
   int count = 0; // Number of used elements in vars array.
   int delimiters = 0; // Number of delimiters in input string.
the end of environment block, e. g.:
 
     It is not clear how empty environment is represented. "\x00\x00"?
 */
 
 #if KMP_OS_WINDOWS
 static void ___kmp_env_blk_parse_windows(
     kmp_env_blk_t *block, // M: Env block to fill.
     char const *env // I: Pointer to Windows* OS (DOS) environment block.
-    ) {
 
   char *bulk = NULL;
   kmp_env_var_t *vars = NULL;
   int count = 0; // Number of used elements in vars array.
   int size = 0; // Size of bulk.
 
   char *name; // Pointer to name of variable.
   char *value; // Pointer to value.
/* Unix environment block is a array of pointers to variables, last pointer in
    array is NULL:
 
         { "HOME=/home/lev", "TERM=xterm", NULL }
 */
 
 static void
 ___kmp_env_blk_parse_unix(kmp_env_blk_t *block, // M: Env block to fill.
                           char **env // I: Unix environment to parse.
-                          ) {
   char *bulk = NULL;
   kmp_env_var_t *vars = NULL;
   int count = 0;
   size_t size = 0; // Size of bulk.
 
   // Count number of variables and length of required bulk.
   {
     while (env[count] != NULL) {
) {
   // Fill out result.
   block->bulk = bulk;
   block->vars = vars;
   block->count = count;
 }
 
 void __kmp_env_blk_init(kmp_env_blk_t *block, // M: Block to initialize.
                         char const *bulk // I: Initialization string, or NULL.
-                        ) {
 
   if (bulk != NULL) {
     ___kmp_env_blk_parse_string(block, bulk);
   } else {
 #if KMP_OS_UNIX
     ___kmp_env_blk_parse_unix(block, environ);
 #elif KMP_OS_WINDOWS
     {

 
 static int ___kmp_env_var_cmp( // Comparison function for qsort().
     kmp_env_var_t const *lhs, kmp_env_var_t const *rhs) {
   return strcmp(lhs->name, rhs->name);
 }
 
 void __kmp_env_blk_sort(
     kmp_env_blk_t *block // M: Block of environment variables to sort.
-    ) {
 
   qsort(CCAST(kmp_env_var_t *, block->vars), block->count,
         sizeof(kmp_env_var_t),
         (int (*)(void const *, void const *)) & ___kmp_env_var_cmp);
 
 } // __kmp_env_block_sort
 
 void __kmp_env_blk_free(
     kmp_env_blk_t *block // M: Block of environment variables to free.
-    ) {
 
   KMP_INTERNAL_FREE(CCAST(kmp_env_var_t *, block->vars));
   __kmp_str_free(&(block->bulk));
 
   block->count = 0;
   block->vars = NULL;
 
 } // __kmp_env_blk_free
 
 char const * // R: Value of variable or NULL if variable does not exist.
-    __kmp_env_blk_var(
-        kmp_env_blk_t *block, // I: Block of environment variables.
+__kmp_env_blk_var(kmp_env_blk_t *block, // I: Block of environment variables.
                   char const *name // I: Name of variable to find.
-        ) {
 
   int i;
   for (i = 0; i < block->count; ++i) {
     if (strcmp(block->vars[i].name, name) == 0) {
       return block->vars[i].value;
     }
   }
   return NULL;
 
 } // __kmp_env_block_var
 
 // end of file //

openmp/runtime/src/kmp_error.cpp

 #include "kmp_i18n.h"
 #include "kmp_str.h"
 
 /* ------------------------------------------------------------------------ */
 
 #define MIN_STACK 100
 
 static char const *cons_text_c[] = {
-    "(none)", "\"parallel\"", "work-sharing", /* this is not called "for"
-                                                 because of lowering of
-                                                 "sections" pragmas */
+    "(none)",
+    "\"parallel\"",
+    "work-sharing", /* this is not called "for"
     "\"ordered\" work-sharing", /* this is not called "for ordered" because of
                                    lowering of "sections" pragmas */
     "\"sections\"",
     "work-sharing", /* this is not called "single" because of lowering of
                        "sections" pragmas */
-    "\"critical\"", "\"ordered\"", /* in PARALLEL */
+    "\"critical\"",
+    "\"ordered\"", /* in PARALLEL */
     "\"ordered\"", /* in PDO */
-    "\"master\"", "\"reduce\"", "\"barrier\""};
+    "\"master\"",
+    "\"reduce\"",
+    "\"barrier\""};
 
 #define get_src(ident) ((ident) == NULL ? NULL : (ident)->psource)
 
 #define PUSH_MSG(ct, ident)                                                    \
   "\tpushing on stack: %s (%s)\n", cons_text_c[(ct)], get_src((ident))
 #define POP_MSG(p)                                                             \
   "\tpopping off stack: %s (%s)\n", cons_text_c[(p)->stack_data[tos].type],    \
       get_src((p)->stack_data[tos].ident)
static char *__kmp_pragma(int ct, ident_t const *ident) {
   return prgm.str;
 } // __kmp_pragma
 
 /* ----------------- END OF STATIC LOCAL ROUTINES ------------------------- */
 
 void __kmp_error_construct(kmp_i18n_id_t id, // Message identifier.
                            enum cons_type ct, // Construct type.
                            ident_t const *ident // Construct ident.
-                           ) {
   char *construct = __kmp_pragma(ct, ident);
   __kmp_fatal(__kmp_msg_format(id, construct), __kmp_msg_null);
   KMP_INTERNAL_FREE(construct);
 }
 
 void __kmp_error_construct2(kmp_i18n_id_t id, // Message identifier.
                             enum cons_type ct, // First construct type.
                             ident_t const *ident, // First construct ident.
                             struct cons_data const *cons // Second construct.
-                            ) {
   char *construct1 = __kmp_pragma(ct, ident);
   char *construct2 = __kmp_pragma(cons->type, cons->ident);
   __kmp_fatal(__kmp_msg_format(id, construct1, construct2), __kmp_msg_null);
   KMP_INTERNAL_FREE(construct1);
   KMP_INTERNAL_FREE(construct2);
 }
 
 struct cons_header *__kmp_allocate_cons_stack(int gtid) {

openmp/runtime/src/kmp_ftn_entry.h

 /*
  * kmp_ftn_entry.h -- Fortran entry linkage support for OpenMP.
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FTN_STDCALL
 #error The support file kmp_ftn_entry.h should not be compiled by itself.
 #endif
 
 #ifdef KMP_STUB
 #include "kmp_stub.h"
 #endif
 
 #include "kmp_i18n.h"
 

 
 // This macro helps to reduce code duplication.
 #ifdef PASS_ARGS_BY_VALUE
 #define KMP_DEREF
 #else
 #define KMP_DEREF *
 #endif
 
 void FTN_STDCALL FTN_SET_STACKSIZE(int KMP_DEREF arg) {
 #ifdef KMP_STUB
   __kmps_set_stacksize(KMP_DEREF arg);
 #else
   // __kmp_aux_set_stacksize initializes the library if needed
   __kmp_aux_set_stacksize((size_t)KMP_DEREF arg);
 #endif
 }
 
public:
   ~ConvertedString() { __kmp_thread_free(th, buf); }
   const char *get() const { return buf; }
 };
 #endif // KMP_STUB
 
 /*
  * Set the value of the affinity-format-var ICV on the current device to the
  * format specified in the argument.
  */
 void FTN_STDCALL FTN_SET_AFFINITY_FORMAT(char const *format, size_t size) {
 #ifdef KMP_STUB
   return;
 #else
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   ConvertedString cformat(format, size);
   // Since the __kmp_affinity_format variable is a C string, do not
   // use the fortran strncpy function
   __kmp_strncpy_truncate(__kmp_affinity_format, KMP_AFFINITY_FORMAT_SIZE,
                          cformat.get(), KMP_STRLEN(cformat.get()));
 #endif
 }
 
 /*
  * Returns the number of characters required to hold the entire affinity format
  * specification (not including null byte character) and writes the value of the
  * affinity-format-var ICV on the current device to buffer. If the return value
  * is larger than size, the affinity format specification is truncated.
  */
 size_t FTN_STDCALL FTN_GET_AFFINITY_FORMAT(char *buffer, size_t size) {
 #ifdef KMP_STUB
   return 0;
 #else
   size_t format_size;
   if (!__kmp_init_serial) {
     __kmp_serial_initialize();
   }
   format_size = KMP_STRLEN(__kmp_affinity_format);
   if (buffer && size) {
     __kmp_fortran_strncpy_truncate(buffer, size, __kmp_affinity_format,
                                    format_size);
   }
   return format_size;
 #endif
 }
 
 /*
  * Prints the thread affinity information of the current thread in the format
  * specified by the format argument. If the format is NULL or a zero-length
  * string, the value of the affinity-format-var ICV is used.
  */
 void FTN_STDCALL FTN_DISPLAY_AFFINITY(char const *format, size_t size) {
 #ifdef KMP_STUB
   return;
 #else
   int gtid;
   if (!TCR_4(__kmp_init_middle)) {
     __kmp_middle_initialize();
   }
   gtid = __kmp_get_gtid();
   ConvertedString cformat(format, size);
   __kmp_aux_display_affinity(gtid, cformat.get());
 #endif
 }
 
 /*
  * Returns the number of characters required to hold the entire affinity format
  * specification (not including null byte) and prints the thread affinity
  * information of the current thread into the character string buffer with the
  * size of size in the format specified by the format argument. If the format is
  * NULL or a zero-length string, the value of the affinity-format-var ICV is
  * used. The buffer must be allocated prior to calling the routine. If the
  * return value is larger than size, the affinity format specification is
  * truncated.
  */
 size_t FTN_STDCALL FTN_CAPTURE_AFFINITY(char *buffer, char const *format,
                                         size_t buf_size, size_t for_size) {
 #if defined(KMP_STUB)
   return 0;
 #else
   int gtid;
   size_t num_required;
   kmp_str_buf_t capture_buf;

 
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_THREAD_NUM)(void) {
 #ifdef KMP_STUB
   return 0;
 #else
   int gtid;
 
 #if KMP_OS_DARWIN || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD ||    \
-        KMP_OS_HURD|| KMP_OS_OPENBSD
+    KMP_OS_HURD || KMP_OS_OPENBSD
   gtid = __kmp_entry_gtid();
 #elif KMP_OS_WINDOWS
   if (!__kmp_init_parallel ||
       (gtid = (int)((kmp_intptr_t)TlsGetValue(__kmp_gtid_threadprivate_key))) ==
           0) {
     // Either library isn't initialized or thread is not registered
     // 0 is the correct TID in this case
     return 0;
   }
   --gtid; // We keep (gtid+1) in TLS
 #elif KMP_OS_LINUX
 #ifdef KMP_TDATA_GTID
   if (__kmp_gtid_mode >= 3) {
     if ((gtid = __kmp_gtid) == KMP_GTID_DNE) {
       return 0;
     }
   } else {
 #endif
     if (!__kmp_init_parallel ||
-        (gtid = (int)((kmp_intptr_t)(
-             pthread_getspecific(__kmp_gtid_threadprivate_key)))) == 0) {
+        (gtid = (int)((kmp_intptr_t)(pthread_getspecific(
+             __kmp_gtid_threadprivate_key)))) == 0) {
       return 0;
     }
     --gtid;
 #ifdef KMP_TDATA_GTID
   }
 #endif
 #else
 #error Unknown or unsupported OS
#ifdef KMP_STUB
   return 0; // returns 0 if it is called from the sequential part of the program
 #else
   /* TO DO: For the per-task implementation of the internal controls */
   return __kmp_entry_thread()->th.th_team->t.t_level;
 #endif
 }
 
 int FTN_STDCALL
-    KMP_EXPAND_NAME(FTN_GET_ANCESTOR_THREAD_NUM)(int KMP_DEREF level) {
 #ifdef KMP_STUB
   return (KMP_DEREF level) ? (-1) : (0);
 #else
   return __kmp_get_ancestor_thread_num(__kmp_entry_gtid(), KMP_DEREF level);
 #endif
 }
 
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_TEAM_SIZE)(int KMP_DEREF level) {
#else
   if (first_place <= last_place)
     num_places = last_place - first_place + 1;
   else
     num_places = __kmp_affinity_num_masks - first_place + last_place + 1;
   return num_places;
 #endif
 }
 
-void
-    FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_PARTITION_PLACE_NUMS)(int *place_nums) {
+void FTN_STDCALL
+KMP_EXPAND_NAME(FTN_GET_PARTITION_PLACE_NUMS)(int *place_nums) {
 #if defined(KMP_STUB) || !KMP_AFFINITY_SUPPORTED
 // Nothing.
 #else
   int i, gtid, place_num, first_place, last_place, start, end;
   kmp_info_t *thread;
   if (!TCR_4(__kmp_init_middle)) {
     __kmp_middle_initialize();
   }

 #else
   __kmp_entry_thread()->th.th_current_task->td_icvs.default_device =
       KMP_DEREF arg;
 #endif
 }
 
 // Get number of NON-HOST devices.
 // libomptarget, if loaded, provides this function in api.cpp.
-int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_DEVICES)(void) KMP_WEAK_ATTRIBUTE_EXTERNAL;
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_DEVICES)(void)
+    KMP_WEAK_ATTRIBUTE_EXTERNAL;
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_GET_NUM_DEVICES)(void) {
 #if KMP_MIC || KMP_OS_DARWIN || KMP_OS_WINDOWS || defined(KMP_STUB)
   return 0;
 #else
   int (*fptr)();
   if ((*(void **)(&fptr) = dlsym(RTLD_DEFAULT, "_Offload_number_of_devices"))) {
     return (*fptr)();
   } else if ((*(void **)(&fptr) = dlsym(RTLD_NEXT, "omp_get_num_devices"))) {
     return (*fptr)();
   } else { // liboffload & libomptarget don't exist
     return 0;
   }
 #endif // KMP_MIC || KMP_OS_DARWIN || KMP_OS_WINDOWS || defined(KMP_STUB)
 }
 
 // This function always returns true when called on host device.
 // Compiler/libomptarget should handle when it is called inside target region.
-int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) KMP_WEAK_ATTRIBUTE_EXTERNAL;
+int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void)
+    KMP_WEAK_ATTRIBUTE_EXTERNAL;
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) {
   return 1; // This is the host
 }
 
 // libomptarget, if loaded, provides this function
 int FTN_STDCALL FTN_GET_INITIAL_DEVICE(void) KMP_WEAK_ATTRIBUTE_EXTERNAL;
 int FTN_STDCALL FTN_GET_INITIAL_DEVICE(void) {
 #if KMP_MIC || KMP_OS_DARWIN || KMP_OS_WINDOWS || defined(KMP_STUB)
   // same as omp_get_num_devices()
   return 0;
 #else
   int (*fptr)();
   if ((*(void **)(&fptr) = dlsym(RTLD_NEXT, "omp_get_initial_device"))) {
     return (*fptr)();
   } else { // liboffload & libomptarget don't exist

 #endif
 }
 
 void FTN_STDCALL FTN_SET_DEFAULTS(char const *str
 #ifndef PASS_ARGS_BY_VALUE
                                   ,
                                   int len
 #endif
-                                  ) {
 #ifndef KMP_STUB
 #ifdef PASS_ARGS_BY_VALUE
   int len = (int)KMP_STRLEN(str);
 #endif
   __kmp_aux_set_defaults(str, len);
 #endif
 }
 
#else
   return __kmp_max_task_priority;
 #endif
 }
 
 // This function will be defined in libomptarget. When libomptarget is not
 // loaded, we assume we are on the host and return KMP_HOST_DEVICE.
 // Compiler/libomptarget will handle this if called inside target.
 int FTN_STDCALL FTN_GET_DEVICE_NUM(void) KMP_WEAK_ATTRIBUTE_EXTERNAL;
 int FTN_STDCALL FTN_GET_DEVICE_NUM(void) { return FTN_GET_INITIAL_DEVICE(); }
 
 // Compiler will ensure that this is only called from host in sequential region
 int FTN_STDCALL FTN_PAUSE_RESOURCE(kmp_pause_status_t kind, int device_num) {
 #ifdef KMP_STUB
   return 1; // just fail
 #else
   if (device_num == FTN_GET_INITIAL_DEVICE())
     return __kmpc_pause_resource(kind);
/* These following sections create versioned symbols for the
    Step 2) Set __kmp_api_omp_set_num_threads_10_alias to version:
      omp_set_num_threads@OMP_1.0
    Step 2B) Set __kmp_api_omp_set_num_threads to default version:
      omp_set_num_threads@@VERSION
 */
 
 // OMP_1.0 versioned symbols
 KMP_VERSION_SYMBOL(FTN_SET_NUM_THREADS, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_GET_NUM_THREADS, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_GET_MAX_THREADS, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_GET_THREAD_NUM, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_GET_NUM_PROCS, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_IN_PARALLEL, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_SET_DYNAMIC, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_GET_DYNAMIC, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_SET_NESTED, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_GET_NESTED, 10, "OMP_1.0");
 KMP_VERSION_SYMBOL(FTN_INIT_LOCK, 10, "OMP_1.0");

openmp/runtime/src/kmp_gsupport.cpp

void *KMP_EXPAND_NAME(KMP_API_NAME_GOMP_SINGLE_COPY_START)(void) {
   __kmp_resume_if_soft_paused();
 
   // If this is the first thread to enter, return NULL.  The generated code will
   // then call GOMP_single_copy_end() for this thread only, with the
   // copyprivate data pointer as an argument.
   if (__kmp_enter_single(gtid, &loc, FALSE))
     return NULL;
 
     // Wait for the first thread to set the copyprivate data pointer,
     // and for all other threads to reach this point.
 
 #if OMPT_SUPPORT && OMPT_OPTIONAL
   ompt_frame_t *ompt_frame;
   if (ompt_enabled.enabled) {
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
   }
   OMPT_STORE_RETURN_ADDRESS(gtid);
if (ompt_enabled.enabled) {
     ompt_team_info_t *team_info = __ompt_get_teaminfo(0, NULL);
     ompt_task_info_t *task_info = __ompt_get_task_info_object(0);
 
     // implicit task callback
     if (ompt_enabled.ompt_callback_implicit_task) {
       ompt_team_size = __kmp_team_from_gtid(gtid)->t.t_nproc;
       ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
           ompt_scope_begin, &(team_info->parallel_data),
-          &(task_info->task_data), ompt_team_size, __kmp_tid_from_gtid(gtid), ompt_task_implicit); // TODO: Can this be ompt_task_initial?
+          &(task_info->task_data), ompt_team_size, __kmp_tid_from_gtid(gtid),
+          ompt_task_implicit); // TODO: Can this be ompt_task_initial?
       task_info->thread_num = __kmp_tid_from_gtid(gtid);
     }
     thr->th.ompt_thread_info.state = ompt_state_work_parallel;
   }
 #endif
 }
 
 void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_START)(void (*task)(void *),
#if OMPT_SUPPORT
   }
 #endif
 
   __kmp_join_call(&loc, gtid
 #if OMPT_SUPPORT
                   ,
                   fork_context_gnu
 #endif
-                  );
 }
 
 // Loop worksharing constructs
 
 // The Gnu codegen passes in an exclusive upper bound for the overall range,
 // but the libguide dispatch code expects an inclusive upper bound, hence the
 // "end - incr" 5th argument to KMP_DISPATCH_INIT (and the " ub - str" 11th
 // argument to __kmp_GOMP_fork_call).

 LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_START),
                kmp_sch_dynamic_chunked)
 LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_DYNAMIC_NEXT), {})
 LOOP_START_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_START),
                kmp_sch_guided_chunked)
 LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_GUIDED_NEXT), {})
 LOOP_START_ULL(
     KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_START),
-               kmp_sch_dynamic_chunked)
 LOOP_NEXT_ULL(
     KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_DYNAMIC_NEXT), {})
 LOOP_START_ULL(
     KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_START),
-               kmp_sch_guided_chunked)
 LOOP_NEXT_ULL(
     KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_NONMONOTONIC_GUIDED_NEXT), {})
 LOOP_RUNTIME_START_ULL(
     KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_START), kmp_sch_runtime)
 LOOP_NEXT_ULL(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_LOOP_ULL_RUNTIME_NEXT), {})
 LOOP_RUNTIME_START_ULL(
     KMP_EXPAND_NAME(
         KMP_API_NAME_GOMP_LOOP_ULL_MAYBE_NONMONOTONIC_RUNTIME_START),
if (copy_func) {
       KMP_MEMCPY(task->shareds, data, arg_size);
     }
   }
 
 #if OMPT_SUPPORT
   kmp_taskdata_t *current_task;
   if (ompt_enabled.enabled) {
     current_task = __kmp_threads[gtid]->th.th_current_task;
-    current_task->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
+    current_task->ompt_task_info.frame.enter_frame.ptr =
+        OMPT_GET_FRAME_ADDRESS(0);
   }
   OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
   if (if_cond) {
     if (gomp_flags & KMP_GOMP_TASK_DEPENDS_FLAG) {
       KMP_ASSERT(depend);
       kmp_gomp_depends_info_t gomp_depends(depend);
#endif
 
   __kmp_GOMP_fork_call(&loc, gtid, num_threads, flags, task,
                        (microtask_t)__kmp_GOMP_parallel_microtask_wrapper, 9,
                        task, data, num_threads, &loc, kmp_nm_dynamic_chunked,
                        (kmp_int)1, (kmp_int)count, (kmp_int)1, (kmp_int)1);
 
   {
 #if OMPT_SUPPORT
     OMPT_STORE_RETURN_ADDRESS(gtid);
 #endif
 
     KMP_DISPATCH_INIT(&loc, gtid, kmp_nm_dynamic_chunked, 1, count, 1, 1, TRUE);
   }
   task(data);
   KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_END)();
   KA_TRACE(20, ("GOMP_parallel_sections exit: T#%d\n", gtid));
 }
 
 #define PARALLEL_LOOP(func, schedule, ompt_pre, ompt_post)                     \
   void func(void (*task)(void *), void *data, unsigned num_threads, long lb,   \
#define PARALLEL_LOOP(func, schedule, ompt_pre, ompt_post)                     \
   }
 
 PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_STATIC),
               kmp_sch_static, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_DYNAMIC),
               kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP(
     KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_NONMONOTONIC_GUIDED),
-              kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP(
     KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_NONMONOTONIC_DYNAMIC),
-              kmp_sch_dynamic_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_GUIDED),
               kmp_sch_guided_chunked, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP(KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_RUNTIME),
               kmp_sch_runtime, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP(
     KMP_EXPAND_NAME(KMP_API_NAME_GOMP_PARALLEL_LOOP_MAYBE_NONMONOTONIC_RUNTIME),
     kmp_sch_runtime, OMPT_LOOP_PRE, OMPT_LOOP_POST)
 PARALLEL_LOOP(

openmp/runtime/src/kmp_i18n.cpp

if (__kmp_generate_warnings > kmp_warnings_low) {
 
          OMP: Warning #2: Cannot open message catalog "1041\libompui.dll":
          OMP: System error #193: (No system error message available)
          OMP: Info #3: Default messages will be used.
 
          Issue hint in this case so cause of trouble is more understandable. */
       kmp_msg_t err_code = KMP_SYSERRCODE(error);
       __kmp_msg(kmp_ms_warning, KMP_MSG(CantOpenMessageCatalog, path.str),
-                err_code, (error == ERROR_BAD_EXE_FORMAT
-                               ? KMP_HNT(BadExeFormat, path.str, KMP_ARCH_STR)
-                               : __kmp_msg_null),
+                err_code,
+                (error == ERROR_BAD_EXE_FORMAT
                 __kmp_msg_null);
       if (__kmp_generate_warnings == kmp_warnings_off) {
         __kmp_str_free(&err_code.str);
       }
       KMP_INFORM(WillUseDefaultMessages);
     }
   } else { // status == KMP_I18N_OPENED
 
static char const *___catgets(kmp_i18n_id_t id) {
 
   // Calculate length of multibyte message.
   // Since wlen does not include terminating null, len does not include it also.
   len = WideCharToMultiByte(code_page,
                             0, // Flags.
                             wmsg, wlen, // Wide buffer and size.
                             NULL, 0, // Buffer and size.
                             NULL, NULL // Default char and used default char.
-                            );
   if (len <= 0) {
     goto end;
   }
 
   // Allocate memory.
   msg = (char *)KMP_INTERNAL_MALLOC(len + 1);
 
   // Convert wide message to multibyte one.
   rc = WideCharToMultiByte(code_page,
                            0, // Flags.
                            wmsg, wlen, // Wide buffer and size.
                            msg, len, // Buffer and size.
                            NULL, NULL // Default char and used default char.
-                           );
   if (rc <= 0 || rc > len) {
     goto end;
   }
   KMP_DEBUG_ASSERT(rc == len);
   len = rc;
   msg[len] = 0; // Put terminating null to the end.
 
   // Stripping all "\r" before stripping last end-of-line simplifies the task.
if (rc > 0) {
     // even start it.
   }
   if (buffer != NULL) {
     LocalFree(buffer);
   }
 
 #else // Non-Windows* OS: Linux* OS or OS X*
 
   /* There are 2 incompatible versions of strerror_r:
 
      char * strerror_r( int, char *, size_t );  // GNU version
      int    strerror_r( int, char *, size_t );  // XSI version
   */
 
 #if (defined(__GLIBC__) && defined(_GNU_SOURCE)) ||                            \
     (defined(__BIONIC__) && defined(_GNU_SOURCE) &&                            \
      __ANDROID_API__ >= __ANDROID_API_M__)
   // GNU version of strerror_r.
 
   char buffer[2048];
   char *const err_msg = strerror_r(err, buffer, sizeof(buffer));
case kmp_ms_inform: {
     format = kmp_i18n_fmt_Info;
   } break;
   case kmp_ms_warning: {
     format = kmp_i18n_fmt_Warning;
   } break;
   case kmp_ms_fatal: {
     format = kmp_i18n_fmt_Fatal;
   } break;
-  default: { KMP_DEBUG_ASSERT(0); }
+  default: {
+    KMP_DEBUG_ASSERT(0);
+  }
   }
   fmsg = __kmp_msg_format(format, message.num, message.str);
   __kmp_str_free(&message.str);
   __kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len);
   __kmp_str_free(&fmsg.str);
 
   // Format other messages.
   for (;;) {
     message = va_arg(args, kmp_msg_t);
     if (message.type == kmp_mt_dummy && message.str == NULL) {
       break;
     }
     switch (message.type) {
     case kmp_mt_hint: {
       format = kmp_i18n_fmt_Hint;
       // we cannot skip %1$ and only use %2$ to print the message without the
       // number
       fmsg = __kmp_msg_format(format, message.str);
     } break;
     case kmp_mt_syserr: {
       format = kmp_i18n_fmt_SysErr;
       fmsg = __kmp_msg_format(format, message.num, message.str);
     } break;
-    default: { KMP_DEBUG_ASSERT(0); }
+    default: {
+      KMP_DEBUG_ASSERT(0);
+    }
     }
     __kmp_str_free(&message.str);
     __kmp_str_buf_cat(&buffer, fmsg.str, fmsg.len);
     __kmp_str_free(&fmsg.str);
   }
 
   // Print formatted messages.
   // This lock prevents multiple fatal errors on the same problem.

openmp/runtime/src/kmp_io.cpp

#endif /* KMP_OS_WINDOWS */
 
   if (__kmp_debug_buf && __kmp_debug_buffer != NULL) {
 
     int dc = __kmp_debug_count++ % __kmp_debug_buf_lines;
     char *db = &__kmp_debug_buffer[dc * __kmp_debug_buf_chars];
     int chars = 0;
 
 #ifdef KMP_DEBUG_PIDS
-    chars = KMP_SNPRINTF(db, __kmp_debug_buf_chars, "pid=%d: ",
-                         (kmp_int32)getpid());
+    chars = KMP_SNPRINTF(db, __kmp_debug_buf_chars,
+                         "pid=%d: ", (kmp_int32)getpid());
 #endif
     chars += KMP_VSNPRINTF(db, __kmp_debug_buf_chars, format, ap);
 
     if (chars + 1 > __kmp_debug_buf_chars) {
       if (chars + 1 > __kmp_debug_buf_warn_chars) {
 #if KMP_OS_WINDOWS
         DWORD count;
-        __kmp_str_buf_print(&__kmp_console_buf, "OMP warning: Debugging buffer "
-                                                "overflow; increase "
-                                                "KMP_DEBUG_BUF_CHARS to %d\n",
+        __kmp_str_buf_print(&__kmp_console_buf,
+                            "OMP warning: Debugging buffer "
                             chars + 1);
         WriteFile(stream, __kmp_console_buf.str, __kmp_console_buf.used, &count,
                   NULL);
         __kmp_str_buf_clear(&__kmp_console_buf);
 #else
-        fprintf(stream, "OMP warning: Debugging buffer overflow; "
-                        "increase KMP_DEBUG_BUF_CHARS to %d\n",
+        fprintf(stream,
+                "OMP warning: Debugging buffer overflow; "
                 chars + 1);
         fflush(stream);
 #endif
         __kmp_debug_buf_warn_chars = chars + 1;
       }
       /* terminate string if overflow occurred */
       db[__kmp_debug_buf_chars - 2] = '\n';
       db[__kmp_debug_buf_chars - 1] = '\0';

openmp/runtime/src/kmp_itt.cpp

 void __kmp_itt_reset() {
 #if USE_ITT_NOTIFY
   __kmp_itt__ittapi_global = __kmp_ittapi_clean_global;
 #endif
 }
 
 void __kmp_itt_initialize() {
 
   // ITTNotify library is loaded and initialized at first call to any ittnotify
   // function, so we do not need to explicitly load it any more. Just report OMP
   // RTL version to ITTNotify.
 
 #if USE_ITT_NOTIFY
   // Backup a clean global state
   __kmp_ittapi_clean_global = __kmp_itt__ittapi_global;
 
   // Report OpenMP RTL version.
   kmp_str_buf_t buf;
   __itt_mark_type version;
case __itt_error_system: {
     int sys_err = va_arg(args, int);
     kmp_msg_t err_code = KMP_SYSERRCODE(sys_err);
     __kmp_msg(kmp_ms_warning, KMP_MSG(IttFunctionError, func), err_code,
               __kmp_msg_null);
     if (__kmp_generate_warnings == kmp_warnings_off) {
       __kmp_str_free(&err_code.str);
     }
   } break;
-  default: { KMP_WARNING(IttUnknownError, err); }
+  default: {
+    KMP_WARNING(IttUnknownError, err);
+  }
   }
 } // __itt_error_handler
 
 #endif /* USE_ITT_BUILD */

openmp/runtime/src/kmp_lock.h

if (__kmp_user_lock_kind == lk_tas) {                                        \
     }                                                                          \
     if (lck->tas.lk.poll != 0 ||                                               \
         !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) {     \
       kmp_uint32 spins;                                                        \
       KMP_FSYNC_PREPARE(lck);                                                  \
       KMP_INIT_YIELD(spins);                                                   \
       do {                                                                     \
         KMP_YIELD_OVERSUB_ELSE_SPIN(spins);                                    \
-      } while (                                                                \
-          lck->tas.lk.poll != 0 ||                                             \
-          !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1));    \
+      } while (lck->tas.lk.poll != 0 || !__kmp_atomic_compare_store_acq(       \
+                                            &lck->tas.lk.poll, 0, gtid + 1));  \
     }                                                                          \
     KMP_FSYNC_ACQUIRED(lck);                                                   \
   } else {                                                                     \
     KMP_DEBUG_ASSERT(__kmp_acquire_user_lock_with_checks_ != NULL);            \
     (*__kmp_acquire_user_lock_with_checks_)(lck, gtid);                        \
   }
 
 #else
extern void (*__kmp_indirect_set_flags[KMP_NUM_I_LOCKS])(kmp_user_lock_p,
                                                          kmp_lock_flags_t);
 #define KMP_SET_I_LOCK_FLAGS(lck, flag)                                        \
   {                                                                            \
     if (__kmp_indirect_set_flags[(lck)->type] != NULL)                         \
       __kmp_indirect_set_flags[(lck)->type]((lck)->lock, flag);                \
   }
 
 // Jump table for "get lock location", available only for indirect locks.
-extern const ident_t *(*__kmp_indirect_get_location[KMP_NUM_I_LOCKS])(
-    kmp_user_lock_p);
+extern const ident_t *(
+    *__kmp_indirect_get_location[KMP_NUM_I_LOCKS])(kmp_user_lock_p);
 #define KMP_GET_I_LOCK_LOCATION(lck)                                           \
   (__kmp_indirect_get_location[(lck)->type] != NULL                            \
        ? __kmp_indirect_get_location[(lck)->type]((lck)->lock)                 \
        : NULL)
 
 // Jump table for "get lock flags", available only for indirect locks.
 extern kmp_lock_flags_t (*__kmp_indirect_get_flags[KMP_NUM_I_LOCKS])(
     kmp_user_lock_p);

openmp/runtime/src/kmp_lock.cpp

#endif
       KA_TRACE(1000, ("__kmp_release_queuing_lock: lck:%p, T#%d exiting: after "
                       "dequeuing\n",
                       lck, gtid));
 #ifdef DEBUG_QUEUING_LOCKS
       TRACE_LOCK(gtid + 1, "rel exit 2");
 #endif
       return KMP_LOCK_RELEASED;
     }
     /* KMP_CPU_PAUSE(); don't want to make releasing thread hold up acquiring
        threads */
 
 #ifdef DEBUG_QUEUING_LOCKS
     TRACE_LOCK(gtid + 1, "rel retry");
 #endif
 
   } /* while */
   KMP_ASSERT2(0, "should not get here");
   return KMP_LOCK_RELEASED;
if (strcmp(__kmp_speculative_statsfile, "-") == 0) {
     size_t buffLen = KMP_STRLEN(__kmp_speculative_statsfile) + 20;
     char buffer[buffLen];
     KMP_SNPRINTF(&buffer[0], buffLen, __kmp_speculative_statsfile,
                  (kmp_int32)getpid());
     statsFile.open(buffer, "w");
   }
 
   fprintf(statsFile, "Speculative lock statistics (all approximate!)\n");
-  fprintf(statsFile, " Lock parameters: \n"
-                     "   max_soft_retries               : %10d\n"
-                     "   max_badness                    : %10d\n",
+  fprintf(statsFile,
+          " Lock parameters: \n"
           __kmp_adaptive_backoff_params.max_soft_retries,
           __kmp_adaptive_backoff_params.max_badness);
   fprintf(statsFile, " Non-speculative acquire attempts : %10d\n",
           t->nonSpeculativeAcquireAttempts);
   fprintf(statsFile, " Total critical sections          : %10d\n",
           totalSections);
   fprintf(statsFile, " Successful speculations          : %10d (%5.1f%%)\n",
           t->successfulSpeculations,

 // Size of indirect locks.
 static kmp_uint32 __kmp_indirect_lock_size[KMP_NUM_I_LOCKS] = {0};
 
 // Jump tables for lock accessor/modifier.
 void (*__kmp_indirect_set_location[KMP_NUM_I_LOCKS])(kmp_user_lock_p,
                                                      const ident_t *) = {0};
 void (*__kmp_indirect_set_flags[KMP_NUM_I_LOCKS])(kmp_user_lock_p,
                                                   kmp_lock_flags_t) = {0};
-const ident_t *(*__kmp_indirect_get_location[KMP_NUM_I_LOCKS])(
-    kmp_user_lock_p) = {0};
+const ident_t *(
+    *__kmp_indirect_get_location[KMP_NUM_I_LOCKS])(kmp_user_lock_p) = {0};
 kmp_lock_flags_t (*__kmp_indirect_get_flags[KMP_NUM_I_LOCKS])(
     kmp_user_lock_p) = {0};
 
 // Use different lock pools for different lock types.
 static kmp_indirect_lock_t *__kmp_indirect_lock_pool[KMP_NUM_I_LOCKS] = {0};
 
 // User lock allocator for dynamically dispatched indirect locks. Every entry of
 // the indirect lock table holds the address and type of the allocated indirect
__kmp_get_user_lock_location_ =
         (const ident_t *(*)(kmp_user_lock_p))(&__kmp_get_ticket_lock_location);
 
     __kmp_set_user_lock_location_ = (void (*)(
         kmp_user_lock_p, const ident_t *))(&__kmp_set_ticket_lock_location);
 
     __kmp_get_user_lock_flags_ =
         (kmp_lock_flags_t(*)(kmp_user_lock_p))(&__kmp_get_ticket_lock_flags);
 
-    __kmp_set_user_lock_flags_ = (void (*)(kmp_user_lock_p, kmp_lock_flags_t))(
-        &__kmp_set_ticket_lock_flags);
+    __kmp_set_user_lock_flags_ = (void (*)(
+        kmp_user_lock_p, kmp_lock_flags_t))(&__kmp_set_ticket_lock_flags);
   } break;
 
   case lk_queuing: {
     __kmp_base_user_lock_size = sizeof(kmp_base_queuing_lock_t);
     __kmp_user_lock_size = sizeof(kmp_queuing_lock_t);
 
     __kmp_get_user_lock_owner_ =
         (kmp_int32(*)(kmp_user_lock_p))(&__kmp_get_queuing_lock_owner);
__kmp_get_user_lock_location_ =
         (const ident_t *(*)(kmp_user_lock_p))(&__kmp_get_queuing_lock_location);
 
     __kmp_set_user_lock_location_ = (void (*)(
         kmp_user_lock_p, const ident_t *))(&__kmp_set_queuing_lock_location);
 
     __kmp_get_user_lock_flags_ =
         (kmp_lock_flags_t(*)(kmp_user_lock_p))(&__kmp_get_queuing_lock_flags);
 
-    __kmp_set_user_lock_flags_ = (void (*)(kmp_user_lock_p, kmp_lock_flags_t))(
-        &__kmp_set_queuing_lock_flags);
+    __kmp_set_user_lock_flags_ = (void (*)(
+        kmp_user_lock_p, kmp_lock_flags_t))(&__kmp_set_queuing_lock_flags);
   } break;
 
 #if KMP_USE_ADAPTIVE_LOCKS
   case lk_adaptive: {
     __kmp_base_user_lock_size = sizeof(kmp_base_adaptive_lock_t);
     __kmp_user_lock_size = sizeof(kmp_adaptive_lock_t);
 
     __kmp_get_user_lock_owner_ =
__kmp_get_user_lock_location_ =
         (const ident_t *(*)(kmp_user_lock_p))(&__kmp_get_queuing_lock_location);
 
     __kmp_set_user_lock_location_ = (void (*)(
         kmp_user_lock_p, const ident_t *))(&__kmp_set_queuing_lock_location);
 
     __kmp_get_user_lock_flags_ =
         (kmp_lock_flags_t(*)(kmp_user_lock_p))(&__kmp_get_queuing_lock_flags);
 
-    __kmp_set_user_lock_flags_ = (void (*)(kmp_user_lock_p, kmp_lock_flags_t))(
-        &__kmp_set_queuing_lock_flags);
+    __kmp_set_user_lock_flags_ = (void (*)(
+        kmp_user_lock_p, kmp_lock_flags_t))(&__kmp_set_queuing_lock_flags);
 
   } break;
 #endif // KMP_USE_ADAPTIVE_LOCKS
 
   case lk_drdpa: {
     __kmp_base_user_lock_size = sizeof(kmp_base_drdpa_lock_t);
     __kmp_user_lock_size = sizeof(kmp_drdpa_lock_t);
 
__kmp_get_user_lock_location_ =
         (const ident_t *(*)(kmp_user_lock_p))(&__kmp_get_drdpa_lock_location);
 
     __kmp_set_user_lock_location_ = (void (*)(
         kmp_user_lock_p, const ident_t *))(&__kmp_set_drdpa_lock_location);
 
     __kmp_get_user_lock_flags_ =
         (kmp_lock_flags_t(*)(kmp_user_lock_p))(&__kmp_get_drdpa_lock_flags);
 
-    __kmp_set_user_lock_flags_ = (void (*)(kmp_user_lock_p, kmp_lock_flags_t))(
-        &__kmp_set_drdpa_lock_flags);
+    __kmp_set_user_lock_flags_ = (void (*)(
+        kmp_user_lock_p, kmp_lock_flags_t))(&__kmp_set_drdpa_lock_flags);
   } break;
   }
 }
 
 // ----------------------------------------------------------------------------
 // User lock table & lock allocation
 
 kmp_lock_table_t __kmp_user_lock_table = {1, 0, NULL};

openmp/runtime/src/kmp_os.h

 
 #define KMP_CACHE_PREFETCH(ADDR) /* nothing */
 
 // Define attribute that indicates that the fall through from the previous
 // case label is intentional and should not be diagnosed by a compiler
 //   Code from libcxx/include/__config
 // Use a function like macro to imply that it must be followed by a semicolon
 #if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
-#  define KMP_FALLTHROUGH() [[fallthrough]]
+#define KMP_FALLTHROUGH() [[fallthrough]]
 #elif __has_cpp_attribute(clang::fallthrough)
-#  define KMP_FALLTHROUGH() [[clang::fallthrough]]
+#define KMP_FALLTHROUGH() [[clang::fallthrough]]
 #elif __has_attribute(fallthrough) || __GNUC__ >= 7
-#  define KMP_FALLTHROUGH() __attribute__((__fallthrough__))
+#define KMP_FALLTHROUGH() __attribute__((__fallthrough__))
 #else
-#  define KMP_FALLTHROUGH() ((void)0)
+#define KMP_FALLTHROUGH() ((void)0)
 #endif
 
 #if KMP_HAVE_ATTRIBUTE_WAITPKG
 #define KMP_ATTRIBUTE_TARGET_WAITPKG __attribute__((target("waitpkg")))
 #else
 #define KMP_ATTRIBUTE_TARGET_WAITPKG /* Nothing */
 #endif
 
__sync_val_compare_and_swap((volatile kmp_uint8 *)(p), (kmp_uint8)(cv),      \
                               (kmp_uint8)(sv))
 #define KMP_COMPARE_AND_STORE_RET16(p, cv, sv)                                 \
   __sync_val_compare_and_swap((volatile kmp_uint16 *)(p), (kmp_uint16)(cv),    \
                               (kmp_uint16)(sv))
 #define KMP_COMPARE_AND_STORE_RET32(p, cv, sv)                                 \
   __sync_val_compare_and_swap((volatile kmp_uint32 *)(p), (kmp_uint32)(cv),    \
                               (kmp_uint32)(sv))
 #if KMP_ARCH_MIPS
-static inline bool mips_sync_bool_compare_and_swap(
-  volatile kmp_uint64 *p, kmp_uint64 cv, kmp_uint64 sv) {
+static inline bool mips_sync_bool_compare_and_swap(volatile kmp_uint64 *p,
+                                                   kmp_uint64 cv,
+                                                   kmp_uint64 sv) {
   return __atomic_compare_exchange(p, &cv, &sv, false, __ATOMIC_SEQ_CST,
-                                                       __ATOMIC_SEQ_CST);
 }
-static inline bool mips_sync_val_compare_and_swap(
-  volatile kmp_uint64 *p, kmp_uint64 cv, kmp_uint64 sv) {
+static inline bool mips_sync_val_compare_and_swap(volatile kmp_uint64 *p,
+                                                  kmp_uint64 cv,
+                                                  kmp_uint64 sv) {
   __atomic_compare_exchange(p, &cv, &sv, false, __ATOMIC_SEQ_CST,
-                                                __ATOMIC_SEQ_CST);
   return cv;
 }
 #define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
-  mips_sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),\
-                               (kmp_uint64)(sv))
+  mips_sync_bool_compare_and_swap((volatile kmp_uint64 *)(p),                  \
+                                  (kmp_uint64)(cv), (kmp_uint64)(sv))
 #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
-  mips_sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),\
-                               (kmp_uint64)(sv))
+  mips_sync_bool_compare_and_swap((volatile kmp_uint64 *)(p),                  \
+                                  (kmp_uint64)(cv), (kmp_uint64)(sv))
 #define KMP_COMPARE_AND_STORE_RET64(p, cv, sv)                                 \
   mips_sync_val_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv), \
                                  (kmp_uint64)(sv))
 #else
 #define KMP_COMPARE_AND_STORE_ACQ64(p, cv, sv)                                 \
   __sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),   \
                                (kmp_uint64)(sv))
 #define KMP_COMPARE_AND_STORE_REL64(p, cv, sv)                                 \
   __sync_bool_compare_and_swap((volatile kmp_uint64 *)(p), (kmp_uint64)(cv),   \
                                (kmp_uint64)(sv))
 #define KMP_COMPARE_AND_STORE_RET64(p, cv, sv)                                 \

openmp/runtime/src/kmp_platform.h

 #define KMP_OS_OPENBSD 1
 #endif
 
 #if (defined __GNU__)
 #undef KMP_OS_HURD
 #define KMP_OS_HURD 1
 #endif
 
-#if (1 !=                                                                      \
-     KMP_OS_LINUX + KMP_OS_DRAGONFLY + KMP_OS_FREEBSD + KMP_OS_NETBSD +        \
+#if (1 != KMP_OS_LINUX + KMP_OS_DRAGONFLY + KMP_OS_FREEBSD + KMP_OS_NETBSD +   \
               KMP_OS_OPENBSD + KMP_OS_DARWIN + KMP_OS_WINDOWS + KMP_OS_HURD)
 #error Unknown OS
 #endif
 
 #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD ||     \
-        KMP_OS_OPENBSD || KMP_OS_DARWIN || KMP_OS_HURD
 #undef KMP_OS_UNIX
 #define KMP_OS_UNIX 1
 #endif
 
 /* ---------------------- Architecture recognition ------------------- */
 
 #define KMP_ARCH_X86 0
 #define KMP_ARCH_X86_64 0

 /* Specify 32 bit architectures here */
 #define KMP_32_BIT_ARCH (KMP_ARCH_X86 || KMP_ARCH_ARM || KMP_ARCH_MIPS)
 
 // Platforms which support Intel(R) Many Integrated Core Architecture
 #define KMP_MIC_SUPPORTED                                                      \
   ((KMP_ARCH_X86 || KMP_ARCH_X86_64) && (KMP_OS_LINUX || KMP_OS_WINDOWS))
 
 // TODO: Fixme - This is clever, but really fugly
-#if (1 !=                                                                      \
-     KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64 +          \
-     KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64 + KMP_ARCH_RISCV64)
+#if (1 != KMP_ARCH_X86 + KMP_ARCH_X86_64 + KMP_ARCH_ARM + KMP_ARCH_PPC64 +     \
+              KMP_ARCH_AARCH64 + KMP_ARCH_MIPS + KMP_ARCH_MIPS64 +             \
+              KMP_ARCH_RISCV64)
 #error Unknown or unsupported architecture
 #endif
 
 #endif // KMP_PLATFORM_H

openmp/runtime/src/kmp_runtime.cpp

#endif
   }
 
   if (__kmp_env_consistency_check)
     __kmp_push_parallel(global_tid, NULL);
 #if OMPT_SUPPORT
   serial_team->t.ompt_team_info.master_return_address = codeptr;
   if (ompt_enabled.enabled &&
       this_thr->th.ompt_thread_info.state != ompt_state_overhead) {
-    OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
+    OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr =
+        OMPT_GET_FRAME_ADDRESS(0);
 
     ompt_lw_taskteam_t lw_taskteam;
     __ompt_lw_taskteam_init(&lw_taskteam, this_thr, global_tid,
                             &ompt_parallel_data, codeptr);
 
     __ompt_lw_taskteam_link(&lw_taskteam, this_thr, 1);
     // don't use lw_taskteam after linking. content was swaped
 
     /* OMPT implicit task begin */
     implicit_task_data = OMPT_CUR_TASK_DATA(this_thr);
     if (ompt_enabled.ompt_callback_implicit_task) {
       ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
           ompt_scope_begin, OMPT_CUR_TEAM_DATA(this_thr),
-          OMPT_CUR_TASK_DATA(this_thr), 1, __kmp_tid_from_gtid(global_tid), ompt_task_implicit); // TODO: Can this be ompt_task_initial?
-      OMPT_CUR_TASK_INFO(this_thr)
-          ->thread_num = __kmp_tid_from_gtid(global_tid);
+          OMPT_CUR_TASK_DATA(this_thr), 1, __kmp_tid_from_gtid(global_tid),
+          ompt_task_implicit); // TODO: Can this be ompt_task_initial?
+      OMPT_CUR_TASK_INFO(this_thr)->thread_num =
+          __kmp_tid_from_gtid(global_tid);
     }
 
     /* OMPT state */
     this_thr->th.ompt_thread_info.state = ompt_state_work_parallel;
-    OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
+    OMPT_CUR_TASK_INFO(this_thr)->frame.exit_frame.ptr =
+        OMPT_GET_FRAME_ADDRESS(0);
   }
 #endif
 }
 
 /* most of the work for a fork */
 /* return true if we really went parallel, false if serialized */
 int __kmp_fork_call(ident_t *loc, int gtid,
                     enum fork_context_e call_context, // Intel, GNU, ...
#if OMPT_SUPPORT
           exit_frame_p = &(lw_taskteam.ompt_task_info.frame.exit_frame.ptr);
 
           __ompt_lw_taskteam_link(&lw_taskteam, master_th, 0);
           // don't use lw_taskteam after linking. content was swaped
 
           /* OMPT implicit task begin */
           implicit_task_data = OMPT_CUR_TASK_DATA(master_th);
           if (ompt_enabled.ompt_callback_implicit_task) {
-            OMPT_CUR_TASK_INFO(master_th)
-                ->thread_num = __kmp_tid_from_gtid(gtid);
+            OMPT_CUR_TASK_INFO(master_th)->thread_num =
+                __kmp_tid_from_gtid(gtid);
             ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                 ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th),
                 implicit_task_data, 1,
                 OMPT_CUR_TASK_INFO(master_th)->thread_num, ompt_task_implicit);
           }
 
           /* OMPT state */
           master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
         } else {
           exit_frame_p = &dummy;
         }
 #endif
         // AC: need to decrement t_serialized for enquiry functions to work
         // correctly, will restore at join time
         parent_team->t.t_serialized--;
 
         {
           KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
           KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
           __kmp_invoke_microtask(microtask, gtid, 0, argc, parent_team->t.t_argv
 #if OMPT_SUPPORT
                                  ,
                                  exit_frame_p
 #endif
-                                 );
         }
 
 #if OMPT_SUPPORT
         if (ompt_enabled.enabled) {
           *exit_frame_p = NULL;
           OMPT_CUR_TASK_INFO(master_th)->frame.exit_frame = ompt_data_none;
           if (ompt_enabled.ompt_callback_implicit_task) {
             ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
#endif /* KMP_OS_LINUX && ( KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || \
       __kmpc_serialized_parallel(loc, gtid);
 
       if (call_context == fork_context_intel) {
         /* TODO this sucks, use the compiler itself to pass args! :) */
         master_th->th.th_serial_team->t.t_ident = loc;
         if (!ap) {
           // revert change made in __kmpc_serialized_parallel()
           master_th->th.th_serial_team->t.t_level--;
           // Get args from parent team for teams construct
 
 #if OMPT_SUPPORT
           void *dummy;
           void **exit_frame_p;
           ompt_task_info_t *task_info;
 
           ompt_lw_taskteam_t lw_taskteam;
 
           if (ompt_enabled.enabled) {
             __ompt_lw_taskteam_init(&lw_taskteam, master_th, gtid,
                                     &ompt_parallel_data, return_address);
 
             __ompt_lw_taskteam_link(&lw_taskteam, master_th, 0);
             // don't use lw_taskteam after linking. content was swaped
 
             task_info = OMPT_CUR_TASK_INFO(master_th);
             exit_frame_p = &(task_info->frame.exit_frame.ptr);
             if (ompt_enabled.ompt_callback_implicit_task) {
-              OMPT_CUR_TASK_INFO(master_th)
-                  ->thread_num = __kmp_tid_from_gtid(gtid);
+              OMPT_CUR_TASK_INFO(master_th)->thread_num =
+                  __kmp_tid_from_gtid(gtid);
               ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                   ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th),
                   &(task_info->task_data), 1,
                   OMPT_CUR_TASK_INFO(master_th)->thread_num,
                   ompt_task_implicit);
             }
 
             /* OMPT state */
             master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
           } else {
             exit_frame_p = &dummy;
           }
 #endif
 
           {
             KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
             KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
             __kmp_invoke_microtask(microtask, gtid, 0, argc,
                                    parent_team->t.t_argv
 #if OMPT_SUPPORT
                                    ,
                                    exit_frame_p
 #endif
-                                   );
           }
 
 #if OMPT_SUPPORT
           if (ompt_enabled.enabled) {
             *exit_frame_p = NULL;
             if (ompt_enabled.ompt_callback_implicit_task) {
               ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                   ompt_scope_end, NULL, &(task_info->task_data), 1,
#if OMPT_SUPPORT
 
             /* OMPT implicit task begin */
             implicit_task_data = OMPT_CUR_TASK_DATA(master_th);
             if (ompt_enabled.ompt_callback_implicit_task) {
               ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                   ompt_scope_begin, OMPT_CUR_TEAM_DATA(master_th),
                   implicit_task_data, 1, __kmp_tid_from_gtid(gtid),
                   ompt_task_implicit);
-              OMPT_CUR_TASK_INFO(master_th)
-                  ->thread_num = __kmp_tid_from_gtid(gtid);
+              OMPT_CUR_TASK_INFO(master_th)->thread_num =
+                  __kmp_tid_from_gtid(gtid);
             }
 
             /* OMPT state */
             master_th->th.ompt_thread_info.state = ompt_state_work_parallel;
           } else {
             exit_frame_p = &dummy;
           }
 #endif
 
           {
             KMP_TIME_PARTITIONED_BLOCK(OMP_parallel);
             KMP_SET_THREAD_STATE_BLOCK(IMPLICIT_TASK);
             __kmp_invoke_microtask(microtask, gtid, 0, argc, args
 #if OMPT_SUPPORT
                                    ,
                                    exit_frame_p
 #endif
-                                   );
           }
 
 #if OMPT_SUPPORT
           if (ompt_enabled.enabled) {
             *exit_frame_p = NULL;
             if (ompt_enabled.ompt_callback_implicit_task) {
               ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
                   ompt_scope_end, NULL, &(task_info->task_data), 1,
void __kmp_set_num_threads(int new_nth, int gtid) {
   // reduced (in the absence of a num_threads clause), then reduce it now,
   // rather than waiting for the next parallel region.
   root = thread->th.th_root;
   if (__kmp_init_parallel && (!root->r.r_active) &&
       (root->r.r_hot_team->t.t_nproc > new_nth)
 #if KMP_NESTED_HOT_TEAMS
       && __kmp_hot_teams_max_level && !__kmp_hot_teams_mode
 #endif
-      ) {
     kmp_team_t *hot_team = root->r.r_hot_team;
     int f;
 
     __kmp_acquire_bootstrap_lock(&__kmp_forkjoin_lock);
 
     // Release the extra threads we don't need any more.
     for (f = new_nth; f < hot_team->t.t_nproc; f++) {
       KMP_DEBUG_ASSERT(hot_team->t.t_threads[f] != NULL);
root_team =
                           1, // new_nproc
                           1, // max_nproc
 #if OMPT_SUPPORT
                           ompt_data_none, // root parallel id
 #endif
                           __kmp_nested_proc_bind.bind_types[0], &r_icvs,
                           0 // argc
                           USE_NESTED_HOT_ARG(NULL) // master thread is unknown
-                          );
 #if USE_DEBUGGER
   // Non-NULL value should be assigned to make the debugger display the root
   // team.
   TCW_SYNC_PTR(root_team->t.t_pkfn, (microtask_t)(~0));
 #endif
 
   KF_TRACE(10, ("__kmp_initialize_root: after root_team = %p\n", root_team));
 
hot_team =
                           1, // new_nproc
                           __kmp_dflt_team_nth_ub * 2, // max_nproc
 #if OMPT_SUPPORT
                           ompt_data_none, // root parallel id
 #endif
                           __kmp_nested_proc_bind.bind_types[0], &r_icvs,
                           0 // argc
                           USE_NESTED_HOT_ARG(NULL) // master thread is unknown
-                          );
   KF_TRACE(10, ("__kmp_initialize_root: after hot_team = %p\n", hot_team));
 
   root->r.r_hot_team = hot_team;
   root_team->t.t_control_stack_top = NULL;
 
   /* first-time initialization */
   hot_team->t.t_parent = root_team;
 
typedef struct kmp_team_list_item {
   kmp_team_p const *entry;
   struct kmp_team_list_item *next;
 } kmp_team_list_item_t;
 typedef kmp_team_list_item_t *kmp_team_list_t;
 
 static void __kmp_print_structure_team_accum( // Add team to list of teams.
     kmp_team_list_t list, // List of teams.
     kmp_team_p const *team // Team to add.
-    ) {
 
   // List must terminate with item where both entry and next are NULL.
   // Team is added to the list only once.
   // List is sorted in ascending order by team id.
   // Team id is *not* a key.
 
   kmp_team_list_t l;
 
// Insert team.
     *item = *l;
     l->entry = team;
     l->next = item;
   }
 }
 
 static void __kmp_print_structure_team(char const *title, kmp_team_p const *team
 
-                                       ) {
   __kmp_printf("%s", title);
   if (team != NULL) {
     __kmp_printf("%2x %p\n", team->t.t_id, team);
   } else {
     __kmp_printf(" - (nil)\n");
   }
 }
 
/* This function attempts to create free entries in __kmp_threads and
    If any argument is negative, the behavior is undefined. */
 static int __kmp_expand_threads(int nNeed) {
   int added = 0;
   int minimumRequiredCapacity;
   int newCapacity;
   kmp_info_t **newThreads;
   kmp_root_t **newRoot;
 
   // All calls to __kmp_expand_threads should be under __kmp_forkjoin_lock, so
   // resizing __kmp_threads does not need additional protection if foreign
   // threads are present
 
 #if KMP_OS_WINDOWS && !KMP_DYNAMIC_LIB
   /* only for Windows static library */
   /* reclaim array entries for root threads that are already dead */
   added = __kmp_reclaim_dead_roots();
 
   if (nNeed) {
     nNeed -= added;
if (!initial_thread && ompt_enabled.enabled) {
     ompt_set_thread_state(root_thread, ompt_state_overhead);
 
     if (ompt_enabled.ompt_callback_thread_begin) {
       ompt_callbacks.ompt_callback(ompt_callback_thread_begin)(
           ompt_thread_initial, __ompt_get_thread_data_internal());
     }
     ompt_data_t *task_data;
     ompt_data_t *parallel_data;
-    __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data, NULL);
+    __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data,
+                                  NULL);
     if (ompt_enabled.ompt_callback_implicit_task) {
       ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
           ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial);
     }
 
     ompt_set_thread_state(root_thread, ompt_state_work_serial);
   }
 #endif
KA_TRACE(
            (LPVOID) & (root->r.r_uber_thread->th),
            root->r.r_uber_thread->th.th_info.ds.ds_thread));
   __kmp_free_handle(root->r.r_uber_thread->th.th_info.ds.ds_thread);
 #endif /* KMP_OS_WINDOWS */
 
 #if OMPT_SUPPORT
   ompt_data_t *task_data;
   ompt_data_t *parallel_data;
-  __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data, NULL);
+  __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data,
+                                NULL);
   if (ompt_enabled.ompt_callback_implicit_task) {
     ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
         ompt_scope_end, parallel_data, task_data, 0, 1, ompt_task_initial);
   }
   if (ompt_enabled.ompt_callback_thread_end) {
     ompt_callbacks.ompt_callback(ompt_callback_thread_end)(
         &(root->r.r_uber_thread->th.ompt_thread_info.thread_data));
   }
if (!dispatch->th_disp_buffer) {
           (dispatch_private_info_t *)__kmp_allocate(disp_size);
 
       if (__kmp_storage_map) {
         __kmp_print_storage_map_gtid(
             gtid, &dispatch->th_disp_buffer[0],
             &dispatch->th_disp_buffer[team->t.t_max_nproc == 1
                                           ? 1
                                           : __kmp_dispatch_num_buffers],
-            disp_size, "th_%d.th_dispatch.th_disp_buffer "
-                       "(team_%d.t_dispatch[%d].th_disp_buffer)",
+            disp_size,
+            "th_%d.th_dispatch.th_disp_buffer "
             gtid, team->t.t_id, gtid);
       }
     } else {
       memset(&dispatch->th_disp_buffer[0], '\0', disp_size);
     }
 
     dispatch->th_dispatch_pr_current = 0;
     dispatch->th_dispatch_sh_current = 0;

 #endif /* USE_FAST_MEMORY */
 
   __kmp_suspend_uninitialize_thread(thread);
 
   KMP_DEBUG_ASSERT(__kmp_threads[gtid] == thread);
   TCW_SYNC_PTR(__kmp_threads[gtid], NULL);
 
   --__kmp_all_nth;
   // __kmp_nth was decremented when thread is added to the pool.
 
 #ifdef KMP_ADJUST_BLOCKTIME
   /* Adjust blocktime back to user setting or default if necessary */
   /* Middle initialization might never have occurred                */
   if (!__kmp_env_blocktime && (__kmp_avail_proc > 0)) {
     KMP_DEBUG_ASSERT(__kmp_avail_proc > 0);
     if (__kmp_nth <= __kmp_avail_proc) {
       __kmp_zero_bt = FALSE;
if (value != NULL && strcmp(value, __kmp_registration_str) == 0) {
       char *flag_val_str = NULL;
       char const *file_name = NULL;
       __kmp_str_split(tail, '-', &flag_addr_str, &tail);
       __kmp_str_split(tail, '-', &flag_val_str, &tail);
       file_name = tail;
       if (tail != NULL) {
         long *flag_addr = 0;
         long flag_val = 0;
-        KMP_SSCANF(flag_addr_str, "%p", RCAST(void**, &flag_addr));
+        KMP_SSCANF(flag_addr_str, "%p", RCAST(void **, &flag_addr));
         KMP_SSCANF(flag_val_str, "%lx", &flag_val);
         if (flag_addr != 0 && flag_val != 0 && strcmp(file_name, "") != 0) {
           // First, check whether environment-encoded address is mapped into
           // addr space.
           // If so, dereference it to see if it still has the right value.
           if (__kmp_is_address_mapped(flag_addr) && *flag_addr == flag_val) {
             neighbor = 1;
           } else {

 #if KMP_OS_UNIX && KMP_DYNAMIC_LIB // shared memory is with dynamic library
         // close shared memory.
         shm_unlink(shm_name); // this removes file in /dev/shm
 #else
         // Clear the variable and try to register library again.
         __kmp_env_unset(name);
 #endif
       } break;
-      default: { KMP_DEBUG_ASSERT(0); } break;
+      default: {
+        KMP_DEBUG_ASSERT(0);
+      } break;
       }
     }
     KMP_INTERNAL_FREE((void *)value);
 #if KMP_OS_UNIX && KMP_DYNAMIC_LIB // shared memory is with dynamic library
     KMP_INTERNAL_FREE((void *)shm_name);
 #endif
   } // while
   KMP_INTERNAL_FREE((void *)name);

 #if OMPT_SUPPORT
   void *dummy;
   void **exit_frame_p;
   ompt_data_t *my_task_data;
   ompt_data_t *my_parallel_data;
   int ompt_team_size;
 
   if (ompt_enabled.enabled) {
-    exit_frame_p = &(
-        team->t.t_implicit_task_taskdata[tid].ompt_task_info.frame.exit_frame.ptr);
+    exit_frame_p = &(team->t.t_implicit_task_taskdata[tid]
+                         .ompt_task_info.frame.exit_frame.ptr);
   } else {
     exit_frame_p = &dummy;
   }
 
   my_task_data =
       &(team->t.t_implicit_task_taskdata[tid].ompt_task_info.task_data);
   my_parallel_data = &(team->t.ompt_team_info.parallel_data);
   if (ompt_enabled.ompt_callback_implicit_task) {

 #endif
 
   rc = __kmp_invoke_microtask((microtask_t)TCR_SYNC_PTR(team->t.t_pkfn), gtid,
                               tid, (int)team->t.t_argc, (void **)team->t.t_argv
 #if OMPT_SUPPORT
                               ,
                               exit_frame_p
 #endif
-                              );
 #if OMPT_SUPPORT
   *exit_frame_p = NULL;
-   this_thr->th.ompt_thread_info.parallel_flags |= ompt_parallel_team;
 #endif
 
 #if KMP_STATS_ENABLED
   if (previous_state == stats_state_e::TEAMS_REGION) {
     KMP_SET_THREAD_STATE(previous_state);
   }
   KMP_POP_PARTITIONED_TIMER();
 #endif

 void __kmp_internal_join(ident_t *id, int gtid, kmp_team_t *team) {
   kmp_info_t *this_thr = __kmp_threads[gtid];
 
   KMP_DEBUG_ASSERT(team);
   KMP_DEBUG_ASSERT(this_thr->th.th_team == team);
   KMP_ASSERT(KMP_MASTER_GTID(gtid));
   KMP_MB(); /* Flush all pending memory write invalidates.  */
 
   /* Join barrier after fork */
 
 #ifdef KMP_DEBUG
   if (__kmp_threads[gtid] &&
       __kmp_threads[gtid]->th.th_team_nproc != team->t.t_nproc) {
     __kmp_printf("GTID: %d, __kmp_threads[%d]=%p\n", gtid, gtid,
                  __kmp_threads[gtid]);
     __kmp_printf("__kmp_threads[%d]->th.th_team_nproc=%d, TEAM: %p, "
                  "team->t.t_nproc=%d\n",
#if OMPT_OPTIONAL
     if (ompt_enabled.ompt_callback_sync_region) {
       ompt_callbacks.ompt_callback(ompt_callback_sync_region)(
           ompt_sync_region_barrier_implicit, ompt_scope_end, NULL, task_data,
           codeptr);
     }
 #endif
     if (!KMP_MASTER_TID(ds_tid) && ompt_enabled.ompt_callback_implicit_task) {
       ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
-          ompt_scope_end, NULL, task_data, 0, ds_tid, ompt_task_implicit); // TODO: Can this be ompt_task_initial?
+          ompt_scope_end, NULL, task_data, 0, ds_tid,
+          ompt_task_implicit); // TODO: Can this be ompt_task_initial?
     }
   }
 #endif
 
   KMP_MB(); /* Flush all pending memory write invalidates.  */
   KMP_ASSERT(this_thr->th.th_team == team);
 }
 

  * T {thread_identifier} - native thread identifier (integer)
  * N {num_threads}       - omp_get_num_threads()
  * A {ancestor_tnum}     - omp_get_ancestor_thread_num(omp_get_level()-1)
  * a {thread_affinity}   - comma separated list of integers or integer ranges
  *                         (values of affinity mask)
  *
  * Implementation-specific field types can be added
  * If a type is unknown, print "undefined"
  */
 
 // Structure holding the short name, long name, and corresponding data type
 // for snprintf.  A table of these will represent the entire valid keyword
 // field types.
 typedef struct kmp_affinity_format_field_t {
   char short_name; // from spec e.g., L -> thread level
   const char *long_name; // from spec thread_level -> thread level
   char field_format; // data type for snprintf (typically 'd' or 's'
#endif
   return rc;
 }
 
 /*
  * Return number of characters needed to hold the affinity string
  * (not including null byte character)
  * The resultant string is printed to buffer, which the caller can then
  * handle afterwards
  */
 size_t __kmp_aux_capture_affinity(int gtid, const char *format,
                                   kmp_str_buf_t *buffer) {
   const char *parse_ptr;
   size_t retval;
   const kmp_info_t *th;
   kmp_str_buf_t field;
 
   KMP_DEBUG_ASSERT(buffer);
if (__kmp_pause_status != kmp_not_paused) {
       return 0;
     }
   } else {
     // error message about invalid level
     return 1;
   }
 }
 
-
 void __kmp_omp_display_env(int verbose) {
   __kmp_acquire_bootstrap_lock(&__kmp_initz_lock);
   if (__kmp_init_serial == 0)
     __kmp_do_serial_initialize();
   __kmp_display_env_impl(!verbose, verbose);
   __kmp_release_bootstrap_lock(&__kmp_initz_lock);
 }

openmp/runtime/src/kmp_sched.cpp

static void __kmp_for_static_init(ident_t *loc, kmp_int32 global_tid,
                                   T *plower, T *pupper,
                                   typename traits_t<T>::signed_t *pstride,
                                   typename traits_t<T>::signed_t incr,
                                   typename traits_t<T>::signed_t chunk
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                   ,
                                   void *codeptr
 #endif
-                                  ) {
   KMP_COUNT_BLOCK(OMP_LOOP_STATIC);
   KMP_PUSH_PARTITIONED_TIMER(OMP_loop_static);
   KMP_PUSH_PARTITIONED_TIMER(OMP_loop_static_scheduling);
 
   typedef typename traits_t<T>::unsigned_t UT;
   typedef typename traits_t<T>::signed_t ST;
   /*  this all has to be changed back to TID and such.. */
   kmp_int32 gtid = global_tid;
void __kmpc_for_static_init_4(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype,
                               kmp_int32 *pupper, kmp_int32 *pstride,
                               kmp_int32 incr, kmp_int32 chunk) {
   __kmp_for_static_init<kmp_int32>(loc, gtid, schedtype, plastiter, plower,
                                    pupper, pstride, incr, chunk
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                    ,
                                    OMPT_GET_RETURN_ADDRESS(0)
 #endif
-                                       );
 }
 
 /*!
  See @ref __kmpc_for_static_init_4
  */
 void __kmpc_for_static_init_4u(ident_t *loc, kmp_int32 gtid,
                                kmp_int32 schedtype, kmp_int32 *plastiter,
                                kmp_uint32 *plower, kmp_uint32 *pupper,
                                kmp_int32 *pstride, kmp_int32 incr,
                                kmp_int32 chunk) {
   __kmp_for_static_init<kmp_uint32>(loc, gtid, schedtype, plastiter, plower,
                                     pupper, pstride, incr, chunk
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                     ,
                                     OMPT_GET_RETURN_ADDRESS(0)
 #endif
-                                        );
 }
 
 /*!
  See @ref __kmpc_for_static_init_4
  */
 void __kmpc_for_static_init_8(ident_t *loc, kmp_int32 gtid, kmp_int32 schedtype,
                               kmp_int32 *plastiter, kmp_int64 *plower,
                               kmp_int64 *pupper, kmp_int64 *pstride,
                               kmp_int64 incr, kmp_int64 chunk) {
   __kmp_for_static_init<kmp_int64>(loc, gtid, schedtype, plastiter, plower,
                                    pupper, pstride, incr, chunk
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                    ,
                                    OMPT_GET_RETURN_ADDRESS(0)
 #endif
-                                       );
 }
 
 /*!
  See @ref __kmpc_for_static_init_4
  */
 void __kmpc_for_static_init_8u(ident_t *loc, kmp_int32 gtid,
                                kmp_int32 schedtype, kmp_int32 *plastiter,
                                kmp_uint64 *plower, kmp_uint64 *pupper,
                                kmp_int64 *pstride, kmp_int64 incr,
                                kmp_int64 chunk) {
   __kmp_for_static_init<kmp_uint64>(loc, gtid, schedtype, plastiter, plower,
                                     pupper, pstride, incr, chunk
 #if OMPT_SUPPORT && OMPT_OPTIONAL
                                     ,
                                     OMPT_GET_RETURN_ADDRESS(0)
 #endif
-                                        );
 }
 /*!
 @}
 */
 
 /*!
 @ingroup WORK_SHARING
 @param    loc       Source code location

openmp/runtime/src/kmp_settings.cpp

if (ca >= 'a' && ca <= 'z')
       ca -= 'a' - 'A';
     if (cb >= 'a' && cb <= 'z')
       cb -= 'a' - 'A';
     if (ca != cb)
       return (int)(unsigned char)*a - (int)(unsigned char)*b;
     ++a;
     ++b;
   }
-  return *a
-             ? (*b && *b != sentinel)
+  return *a                       ? (*b && *b != sentinel)
                                         ? (int)(unsigned char)*a - (int)(unsigned char)*b
                                         : 1
-             : (*b && *b != sentinel) ? -1 : 0;
+         : (*b && *b != sentinel) ? -1
+                                  : 0;
 }
 
 // =============================================================================
 // Table structures and helper functions.
 
 typedef struct __kmp_setting kmp_setting_t;
 typedef struct __kmp_stg_ss_data kmp_stg_ss_data_t;
 typedef struct __kmp_stg_wp_data kmp_stg_wp_data_t;
struct __kmp_stg_fr_data {
   int force; // 0 -- KMP_DETERMINISTIC_REDUCTION, 1 -- KMP_FORCE_REDUCTION.
   kmp_setting_t **rivals; // Array of pointers to rivals (including itself).
 }; // struct __kmp_stg_fr_data
 
 static int __kmp_stg_check_rivals( // 0 -- Ok, 1 -- errors found.
     char const *name, // Name of variable.
     char const *value, // Value of the variable.
     kmp_setting_t **rivals // List of rival settings (must include current one).
-    );
 
 // -----------------------------------------------------------------------------
 // Helper parse functions.
 
 static void __kmp_stg_parse_bool(char const *name, char const *value,
                                  int *out) {
   if (__kmp_str_match_true(value)) {
     *out = TRUE;

 
 static void __kmp_stg_parse_int(
     char const
         *name, // I: Name of environment variable (used in warning messages).
     char const *value, // I: Value of environment variable to parse.
     int min, // I: Minimum allowed value.
     int max, // I: Maximum allowed value.
     int *out // O: Output (parsed) value.
-    ) {
   char const *msg = NULL;
   kmp_uint64 uint = *out;
   __kmp_str_to_uint(value, &uint, &msg);
   if (msg == NULL) {
     if (uint < (unsigned int)min) {
       msg = KMP_I18N_STR(ValueTooSmall);
       uint = min;
     } else if (uint > (unsigned int)max) {

 
 static void __kmp_stg_parse_stackpad(char const *name, char const *value,
                                      void *data) {
   __kmp_stg_parse_int(name, // Env var name
                       value, // Env var value
                       KMP_MIN_STKPADDING, // Min value
                       KMP_MAX_STKPADDING, // Max value
                       &__kmp_stkpadding // Var to initialize
-                      );
 } // __kmp_stg_parse_stackpad
 
 static void __kmp_stg_print_stackpad(kmp_str_buf_t *buffer, char const *name,
                                      void *data) {
   __kmp_stg_print_int(buffer, name, __kmp_stkpadding);
 } // __kmp_stg_print_stackpad
 
 // -----------------------------------------------------------------------------
if (count > 0) {
       KMP_WARNING(AffNoParam, name, "disabled");
     }
   } break;
   case affinity_default: {
     if (count > 0) {
       KMP_WARNING(AffNoParam, name, "default");
     }
   } break;
-  default: { KMP_ASSERT(0); }
+  default: {
+    KMP_ASSERT(0);
+  }
   }
 } // __kmp_parse_affinity_env
 
 static void __kmp_stg_parse_affinity(char const *name, char const *value,
                                      void *data) {
   kmp_setting_t **rivals = (kmp_setting_t **)data;
   int rc;
 
__kmp_str_buf_print(buffer, "%d,%d'\n",
                       __kmp_adaptive_backoff_params.max_badness);
 } // __kmp_stg_print_adaptive_lock_props
 
 #if KMP_DEBUG_ADAPTIVE_LOCKS
 
 static void __kmp_stg_parse_speculative_statsfile(char const *name,
                                                   char const *value,
                                                   void *data) {
-  __kmp_stg_parse_file(name, value, "", CCAST(char**, &__kmp_speculative_statsfile));
+  __kmp_stg_parse_file(name, value, "",
+                       CCAST(char **, &__kmp_speculative_statsfile));
 } // __kmp_stg_parse_speculative_statsfile
 
 static void __kmp_stg_print_speculative_statsfile(kmp_str_buf_t *buffer,
                                                   char const *name,
                                                   void *data) {
   if (__kmp_str_match("-", 0, __kmp_speculative_statsfile)) {
     __kmp_stg_print_str(buffer, name, "stdout");
   } else {
static void __kmp_stg_print_forkjoin_frames_mode(kmp_str_buf_t *buffer,
                                                  char const *name, void *data) {
   __kmp_stg_print_int(buffer, name, __kmp_forkjoin_frames_mode);
 } // __kmp_stg_print_forkjoin_frames
 #endif /* USE_ITT_BUILD */
 
 // -----------------------------------------------------------------------------
 // KMP_ENABLE_TASK_THROTTLING
 
-static void __kmp_stg_parse_task_throttling(char const *name,
-                                            char const *value, void *data) {
+static void __kmp_stg_parse_task_throttling(char const *name, char const *value,
+                                            void *data) {
   __kmp_stg_parse_bool(name, value, &__kmp_enable_task_throttling);
 } // __kmp_stg_parse_task_throttling
 
-
 static void __kmp_stg_print_task_throttling(kmp_str_buf_t *buffer,
                                             char const *name, void *data) {
   __kmp_stg_print_bool(buffer, name, __kmp_enable_task_throttling);
 } // __kmp_stg_print_task_throttling
 
 #if KMP_HAVE_MWAIT || KMP_HAVE_UMWAIT
 // -----------------------------------------------------------------------------
 // KMP_USER_LEVEL_MWAIT
else {
     }
     __kmp_str_buf_print(buffer, ": %s\n", KMP_I18N_STR(NotDefined));
   }
 } // __kmp_stg_print_omp_tool_libraries
 
 static char *__kmp_tool_verbose_init = NULL;
 
 static void __kmp_stg_parse_omp_tool_verbose_init(char const *name,
-                                                  char const *value, void *data) {
+                                                  char const *value,
+                                                  void *data) {
   __kmp_stg_parse_str(name, value, &__kmp_tool_verbose_init);
 } // __kmp_stg_parse_omp_tool_libraries
 
 static void __kmp_stg_print_omp_tool_verbose_init(kmp_str_buf_t *buffer,
-                                                  char const *name, void *data) {
+                                                  char const *name,
+                                                  void *data) {
   if (__kmp_tool_verbose_init)
     __kmp_stg_print_str(buffer, name, __kmp_tool_libraries);
   else {
     if (__kmp_env_format) {
       KMP_STR_BUF_PRINT_NAME;
     } else {
       __kmp_str_buf_print(buffer, "   %s", name);
     }
static void __kmp_stg_parse(char const *name, char const *value) {
   }
 
 } // __kmp_stg_parse
 
 static int __kmp_stg_check_rivals( // 0 -- Ok, 1 -- errors found.
     char const *name, // Name of variable.
     char const *value, // Value of the variable.
     kmp_setting_t **rivals // List of rival settings (must include current one).
-    ) {
 
   if (rivals == NULL) {
     return 0;
   }
 
   // Loop thru higher priority settings (listed before current).
   int i = 0;
   for (; strcmp(rivals[i]->name, name) != 0; i++) {
#if KMP_AFFINITY_SUPPORTED
   // Special case. KMP_AFFINITY is not a rival to other affinity env vars
   // if no affinity type is specified.  We want to allow
   // KMP_AFFINITY=[no],verbose/[no]warnings/etc.  to be enabled when
   // specifying the affinity type via GOMP_CPU_AFFINITY or the OMP 4.0
   // affinity mechanism.
   __kmp_affinity_notype = NULL;
   char const *aff_str = __kmp_env_blk_var(&block, "KMP_AFFINITY");
   if (aff_str != NULL) {
     // Check if the KMP_AFFINITY type is specified in the string.
     // We just search the string for "compact", "scatter", etc.
     // without really parsing the string.  The syntax of the
     // KMP_AFFINITY env var is such that none of the affinity
     // type names can appear anywhere other that the type
     // specifier, even as substrings.
     //
     // I can't find a case-insensitive version of strstr on Windows* OS.
     // Use the case-sensitive version for now.
 
 #if KMP_OS_WINDOWS
 #define FIND strstr
 #else
 #define FIND strcasestr
 #endif
 
     if ((FIND(aff_str, "none") == NULL) &&
void __kmp_env_print() {
   for (i = 0; i < block.count; ++i) {
     char const *name = block.vars[i].name;
     char const *value = block.vars[i].value;
     if ((KMP_STRLEN(name) > 4 && strncmp(name, "KMP_", 4) == 0) ||
         strncmp(name, "OMP_", 4) == 0
 #ifdef KMP_GOMP_COMPAT
         || strncmp(name, "GOMP_", 5) == 0
 #endif // KMP_GOMP_COMPAT
-        ) {
       __kmp_str_buf_print(&buffer, "   %s=%s\n", name, value);
     }
   }
   __kmp_str_buf_print(&buffer, "\n");
 
   // Print internal (effective) settings.
   __kmp_str_buf_print(&buffer, "%s\n\n", KMP_I18N_STR(EffectiveSettings));
   for (int i = 0; i < __kmp_stg_count; ++i) {
#endif // KMP_GOMP_COMPAT
   __kmp_printf("\n");
 
 } // __kmp_env_print
 
 void __kmp_env_print_2() {
   __kmp_display_env_impl(__kmp_display_env, __kmp_display_env_verbose);
 } // __kmp_env_print_2
 
-
 void __kmp_display_env_impl(int display_env, int display_env_verbose) {
   kmp_env_blk_t block;
   kmp_str_buf_t buffer;
 
   __kmp_env_format = 1;
 
   __kmp_stg_init();
   __kmp_str_buf_init(&buffer);
 
   __kmp_env_blk_init(&block, NULL);
   __kmp_env_blk_sort(&block);
 
   __kmp_str_buf_print(&buffer, "\n%s\n", KMP_I18N_STR(DisplayEnvBegin));
   __kmp_str_buf_print(&buffer, "   _OPENMP='%d'\n", __kmp_openmp_version);
 
   for (int i = 0; i < __kmp_stg_count; ++i) {
     if (__kmp_stg_table[i].print != NULL &&
-        ((display_env &&
-          strncmp(__kmp_stg_table[i].name, "OMP_", 4) == 0) ||
+        ((display_env && strncmp(__kmp_stg_table[i].name, "OMP_", 4) == 0) ||
          display_env_verbose)) {
       __kmp_stg_table[i].print(&buffer, __kmp_stg_table[i].name,
                                __kmp_stg_table[i].data);
     }
   }
 
   __kmp_str_buf_print(&buffer, "%s\n", KMP_I18N_STR(DisplayEnvEnd));
   __kmp_str_buf_print(&buffer, "\n");

openmp/runtime/src/kmp_stats.h

  * \details Explicit timers are ones where we need to allocate a timer itself
  * (as well as the accumulated timing statistics). We allocate these on a
  * per-thread basis, and explicitly start and stop them. Block timers just
  * allocate the timer itself on the stack, and use the destructor to notice
  * block exit; they don't need to be defined here. The name here should be the
  * same as that of a timer above.
  *
  * @ingroup STATS_GATHERING
  */
 #define KMP_FOREACH_EXPLICIT_TIMER(macro, arg) KMP_FOREACH_TIMER(macro, arg)
 
 #define ENUMERATE(name, ignore, prefix) prefix##name,
 enum timer_e { KMP_FOREACH_TIMER(ENUMERATE, TIMER_) TIMER_LAST };
 
 enum explicit_timer_e {
   KMP_FOREACH_EXPLICIT_TIMER(ENUMERATE, EXPLICIT_TIMER_) EXPLICIT_TIMER_LAST
 };

  *
  * @param name timer name as specified under the KMP_FOREACH_TIMER() macro
  * @param value double precision sample value to add to statistics for the timer
  *
  * \details Use KMP_COUNT_VALUE(name, value) macro to add a particular value to
  * a timer statistics.
  *
  * @ingroup STATS_GATHERING
  */
 #define KMP_COUNT_VALUE(name, value)                                           \
   __kmp_stats_thread_ptr->getTimer(TIMER_##name)->addSample((double)value)
 
 /*!
  * \brief Increments specified counter (name).
  *
  * @param name counter name as specified under the KMP_FOREACH_COUNTER() macro
  *
  * \details Use KMP_COUNT_BLOCK(name, value) macro to increment a statistics
  * counter for the executing thread.
  *
  * @ingroup STATS_GATHERING
  */
 #define KMP_COUNT_BLOCK(name)                                                  \
   __kmp_stats_thread_ptr->getCounter(COUNTER_##name)->increment()
 
 /*!
  * \brief Outputs the current thread statistics and reset them.
  *
  * @param heading_string heading put above the final stats output
  *
  * \details Explicitly stops all timers and outputs all stats. Environment
  * variable, `OMPTB_STATSFILE=filename`, can be used to output the stats to a
  * filename instead of stderr. Environment variable,
  * `OMPTB_STATSTHREADS=true|undefined`, can be used to output thread specific
  * stats. For now the `OMPTB_STATSTHREADS` environment variable can either be
  * defined with any value, which will print out thread specific stats, or it can
  * be undefined (not specified in the environment) and thread specific stats
  * won't be printed. It should be noted that all statistics are reset when this
  * macro is called.
  *
  * @ingroup STATS_GATHERING
  */
 #define KMP_OUTPUT_STATS(heading_string) __kmp_output_stats(heading_string)
 
 /*!
  * \brief Initializes the partitioned timers to begin with name.
  *
  * @param name timer which you want this thread to begin with
  *
  * @ingroup STATS_GATHERING
  */
 #define KMP_INIT_PARTITIONED_TIMERS(name)                                      \
   __kmp_stats_thread_ptr->getPartitionedTimers()->init(explicitTimer(          \
       __kmp_stats_thread_ptr->getTimer(TIMER_##name), TIMER_##name))
 
 #define KMP_TIME_PARTITIONED_BLOCK(name)                                       \
   blockPartitionedTimer __PBLOCKTIME__(                                        \
       __kmp_stats_thread_ptr->getPartitionedTimers(),                          \
       explicitTimer(__kmp_stats_thread_ptr->getTimer(TIMER_##name),            \
blockThreadState __BTHREADSTATE__(__kmp_stats_thread_ptr->getStatePointer(), \
                                     state_name)
 
 /*!
  * \brief resets all stats (counters to 0, timers to 0 elapsed ticks)
  *
  * \details Reset all stats for all threads.
  *
  * @ingroup STATS_GATHERING
  */
 #define KMP_RESET_STATS() __kmp_reset_stats()
 
 #if (KMP_DEVELOPER_STATS)
 #define KMP_COUNT_DEVELOPER_VALUE(n, v) KMP_COUNT_VALUE(n, v)
 #define KMP_COUNT_DEVELOPER_BLOCK(n) KMP_COUNT_BLOCK(n)
 #define KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(n) KMP_TIME_PARTITIONED_BLOCK(n)
 #define KMP_PUSH_DEVELOPER_PARTITIONED_TIMER(n) KMP_PUSH_PARTITIONED_TIMER(n)
 #define KMP_POP_DEVELOPER_PARTITIONED_TIMER(n) KMP_POP_PARTITIONED_TIMER(n)

openmp/runtime/src/kmp_stats.cpp

 #include <sstream>
 #include <stdlib.h> // for atexit
 #include <cmath>
 
 #define STRINGIZE2(x) #x
 #define STRINGIZE(x) STRINGIZE2(x)
 
 #define expandName(name, flags, ignore) {STRINGIZE(name), flags},
 statInfo timeStat::timerInfo[] = {
     KMP_FOREACH_TIMER(expandName, 0){"TIMER_LAST", 0}};
 const statInfo counter::counterInfo[] = {
     KMP_FOREACH_COUNTER(expandName, 0){"COUNTER_LAST", 0}};
 #undef expandName
 
 #define expandName(ignore1, ignore2, ignore3) {0.0, 0.0, 0.0},
 kmp_stats_output_module::rgb_color kmp_stats_output_module::timerColorInfo[] = {
     KMP_FOREACH_TIMER(expandName, 0){0.0, 0.0, 0.0}};
 #undef expandName
 
 const kmp_stats_output_module::rgb_color
     kmp_stats_output_module::globalColorArray[] = {
         {1.0, 0.0, 0.0}, // red
         {1.0, 0.6, 0.0}, // orange
         {1.0, 1.0, 0.0}, // yellow
         {0.0, 1.0, 0.0}, // green
         {0.0, 0.0, 1.0}, // blue
         {0.6, 0.2, 0.8}, // purple
         {1.0, 0.0, 1.0}, // magenta
         {0.0, 0.4, 0.2}, // dark green
kmp_stats_output_module::globalColorArray[] = {
         {0.7, 0.6, 0.0}, // gold
         {0.0, 0.0, 0.0} // black
 };
 
 // Ensure that the atexit handler only runs once.
 static uint32_t statsPrinted = 0;
 
 // output interface
 static kmp_stats_output_module *__kmp_stats_global_output = NULL;
 
 double logHistogram::binMax[] = {1.e1l, 1.e2l, 1.e3l, 1.e4l, 1.e5l, 1.e6l,
                                  1.e7l, 1.e8l, 1.e9l, 1.e10l, 1.e11l, 1.e12l,
                                  1.e13l, 1.e14l, 1.e15l, 1.e16l, 1.e17l, 1.e18l,
                                  1.e19l, 1.e20l, 1.e21l, 1.e22l, 1.e23l, 1.e24l,
                                  1.e25l, 1.e26l, 1.e27l, 1.e28l, 1.e29l, 1.e30l,
                                  // Always have infinity be the last value
                                  std::numeric_limits<double>::infinity()};
 
 /* ************* statistic member functions ************* */
 
 void statistic::addSample(double sample) {
   sample -= offset;
   KMP_DEBUG_ASSERT(std::isfinite(sample));
 
   double delta = sample - meanVal;
 
   sampleCount = sampleCount + 1;
   meanVal = meanVal + delta / sampleCount;
   m2 = m2 + delta * (sample - meanVal);
 
   minVal = std::min(minVal, sample);
   maxVal = std::max(maxVal, sample);
   if (collectingHist)
     hist.addSample(sample);
 }
 
 statistic &statistic::operator+=(const statistic &other) {
   if (other.sampleCount == 0)
     return *this;
 
   if (sampleCount == 0) {
     *this = other;
     return *this;
   }
 
statistic &statistic::operator+=(const statistic &other) {
   maxVal = std::max(maxVal, other.maxVal);
   sampleCount = newSampleCount;
   if (collectingHist)
     hist += other.hist;
 
   return *this;
 }
 
 void statistic::scale(double factor) {
   minVal = minVal * factor;
   maxVal = maxVal * factor;
   meanVal = meanVal * factor;
   m2 = m2 * factor * factor;
   return;
 }
 
 std::string statistic::format(char unit, bool total) const {
   std::string result = formatSI((double)sampleCount, 9, ' ');
 
   if (sampleCount == 0) {
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
     if (total)
       result = result + std::string(", ") + formatSI(0.0, 9, unit);
     result = result + std::string(", ") + formatSI(0.0, 9, unit);
   } else {
     result = result + std::string(", ") + formatSI(minVal, 9, unit);
     result = result + std::string(", ") + formatSI(meanVal, 9, unit);
     result = result + std::string(", ") + formatSI(maxVal, 9, unit);
     if (total)
       result =
           result + std::string(", ") + formatSI(meanVal * sampleCount, 9, unit);
     result = result + std::string(", ") + formatSI(getSD(), 9, unit);
   }
   return result;
 }
 
 /* ************* histogram member functions ************* */
 
 // Lowest bin that has anything in it
 int logHistogram::minBin() const {
   for (int i = 0; i < numBins; i++) {
     if (bins[i].count != 0)
       return i - logOffset;
   }
   return -logOffset;
 }
 
 // Highest bin that has anything in it

 void kmp_stats_output_module::printPloticusFile() {
   int i;
   int size = __kmp_stats_list->size();
   kmp_safe_raii_file_t plotOut(plotFileName, "w+");
   fprintf(plotOut, "#proc page\n"
                    "   pagesize: 15 10\n"
                    "   scale: 1.0\n\n");
 
-  fprintf(plotOut, "#proc getdata\n"
-                   "   file: %s\n\n",
+  fprintf(plotOut,
+          "#proc getdata\n"
           eventsFileName);
 
-  fprintf(plotOut, "#proc areadef\n"
-                   "   title: OpenMP Sampling Timeline\n"
-                   "   titledetails: align=center size=16\n"
-                   "   rectangle: 1 1 13 9\n"
-                   "   xautorange: datafield=2,3\n"
-                   "   yautorange: -1 %d\n\n",
+  fprintf(plotOut,
+          "#proc areadef\n"
           size);
 
   fprintf(plotOut, "#proc xaxis\n"
                    "   stubs: inc\n"
                    "   stubdetails: size=12\n"
                    "   label: Time (ticks)\n"
                    "   labeldetails: size=14\n\n");
 
-  fprintf(plotOut, "#proc yaxis\n"
-                   "   stubs: inc 1\n"
-                   "   stubrange: 0 %d\n"
-                   "   stubdetails: size=12\n"
-                   "   label: Thread #\n"
-                   "   labeldetails: size=14\n\n",
+  fprintf(plotOut,
+          "#proc yaxis\n"
           size - 1);
 
   fprintf(plotOut, "#proc bars\n"
                    "   exactcolorfield: 5\n"
                    "   axis: x\n"
                    "   locfield: 1\n"
                    "   segmentfields: 2 3\n"
                    "   barwidthfield: 4\n\n");
 
   // create legend entries corresponding to the timer color
   for (i = 0; i < TIMER_LAST; i++) {
     if (timeStat::logEvent((timer_e)i)) {
       rgb_color c = getEventColor((timer_e)i);
-      fprintf(plotOut, "#proc legendentry\n"
-                       "   sampletype: color\n"
-                       "   label: %s\n"
-                       "   details: rgb(%1.1f,%1.1f,%1.1f)\n\n",
+      fprintf(plotOut,
+              "#proc legendentry\n"
               timeStat::name((timer_e)i), c.r, c.g, c.b);
     }
   }
 
   fprintf(plotOut, "#proc legend\n"
                    "   format: down\n"
                    "   location: max max\n\n");
   return;
if (eventPrintingEnabled()) {
       kmp_stats_event_vector events = (*it)->getEventVector();
       printEvents(eventsOut, &events, t);
     }
 
     // Accumulate timers.
     for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
       // See if we should ignore this timer when aggregating
       if ((timeStat::masterOnly(s) && (t != 0)) || // Timer only valid on master
                                                    // and this thread is worker
           (timeStat::workerOnly(s) && (t == 0)) // Timer only valid on worker
           // and this thread is the master
-          ) {
         continue;
       }
 
       statistic *threadStat = (*it)->getTimer(s);
       allStats[s] += *threadStat;
 
       // Add Total stats for timers that are valid in more than one thread
       if (!timeStat::noTotal(s))

openmp/runtime/src/kmp_str.cpp

int __kmp_str_buf_vprint(kmp_str_buf_t *buffer, char const *format,
   KMP_STR_BUF_INVARIANT(buffer);
 
   for (;;) {
     int const free = buffer->size - buffer->used;
     int size;
 
     // Try to format string.
     {
-/* On Linux* OS Intel(R) 64, vsnprintf() modifies args argument, so vsnprintf()
-   crashes if it is called for the second time with the same args. To prevent
-   the crash, we have to pass a fresh intact copy of args to vsnprintf() on each
-   iteration.
-
-   Unfortunately, standard va_copy() macro is not available on Windows* OS.
-   However, it seems vsnprintf() does not modify args argument on Windows* OS.
+      /* On Linux* OS Intel(R) 64, vsnprintf() modifies args argument, so
+         vsnprintf() crashes if it is called for the second time with the same
+         args. To prevent the crash, we have to pass a fresh intact copy of args
+         to vsnprintf() on each iteration.
+
+         Unfortunately, standard va_copy() macro is not available on Windows*
+         OS. However, it seems vsnprintf() does not modify args argument on
+         Windows* OS.
       */
 
 #if !KMP_OS_WINDOWS
       va_list _args;
       va_copy(_args, args); // Make copy of args.
 #define args _args // Substitute args with its copy, _args.
 #endif // KMP_OS_WINDOWS
       rc = KMP_VSNPRINTF(buffer->str + buffer->used, free, format, args);
 #if !KMP_OS_WINDOWS

 
 /* This function is intended to compare file names. On Windows* OS file names
    are case-insensitive, so functions performs case-insensitive comparison. On
    Linux* OS it performs case-sensitive comparison. Note: The function returns
    *true* if strings are *equal*. */
 int __kmp_str_eqf( // True, if strings are equal, false otherwise.
     char const *lhs, // First string.
     char const *rhs // Second string.
-    ) {
   int result;
 #if KMP_OS_WINDOWS
   result = (_stricmp(lhs, rhs) == 0);
 #else
   result = (strcmp(lhs, rhs) == 0);
 #endif
   return result;
 } // __kmp_str_eqf
2. __kmp_thread_malloc() cannot be used because it requires pointer to thread
       (for example, in __kmp_register_library_startup()) when no thread
       structures are allocated yet.
    So standard malloc() is the only available option.
 */
 
 char *__kmp_str_format( // Allocated string.
     char const *format, // Format string.
     ... // Other parameters.
-    ) {
   va_list args;
   int size = 512;
   char *buffer = NULL;
   int rc;
 
   // Allocate buffer.
   buffer = (char *)KMP_INTERNAL_MALLOC(size);
   if (buffer == NULL) {
while (found) {
     found = strchr(found + 1, search_for);
   }
 } // __kmp_str_replace
 
 void __kmp_str_split(char *str, // I: String to split.
                      char delim, // I: Character to split on.
                      char **head, // O: Pointer to head (may be NULL).
                      char **tail // O: Pointer to tail (may be NULL).
-                     ) {
   char *h = str;
   char *t = NULL;
   if (str != NULL) {
     char *ptr = strchr(str, delim);
     if (ptr != NULL) {
       *ptr = 0;
       t = ptr + 1;
     }
   }
   if (head != NULL) {
     *head = h;
   }
   if (tail != NULL) {
     *tail = t;
   }
 } // __kmp_str_split
 
 /* strtok_r() is not available on Windows* OS. This function reimplements
    strtok_r(). */
 char *__kmp_str_token(
     char *str, // String to split into tokens. Note: String *is* modified!
     char const *delim, // Delimiters.
     char **buf // Internal buffer.
-    ) {
   char *token = NULL;
 #if KMP_OS_WINDOWS
   // On Windows* OS there is no strtok_r() function. Let us implement it.
   if (str != NULL) {
     *buf = str; // First call, initialize buf.
   }
   *buf += strspn(*buf, delim); // Skip leading delimiters.
   if (**buf != 0) { // Rest of the string is not yet empty.
/* The routine parses input string. It is expected it is a unsigned integer with
    value. In case of overflow *size is set to KMP_SIZE_T_MAX, in case of unknown
    unit *size is set to zero. */
 void __kmp_str_to_size( // R: Error code.
     char const *str, // I: String of characters, unsigned number and unit ("b",
     // "kb", etc).
     size_t *out, // O: Parsed number.
     size_t dfactor, // I: The factor if none of the letters specified.
     char const **error // O: Null if everything is ok, error message otherwise.
-    ) {
 
   size_t value = 0;
   size_t factor = 0;
   int overflow = 0;
   int i = 0;
   int digit;
 
   KMP_DEBUG_ASSERT(str != NULL);
#undef _case
   *error = NULL;
   *out = value;
 } // __kmp_str_to_size
 
 void __kmp_str_to_uint( // R: Error code.
     char const *str, // I: String of characters, unsigned number.
     kmp_uint64 *out, // O: Parsed number.
     char const **error // O: Null if everything is ok, error message otherwise.
-    ) {
   size_t value = 0;
   int overflow = 0;
   int i = 0;
   int digit;
 
   KMP_DEBUG_ASSERT(str != NULL);
 
   // Skip spaces.

openmp/runtime/src/kmp_taskdeps.h

 /*
  * kmp_taskdeps.h
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_TASKDEPS_H
 #define KMP_TASKDEPS_H
 
 #include "kmp.h"
 
 #define KMP_ACQUIRE_DEPNODE(gtid, n) __kmp_acquire_lock(&(n)->dn.lock, (gtid))
 #define KMP_RELEASE_DEPNODE(gtid, n) __kmp_release_lock(&(n)->dn.lock, (gtid))
 

openmp/runtime/src/kmp_taskdeps.cpp

 
 static inline kmp_depnode_t *__kmp_node_ref(kmp_depnode_t *node) {
   KMP_ATOMIC_INC(&node->dn.nrefs);
   return node;
 }
 
 enum { KMP_DEPHASH_OTHER_SIZE = 97, KMP_DEPHASH_MASTER_SIZE = 997 };
 
-size_t sizes[] = { 997, 2003, 4001, 8191, 16001, 32003, 64007, 131071, 270029 };
+size_t sizes[] = {997, 2003, 4001, 8191, 16001, 32003, 64007, 131071, 270029};
 const size_t MAX_GEN = 8;
 
 static inline size_t __kmp_dephash_hash(kmp_intptr_t addr, size_t hsize) {
   // TODO alternate to try: set = (((Addr64)(addrUsefulBits * 9.618)) %
   // m_num_sets );
   return ((addr >> 6) ^ (addr >> 2)) % hsize;
 }
 
for (size_t i = 0; i < h_size; i++)
     h->buckets[i] = 0;
 
   return h;
 }
 
 #define ENTRY_LAST_INS 0
 #define ENTRY_LAST_MTXS 1
 
-static kmp_dephash_entry *
-__kmp_dephash_find(kmp_info_t *thread, kmp_dephash_t **hash, kmp_intptr_t addr) {
+static kmp_dephash_entry *__kmp_dephash_find(kmp_info_t *thread,
+                                             kmp_dephash_t **hash,
+                                             kmp_intptr_t addr) {
   kmp_dephash_t *h = *hash;
-  if (h->nelements != 0
-      && h->nconflicts/h->size >= 1) {
+  if (h->nelements != 0 && h->nconflicts / h->size >= 1) {
     *hash = __kmp_dephash_extend(thread, h);
     h = *hash;
   }
   size_t bucket = __kmp_dephash_hash(addr, h->size);
 
   kmp_dephash_entry_t *entry;
   for (entry = h->buckets[bucket]; entry; entry = entry->next_in_bucket)
     if (entry->addr == addr)
if (ompt_enabled.ompt_callback_task_create) {
       ompt_callbacks.ompt_callback(ompt_callback_task_create)(
           &(current_task->ompt_task_info.task_data),
           &(current_task->ompt_task_info.frame),
           &(new_taskdata->ompt_task_info.task_data),
           ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 1,
           OMPT_LOAD_OR_GET_RETURN_ADDRESS(gtid));
     }
 
-    new_taskdata->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
+    new_taskdata->ompt_task_info.frame.enter_frame.ptr =
+        OMPT_GET_FRAME_ADDRESS(0);
   }
 
 #if OMPT_OPTIONAL
   /* OMPT grab all dependences if requested by the tool */
-  if (ndeps + ndeps_noalias > 0 &&
-      ompt_enabled.ompt_callback_dependences) {
+  if (ndeps + ndeps_noalias > 0 && ompt_enabled.ompt_callback_dependences) {
     kmp_int32 i;
 
     int ompt_ndeps = ndeps + ndeps_noalias;
     ompt_dependence_t *ompt_deps = (ompt_dependence_t *)KMP_OMPT_DEPS_ALLOC(
         thread, (ndeps + ndeps_noalias) * sizeof(ompt_dependence_t));
 
     KMP_ASSERT(ompt_deps != NULL);
 

openmp/runtime/src/kmp_tasking.cpp

 //   Initialize OMPT fields maintained by a task. This will only be called after
 //   ompt_start_tool, so we already know whether ompt is enabled or not.
 
 static inline void __ompt_task_init(kmp_taskdata_t *task, int tid) {
   // The calls to __ompt_task_init already have the ompt_enabled condition.
   task->ompt_task_info.task_data.value = 0;
   task->ompt_task_info.frame.exit_frame = ompt_data_none;
   task->ompt_task_info.frame.enter_frame = ompt_data_none;
-  task->ompt_task_info.frame.exit_frame_flags = ompt_frame_runtime | ompt_frame_framepointer;
-  task->ompt_task_info.frame.enter_frame_flags = ompt_frame_runtime | ompt_frame_framepointer;
+  task->ompt_task_info.frame.exit_frame_flags =
+      ompt_frame_runtime | ompt_frame_framepointer;
+  task->ompt_task_info.frame.enter_frame_flags =
+      ompt_frame_runtime | ompt_frame_framepointer;
 }
 
 // __ompt_task_start:
 //   Build and trigger task-begin event
 static inline void __ompt_task_start(kmp_task_t *task,
                                      kmp_taskdata_t *current_task,
                                      kmp_int32 gtid) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
static void __kmpc_omp_task_begin_if0_template(ident_t *loc_ref, kmp_int32 gtid,
   __kmp_task_start(gtid, task, current_task);
 
 #if OMPT_SUPPORT
   if (ompt) {
     if (current_task->ompt_task_info.frame.enter_frame.ptr == NULL) {
       current_task->ompt_task_info.frame.enter_frame.ptr =
           taskdata->ompt_task_info.frame.exit_frame.ptr = frame_address;
       current_task->ompt_task_info.frame.enter_frame_flags =
-          taskdata->ompt_task_info.frame.exit_frame_flags = ompt_frame_application | ompt_frame_framepointer;
+          taskdata->ompt_task_info.frame.exit_frame_flags =
+              ompt_frame_application | ompt_frame_framepointer;
     }
     if (ompt_enabled.ompt_callback_task_create) {
       ompt_task_info_t *parent_info = &(current_task->ompt_task_info);
       ompt_callbacks.ompt_callback(ompt_callback_task_create)(
           &(parent_info->task_data), &(parent_info->frame),
           &(taskdata->ompt_task_info.task_data),
           ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(taskdata), 0,
           return_address);
#endif
     // td_flags.executing must be marked as 0 after __kmp_release_deps has been
     // called. Othertwise, if a task is executed immediately from the
     // release_deps code, the flag will be reset to 1 again by this same
     // function
     KMP_DEBUG_ASSERT(taskdata->td_flags.executing == 1);
     taskdata->td_flags.executing = 0; // suspend the finishing task
   }
 
-
   KA_TRACE(
       20, ("__kmp_task_finish: T#%d finished task %p, %d incomplete children\n",
            gtid, taskdata, children));
 
   // Free this task and then ancestor tasks if they have no children.
   // Restore th_current_task first as suggested by John:
   // johnmc: if an asynchronous inquiry peers into the runtime system
   // it doesn't see the freed task as the current task.
static void __kmpc_omp_task_complete_if0_template(ident_t *loc_ref,
   KA_TRACE(10, ("__kmpc_omp_task_complete_if0(exit): T#%d loc=%p task=%p\n",
                 gtid, loc_ref, KMP_TASK_TO_TASKDATA(task)));
 
 #if OMPT_SUPPORT
   if (ompt) {
     ompt_frame_t *ompt_frame;
     __ompt_get_task_info_internal(0, NULL, NULL, &ompt_frame, NULL, NULL);
     ompt_frame->enter_frame = ompt_data_none;
-    ompt_frame->enter_frame_flags = ompt_frame_runtime | ompt_frame_framepointer;
+    ompt_frame->enter_frame_flags =
+        ompt_frame_runtime | ompt_frame_framepointer;
   }
 #endif
 
   return;
 }
 
 #if OMPT_SUPPORT
 OMPT_NOINLINE
if (flags->tiedness == TASK_UNTIED)
     taskdata->td_last_tied = NULL; // will be set when the task is scheduled
   else
     taskdata->td_last_tied = taskdata;
   taskdata->td_allow_completion_event.type = KMP_EVENT_UNINITIALIZED;
 #if OMPT_SUPPORT
   if (UNLIKELY(ompt_enabled.enabled))
     __ompt_task_init(taskdata, gtid);
 #endif
-// Only need to keep track of child task counts if team parallel and tasking not
-// serialized or if it is a proxy or detachable task
-  if (flags->proxy == TASK_PROXY ||
-      flags->detachable == TASK_DETACHABLE ||
-      !(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser))
-  {
+  // Only need to keep track of child task counts if team parallel and tasking
+  // not serialized or if it is a proxy or detachable task
+  if (flags->proxy == TASK_PROXY || flags->detachable == TASK_DETACHABLE ||
+      !(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser)) {
     KMP_ATOMIC_INC(&parent_task->td_incomplete_child_tasks);
     if (parent_task->td_taskgroup)
       KMP_ATOMIC_INC(&parent_task->td_taskgroup->count);
     // Only need to keep track of allocated child tasks for explicit tasks since
     // implicit not deallocated
     if (taskdata->td_parent->td_flags.tasktype == TASK_EXPLICIT) {
       KMP_ATOMIC_INC(&taskdata->td_parent->td_allocated_child_tasks);
     }

 kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid,
                                   kmp_int32 flags, size_t sizeof_kmp_task_t,
                                   size_t sizeof_shareds,
                                   kmp_routine_entry_t task_entry) {
   kmp_task_t *retval;
   kmp_tasking_flags_t *input_flags = (kmp_tasking_flags_t *)&flags;
   __kmp_assert_valid_gtid(gtid);
   input_flags->native = FALSE;
   // __kmp_task_alloc() sets up all other runtime flags
   KA_TRACE(10, ("__kmpc_omp_task_alloc(enter): T#%d loc=%p, flags=(%s %s %s) "
                 "sizeof_task=%ld sizeof_shared=%ld entry=%p\n",
                 gtid, loc_ref, input_flags->tiedness ? "tied  " : "untied",
                 input_flags->proxy ? "proxy" : "",
                 input_flags->detachable ? "detachable" : "", sizeof_kmp_task_t,
                 sizeof_shareds, task_entry));
 
   retval = __kmp_task_alloc(loc_ref, gtid, input_flags, sizeof_kmp_task_t,

 #if USE_ITT_BUILD && USE_ITT_NOTIFY
     if (kmp_itt_count_task) {
       // Barrier imbalance - adjust arrive time with the task duration
       thread->th.th_bar_arrive_time += (__itt_get_timestamp() - cur_time);
     }
     KMP_FSYNC_CANCEL(taskdata); // destroy self (just executed)
     KMP_FSYNC_RELEASING(taskdata->td_parent); // releasing parent
 #endif
-
   }
 
   // Proxy tasks are not handled by the runtime
   if (taskdata->td_flags.proxy != TASK_PROXY) {
     ANNOTATE_HAPPENS_BEFORE(taskdata->td_parent);
 #if OMPT_SUPPORT
     if (UNLIKELY(ompt_enabled.enabled)) {
       thread->th.ompt_thread_info = oldInfo;

 
 #if OMPT_SUPPORT
   kmp_taskdata_t *parent = NULL;
   if (UNLIKELY(ompt_enabled.enabled)) {
     if (!new_taskdata->td_flags.started) {
       OMPT_STORE_RETURN_ADDRESS(gtid);
       parent = new_taskdata->td_parent;
       if (!parent->ompt_task_info.frame.enter_frame.ptr) {
-        parent->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
+        parent->ompt_task_info.frame.enter_frame.ptr =
+            OMPT_GET_FRAME_ADDRESS(0);
       }
       if (ompt_enabled.ompt_callback_task_create) {
         ompt_data_t task_data = ompt_data_none;
         ompt_callbacks.ompt_callback(ompt_callback_task_create)(
             parent ? &(parent->ompt_task_info.task_data) : &task_data,
             parent ? &(parent->ompt_task_info.frame) : NULL,
             &(new_taskdata->ompt_task_info.task_data),
             ompt_task_explicit | TASK_TYPE_DETAILS_FORMAT(new_taskdata), 0,

 
 #ifdef BUILD_TIED_TASK_STACK
         // GEH: Figure out if this is the right thing to do
         for (i = maxthreads; i < nthreads; i++) {
           kmp_thread_data_t *thread_data = &(*threads_data_p)[i];
           __kmp_init_task_stack(__kmp_gtid_from_thread(thread), thread_data);
         }
 #endif // BUILD_TIED_TASK_STACK
-        // Install the new data and free the old data
         (*threads_data_p) = new_data;
         __kmp_free(old_data);
       } else {
         KE_TRACE(10, ("__kmp_realloc_task_threads_data: T#%d allocating "
                       "threads data for task_team %p, size = %d\n",
                       __kmp_gtid_from_thread(thread), task_team, nthreads));
         // Make the initial allocate for threads_data array, and zero entries
         // Cannot use __kmp_thread_calloc() because threads not around for
#endif
   kmp_uint64 lower = task_bounds.get_lb();
   kmp_uint64 upper = task_bounds.get_ub();
   kmp_uint64 i;
   kmp_info_t *thread = __kmp_threads[gtid];
   kmp_taskdata_t *current_task = thread->th.th_current_task;
   kmp_task_t *next_task;
   kmp_int32 lastpriv = 0;
 
-  KMP_DEBUG_ASSERT(
-      tc == num_tasks * grainsize + (last_chunk < 0 ? last_chunk : extras));
+  KMP_DEBUG_ASSERT(tc == num_tasks * grainsize +
+                             (last_chunk < 0 ? last_chunk : extras));
   KMP_DEBUG_ASSERT(num_tasks > extras);
   KMP_DEBUG_ASSERT(num_tasks > 0);
   KA_TRACE(20, ("__kmp_taskloop_linear: T#%d: %lld tasks, grainsize %lld, "
                 "extras %lld, last_chunk %lld, i=%lld,%lld(%d)%lld, dup %p\n",
                 gtid, num_tasks, grainsize, extras, last_chunk, lower, upper,
                 ub_glob, st, task_dup));
 
   // Launch num_tasks tasks, assign grainsize iterations each task
for (i = 0; i < num_tasks; ++i) {
     KA_TRACE(40,
              ("__kmp_taskloop_linear: T#%d; task #%llu: task %p: lower %lld, "
               "upper %lld stride %lld, (offsets %p %p)\n",
               gtid, i, next_task, lower, upper, st,
               next_task_bounds.get_lower_offset(),
               next_task_bounds.get_upper_offset()));
 #if OMPT_SUPPORT
     __kmp_omp_taskloop_task(NULL, gtid, next_task,
                             codeptr_ra); // schedule new task
 #else
     __kmp_omp_task(gtid, next_task, true); // schedule new task
 #endif
     lower = upper + st; // adjust lower bound for the next iteration
   }
   // free the pattern task and exit
   __kmp_task_start(gtid, task, current_task); // make internal bookkeeping
   // do not execute the pattern task, just do internal bookkeeping
#endif
   kmp_info_t *thread = __kmp_threads[gtid];
   //  kmp_taskdata_t *current_task = thread->th.th_current_task;
   kmp_task_t *next_task;
   size_t lower_offset =
       (char *)lb - (char *)task; // remember offset of lb in the task structure
   size_t upper_offset =
       (char *)ub - (char *)task; // remember offset of ub in the task structure
 
-  KMP_DEBUG_ASSERT(
-      tc == num_tasks * grainsize + (last_chunk < 0 ? last_chunk : extras));
+  KMP_DEBUG_ASSERT(tc == num_tasks * grainsize +
+                             (last_chunk < 0 ? last_chunk : extras));
   KMP_DEBUG_ASSERT(num_tasks > extras);
   KMP_DEBUG_ASSERT(num_tasks > 0);
 
   // split the loop in two halves
   kmp_uint64 lb1, ub0, tc0, tc1, ext0, ext1;
   kmp_int64 last_chunk0 = 0, last_chunk1 = 0;
   kmp_uint64 gr_size0 = grainsize;
   kmp_uint64 n_tsk0 = num_tasks >> 1; // num_tasks/2 to execute
if (grainsize > tc) {
         extras = tc % num_tasks;
       }
     }
     break;
   default:
     KMP_ASSERT2(0, "unknown scheduling of taskloop");
   }
 
-  KMP_DEBUG_ASSERT(
-      tc == num_tasks * grainsize + (last_chunk < 0 ? last_chunk : extras));
+  KMP_DEBUG_ASSERT(tc == num_tasks * grainsize +
+                             (last_chunk < 0 ? last_chunk : extras));
   KMP_DEBUG_ASSERT(num_tasks > extras);
   KMP_DEBUG_ASSERT(num_tasks > 0);
   // =========================================================================
 
   // check if clause value first
   // Also require GOMP_taskloop to reduce to linear (taskdata->td_flags.native)
   if (if_val == 0) { // if(0) specified, mark task as serial
     taskdata->td_flags.task_serial = 1;

openmp/runtime/src/kmp_threadprivate.cpp

struct private_common *kmp_threadprivate_insert(int gtid, void *pc_addr,
 
   if ((__kmp_foreign_tp) ? (KMP_INITIAL_GTID(gtid)) : (KMP_UBER_GTID(gtid))) {
     tn->par_addr = (void *)pc_addr;
   } else {
     tn->par_addr = (void *)__kmp_allocate(tn->cmn_size);
   }
 
   __kmp_release_lock(&__kmp_global_lock, gtid);
   /* +++++++++ END OF CRITICAL SECTION +++++++++ */
 
 #ifdef USE_CHECKS_COMMON
   if (pc_size > d_tn->cmn_size) {
     KC_TRACE(
         10, ("__kmp_threadprivate_insert: THREADPRIVATE: %p (%" KMP_UINTPTR_SPEC
              " ,%" KMP_UINTPTR_SPEC ")\n",
              pc_addr, pc_size, d_tn->cmn_size));
     KMP_FATAL(TPCommonBlocksInconsist);

openmp/runtime/src/kmp_utility.cpp

if (bits_seen == 1) {
     current_bit >>= 1;
   }
 
   return ((int)((current_bit - 1) & apic_id));
 }
 
 static kmp_uint64 __kmp_parse_frequency( // R: Frequency in Hz.
     char const *frequency // I: Float number and unit: MHz, GHz, or TGz.
-    ) {
 
   double value = 0.0;
   char *unit = NULL;
   kmp_uint64 result = 0; /* Zero is a better unknown value than all ones. */
 
   if (frequency == NULL) {
     return result;
   }

openmp/runtime/src/kmp_version.cpp

__kmp_str_buf_print(
       &buffer, "%sthread affinity support: %s\n", KMP_VERSION_PREF_STR,
 #if KMP_AFFINITY_SUPPORTED
       (KMP_AFFINITY_CAPABLE()
            ? (__kmp_affinity_type == affinity_none ? "not used" : "yes")
            : "no")
 #else
       "no"
 #endif
-          );
   __kmp_printf("%s", buffer.str);
   __kmp_str_buf_free(&buffer);
   K_DIAG(1, ("KMP_VERSION is true\n"));
 #endif // KMP_STUB
 } // __kmp_print_version_1
 
 // Called at parallel initialization time.
 static int __kmp_version_2_printed = FALSE;

openmp/runtime/src/kmp_wait_release.h

bool notdone_check() {
     // Calculate flag_switch
     if (this_thr->th.th_bar[bt].bb.wait_flag == KMP_BARRIER_SWITCH_TO_OWN_FLAG)
       flag_switch = true;
     if (byteref(get(), offset) != 1 && !flag_switch)
       return true;
     else if (flag_switch) {
       this_thr->th.th_bar[bt].bb.wait_flag = KMP_BARRIER_SWITCHING;
       kmp_flag_64<> flag(&this_thr->th.th_bar[bt].bb.b_go,
                          (kmp_uint64)KMP_BARRIER_STATE_BUMP);
       __kmp_wait_64(this_thr, &flag, TRUE USE_ITT_BUILD_ARG(itt_sync_obj));
     }
     return false;
   }
   void internal_release() {
     // Other threads can write their own bytes simultaneously.
     if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME) {
       byteref(get(), offset) = 1;

openmp/runtime/src/ompt-event-specific.h

  | Optional Events
  +--------------------------------------------------------------------------*/
 
 #define ompt_callback_sync_region_wait_implemented                             \
   ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_mutex_released_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
-#define ompt_callback_dependences_implemented                             \
-  ompt_event_MAY_ALWAYS_OPTIONAL
+#define ompt_callback_dependences_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 #define ompt_callback_task_dependence_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_work_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_masked_implemented ompt_event_MAY_ALWAYS_OPTIONAL
 
 #define ompt_callback_target_map_implemented ompt_event_UNIMPLEMENTED
 #define ompt_callback_target_map_emi_implemented ompt_event_UNIMPLEMENTED

openmp/runtime/src/ompt-general.cpp

#elif KMP_OS_WINDOWS
         start_tool = (ompt_start_tool_t)GetProcAddress(h, "ompt_start_tool");
         if (!start_tool) {
           OMPT_VERBOSE_INIT_CONTINUED_PRINT("Failed: Error %s\n",
                                             GetLastError());
         } else
 #else
 #error Activation of OMPT is not supported on this platform.
 #endif
-        {// if (start_tool)
+        { // if (start_tool)
           ret = (*start_tool)(omp_version, runtime_version);
           if (ret) {
             OMPT_VERBOSE_INIT_CONTINUED_PRINT("Success.\n");
             OMPT_VERBOSE_INIT_PRINT(
                 "Tool was started and is using the OMPT interface.\n");
             break;
           }
           OMPT_VERBOSE_INIT_CONTINUED_PRINT(
case omp_tool_enabled:
     //--------------------------------------------------
     ompt_start_tool_result =
         ompt_try_start_tool(__kmp_openmp_version, ompt_get_runtime_version());
 
     memset(&ompt_enabled, 0, sizeof(ompt_enabled));
     break;
 
   case omp_tool_error:
-    fprintf(stderr, "Warning: OMP_TOOL has invalid value \"%s\".\n"
-                    "  legal values are (NULL,\"\",\"disabled\","
-                    "\"enabled\").\n",
+    fprintf(stderr,
+            "Warning: OMP_TOOL has invalid value \"%s\".\n"
             ompt_env_var);
     break;
   }
   if (verbose_init && verbose_file != stderr && verbose_file != stdout)
     fclose(verbose_file);
 #if OMPT_DEBUG
   printf("ompt_pre_init(): ompt_enabled = %d\n", ompt_enabled);
 #endif
void ompt_post_init() {
 
   ompt_post_initialized = 1;
 
   //--------------------------------------------------
   // Initialize the tool if so indicated.
   //--------------------------------------------------
   if (ompt_start_tool_result) {
     ompt_enabled.enabled = !!ompt_start_tool_result->initialize(
-        ompt_fn_lookup, omp_get_initial_device(), &(ompt_start_tool_result->tool_data));
+        ompt_fn_lookup, omp_get_initial_device(),
+        &(ompt_start_tool_result->tool_data));
 
     if (!ompt_enabled.enabled) {
       // tool not enabled, zero out the bitmap, and done
       memset(&ompt_enabled, 0, sizeof(ompt_enabled));
       return;
     }
 
     kmp_info_t *root_thread = ompt_get_thread();
 
     ompt_set_thread_state(root_thread, ompt_state_overhead);
 
     if (ompt_enabled.ompt_callback_thread_begin) {
       ompt_callbacks.ompt_callback(ompt_callback_thread_begin)(
           ompt_thread_initial, __ompt_get_thread_data_internal());
     }
     ompt_data_t *task_data;
     ompt_data_t *parallel_data;
-    __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data, NULL);
+    __ompt_get_task_info_internal(0, NULL, &task_data, NULL, &parallel_data,
+                                  NULL);
     if (ompt_enabled.ompt_callback_implicit_task) {
       ompt_callbacks.ompt_callback(ompt_callback_implicit_task)(
           ompt_scope_begin, parallel_data, task_data, 1, 1, ompt_task_initial);
     }
 
     ompt_set_thread_state(root_thread, ompt_state_work_serial);
   }
 }
OMPT_API_ROUTINE int ompt_enumerate_mutex_impls(int current_impl,
   return 0;
 }
 
 /*****************************************************************************
  * callbacks
  ****************************************************************************/
 
 OMPT_API_ROUTINE ompt_set_result_t ompt_set_callback(ompt_callbacks_t which,
                                                      ompt_callback_t callback) {
   switch (which) {
 
 #define ompt_event_macro(event_name, callback_type, event_id)                  \
   case event_name:                                                             \
     ompt_callbacks.ompt_callback(event_name) = (callback_type)callback;        \
     ompt_enabled.event_name = (callback != 0);                                 \
     if (callback)                                                              \
       return ompt_event_implementation_status(event_name);                     \

  ****************************************************************************/
 
 /*
  * Currently unused function
 OMPT_API_ROUTINE int ompt_get_ompt_version() { return OMPT_VERSION; }
 */
 
 /*****************************************************************************
  * application-facing API
  ****************************************************************************/
 
 /*----------------------------------------------------------------------------
  | control
  ---------------------------------------------------------------------------*/
 
 int __kmp_control_tool(uint64_t command, uint64_t modifier, void *arg) {
 

openmp/runtime/src/ompt-specific.h

 #if OMPT_SUPPORT
 /*****************************************************************************
  * forward declarations
  ****************************************************************************/
 
 void __ompt_team_assign_id(kmp_team_t *team, ompt_data_t ompt_pid);
 void __ompt_thread_assign_wait_id(void *variable);
 
-void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, kmp_info_t *thr,
-                             int gtid, ompt_data_t *ompt_pid, void *codeptr);
+void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, kmp_info_t *thr, int gtid,
+                             ompt_data_t *ompt_pid, void *codeptr);
 
 void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt, kmp_info_t *thr,
                              int on_heap, bool always = false);
 
 void __ompt_lw_taskteam_unlink(kmp_info_t *thr);
 
 ompt_team_info_t *__ompt_get_teaminfo(int depth, int *size);
 
if (ompt_enabled.enabled && gtid >= 0 && __kmp_threads[gtid] &&              \
       !__kmp_threads[gtid]->th.ompt_thread_info.return_address)                \
   __kmp_threads[gtid]->th.ompt_thread_info.return_address =                    \
       __builtin_return_address(0)*/
 #define OMPT_STORE_RETURN_ADDRESS(gtid)                                        \
   OmptReturnAddressGuard ReturnAddressGuard{gtid, __builtin_return_address(0)};
 #define OMPT_LOAD_RETURN_ADDRESS(gtid) __ompt_load_return_address(gtid)
 #define OMPT_LOAD_OR_GET_RETURN_ADDRESS(gtid)                                  \
   ((ompt_enabled.enabled && gtid >= 0 && __kmp_threads[gtid] &&                \
-      __kmp_threads[gtid]->th.ompt_thread_info.return_address)?                \
-      __ompt_load_return_address(gtid):                                        \
-      __builtin_return_address(0))
+    __kmp_threads[gtid]->th.ompt_thread_info.return_address)                   \
+       ? __ompt_load_return_address(gtid)                                      \
+       : __builtin_return_address(0))
 
 //******************************************************************************
 // inline functions
 //******************************************************************************
 
 inline kmp_info_t *ompt_get_thread_gtid(int gtid) {
   return (gtid >= 0) ? __kmp_thread_from_gtid(gtid) : NULL;
 }

openmp/runtime/src/test-touch.c

 // test-touch.c //
 
-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 extern double omp_get_wtime();
-extern int    omp_get_num_threads();
-extern int    omp_get_max_threads();
+extern int omp_get_num_threads();
+extern int omp_get_max_threads();
 #ifdef __cplusplus
 }
 #endif
 
 int main() {
-    omp_get_wtime();
-    omp_get_num_threads();
-    omp_get_max_threads();
-    return 0;
 }
 
 // end of file //

openmp/runtime/src/thirdparty/ittnotify/disable_warnings.h

 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "ittnotify_config.h"
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 
-#pragma warning (disable: 593)   /* parameter "XXXX" was set but never used                 */
-#pragma warning (disable: 344)   /* typedef name has already been declared (with same type) */
-#pragma warning (disable: 174)   /* expression has no effect                                */
-#pragma warning (disable: 4127)  /* conditional expression is constant                      */
-#pragma warning (disable: 4306)  /* conversion from '?' to '?' of greater size              */
+#pragma warning(disable : 593) /* parameter "XXXX" was set but never used */
+#pragma warning(disable : 344) /* typedef name has already been declared (with \
+                                  same type) */
+#pragma warning(disable : 174) /* expression has no effect */
+#pragma warning(disable : 4127) /* conditional expression is constant */
+#pragma warning(disable : 4306) /* conversion from '?' to '?' of greater size  \
+                                 */
 
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #if defined __INTEL_COMPILER
 
-#pragma warning (disable: 869)  /* parameter "XXXXX" was never referenced                  */
-#pragma warning (disable: 1418) /* external function definition with no prior declaration  */
-#pragma warning (disable: 1419) /* external declaration in primary source file             */
+#pragma warning(disable : 869) /* parameter "XXXXX" was never referenced */
+#pragma warning(disable : 1418) /* external function definition with no prior  \
+                                   declaration  */
+#pragma warning(                                                               \
+    disable : 1419) /* external declaration in primary source file */
 
 #endif /* __INTEL_COMPILER */

openmp/runtime/src/thirdparty/ittnotify/ittnotify.h

 expense of extra API calls.
 
 The same ID may not be reused for different instances, unless a previous
 [ref] __itt_id_destroy call for that ID has been issued.
 */
 
 /** @cond exclude_from_documentation */
 #ifndef ITT_OS_WIN
-#  define ITT_OS_WIN   1
+#define ITT_OS_WIN 1
 #endif /* ITT_OS_WIN */
 
 #ifndef ITT_OS_LINUX
-#  define ITT_OS_LINUX 2
+#define ITT_OS_LINUX 2
 #endif /* ITT_OS_LINUX */
 
 #ifndef ITT_OS_MAC
-#  define ITT_OS_MAC   3
+#define ITT_OS_MAC 3
 #endif /* ITT_OS_MAC */
 
 #ifndef ITT_OS_FREEBSD
-#  define ITT_OS_FREEBSD   4
+#define ITT_OS_FREEBSD 4
 #endif /* ITT_OS_FREEBSD */
 
 #ifndef ITT_OS
-#  if defined WIN32 || defined _WIN32
-#    define ITT_OS ITT_OS_WIN
-#  elif defined( __APPLE__ ) && defined( __MACH__ )
-#    define ITT_OS ITT_OS_MAC
-#  elif defined( __FreeBSD__ )
-#    define ITT_OS ITT_OS_FREEBSD
-#  else
-#    define ITT_OS ITT_OS_LINUX
-#  endif
+#if defined WIN32 || defined _WIN32
+#define ITT_OS ITT_OS_WIN
+#elif defined(__APPLE__) && defined(__MACH__)
+#define ITT_OS ITT_OS_MAC
+#elif defined(__FreeBSD__)
+#define ITT_OS ITT_OS_FREEBSD
+#else
+#define ITT_OS ITT_OS_LINUX
+#endif
 #endif /* ITT_OS */
 
 #ifndef ITT_PLATFORM_WIN
-#  define ITT_PLATFORM_WIN 1
+#define ITT_PLATFORM_WIN 1
 #endif /* ITT_PLATFORM_WIN */
 
 #ifndef ITT_PLATFORM_POSIX
-#  define ITT_PLATFORM_POSIX 2
+#define ITT_PLATFORM_POSIX 2
 #endif /* ITT_PLATFORM_POSIX */
 
 #ifndef ITT_PLATFORM_MAC
-#  define ITT_PLATFORM_MAC 3
+#define ITT_PLATFORM_MAC 3
 #endif /* ITT_PLATFORM_MAC */
 
 #ifndef ITT_PLATFORM_FREEBSD
-#  define ITT_PLATFORM_FREEBSD 4
+#define ITT_PLATFORM_FREEBSD 4
 #endif /* ITT_PLATFORM_FREEBSD */
 
 #ifndef ITT_PLATFORM
-#  if ITT_OS==ITT_OS_WIN
-#    define ITT_PLATFORM ITT_PLATFORM_WIN
-#  elif ITT_OS==ITT_OS_MAC
-#    define ITT_PLATFORM ITT_PLATFORM_MAC
-#  elif ITT_OS==ITT_OS_FREEBSD
-#    define ITT_PLATFORM ITT_PLATFORM_FREEBSD
-#  else
-#    define ITT_PLATFORM ITT_PLATFORM_POSIX
-#  endif
+#if ITT_OS == ITT_OS_WIN
+#define ITT_PLATFORM ITT_PLATFORM_WIN
+#elif ITT_OS == ITT_OS_MAC
+#define ITT_PLATFORM ITT_PLATFORM_MAC
+#elif ITT_OS == ITT_OS_FREEBSD
+#define ITT_PLATFORM ITT_PLATFORM_FREEBSD
+#else
+#define ITT_PLATFORM ITT_PLATFORM_POSIX
+#endif
 #endif /* ITT_PLATFORM */
 
 #if defined(_UNICODE) && !defined(UNICODE)
 #define UNICODE
 #endif
 
 #include <stddef.h>
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #include <tchar.h>
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #include <stdint.h>
 #if defined(UNICODE) || defined(_UNICODE)
 #include <wchar.h>
 #endif /* UNICODE || _UNICODE */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #ifndef ITTAPI_CDECL
-#  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    define ITTAPI_CDECL __cdecl
-#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#    if defined _M_IX86 || defined __i386__
-#      define ITTAPI_CDECL __attribute__ ((cdecl))
-#    else  /* _M_IX86 || __i386__ */
-#      define ITTAPI_CDECL /* actual only on x86 platform */
-#    endif /* _M_IX86 || __i386__ */
-#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define ITTAPI_CDECL __cdecl
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if defined _M_IX86 || defined __i386__
+#define ITTAPI_CDECL __attribute__((cdecl))
+#else /* _M_IX86 || __i386__ */
+#define ITTAPI_CDECL /* actual only on x86 platform */
+#endif /* _M_IX86 || __i386__ */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* ITTAPI_CDECL */
 
 #ifndef STDCALL
-#  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    define STDCALL __stdcall
-#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#    if defined _M_IX86 || defined __i386__
-#      define STDCALL __attribute__ ((stdcall))
-#    else  /* _M_IX86 || __i386__ */
-#      define STDCALL /* supported only on x86 platform */
-#    endif /* _M_IX86 || __i386__ */
-#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define STDCALL __stdcall
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if defined _M_IX86 || defined __i386__
+#define STDCALL __attribute__((stdcall))
+#else /* _M_IX86 || __i386__ */
+#define STDCALL /* supported only on x86 platform */
+#endif /* _M_IX86 || __i386__ */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* STDCALL */
 
-#define ITTAPI    ITTAPI_CDECL
+#define ITTAPI ITTAPI_CDECL
 #define LIBITTAPI ITTAPI_CDECL
 
 /* TODO: Temporary for compatibility! */
-#define ITTAPI_CALL    ITTAPI_CDECL
+#define ITTAPI_CALL ITTAPI_CDECL
 #define LIBITTAPI_CALL ITTAPI_CDECL
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 /* use __forceinline (VC++ specific) */
-#define ITT_INLINE           __forceinline
+#define ITT_INLINE __forceinline
 #define ITT_INLINE_ATTRIBUTE /* nothing */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 /*
  * Generally, functions are not inlined unless optimization is specified.
  * For functions declared inline, this attribute inlines the function even
  * if no optimization level was specified.
  */
 #ifdef __STRICT_ANSI__
-#define ITT_INLINE           static
+#define ITT_INLINE static
 #define ITT_INLINE_ATTRIBUTE __attribute__((unused))
-#else  /* __STRICT_ANSI__ */
-#define ITT_INLINE           static inline
+#else /* __STRICT_ANSI__ */
+#define ITT_INLINE static inline
 #define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
 #endif /* __STRICT_ANSI__ */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 /** @endcond */
 
 #ifdef INTEL_ITTNOTIFY_ENABLE_LEGACY
-#  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    pragma message("WARNING!!! Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro")
-#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#    warning "Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro"
-#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#  include "legacy/ittnotify.h"
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#pragma message(                                                               \
+    "WARNING!!! Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro")
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#warning                                                                       \
+    "Deprecated API is used. Please undefine INTEL_ITTNOTIFY_ENABLE_LEGACY macro"
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#include "legacy/ittnotify.h"
 #endif /* INTEL_ITTNOTIFY_ENABLE_LEGACY */
 
 /** @cond exclude_from_documentation */
 /* Helper macro for joining tokens */
-#define ITT_JOIN_AUX(p,n) p##n
-#define ITT_JOIN(p,n)     ITT_JOIN_AUX(p,n)
+#define ITT_JOIN_AUX(p, n) p##n
+#define ITT_JOIN(p, n) ITT_JOIN_AUX(p, n)
 
 #ifdef ITT_MAJOR
 #undef ITT_MAJOR
 #endif
 #ifdef ITT_MINOR
 #undef ITT_MINOR
 #endif
-#define ITT_MAJOR     3
-#define ITT_MINOR     0
+#define ITT_MAJOR 3
+#define ITT_MINOR 0
 
 /* Standard versioning of a token with major and minor version numbers */
-#define ITT_VERSIONIZE(x)    \
-    ITT_JOIN(x,              \
-    ITT_JOIN(_,              \
-    ITT_JOIN(ITT_MAJOR,      \
-    ITT_JOIN(_, ITT_MINOR))))
+#define ITT_VERSIONIZE(x)                                                      \
+  ITT_JOIN(x, ITT_JOIN(_, ITT_JOIN(ITT_MAJOR, ITT_JOIN(_, ITT_MINOR))))
 
 #ifndef INTEL_ITTNOTIFY_PREFIX
-#  define INTEL_ITTNOTIFY_PREFIX __itt_
+#define INTEL_ITTNOTIFY_PREFIX __itt_
 #endif /* INTEL_ITTNOTIFY_PREFIX */
 #ifndef INTEL_ITTNOTIFY_POSTFIX
-#  define INTEL_ITTNOTIFY_POSTFIX _ptr_
+#define INTEL_ITTNOTIFY_POSTFIX _ptr_
 #endif /* INTEL_ITTNOTIFY_POSTFIX */
 
-#define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)
-#define ITTNOTIFY_NAME(n)     ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n,INTEL_ITTNOTIFY_POSTFIX)))
+#define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n)
+#define ITTNOTIFY_NAME(n)                                                      \
+  ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n, INTEL_ITTNOTIFY_POSTFIX)))
 
 #define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)
-#define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)
+#define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)
 
-#define ITTNOTIFY_VOID_D0(n,d)       (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d)
-#define ITTNOTIFY_VOID_D1(n,d,x)     (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x)
-#define ITTNOTIFY_VOID_D2(n,d,x,y)   (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y)
-#define ITTNOTIFY_VOID_D3(n,d,x,y,z) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z)
-#define ITTNOTIFY_VOID_D4(n,d,x,y,z,a)     (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
-#define ITTNOTIFY_VOID_D5(n,d,x,y,z,a,b)   (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
-#define ITTNOTIFY_VOID_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
-#define ITTNOTIFY_DATA_D0(n,d)       (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d)
-#define ITTNOTIFY_DATA_D1(n,d,x)     (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x)
-#define ITTNOTIFY_DATA_D2(n,d,x,y)   (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y)
-#define ITTNOTIFY_DATA_D3(n,d,x,y,z) (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z)
-#define ITTNOTIFY_DATA_D4(n,d,x,y,z,a)     (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
-#define ITTNOTIFY_DATA_D5(n,d,x,y,z,a,b)   (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
-#define ITTNOTIFY_DATA_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
+#define ITTNOTIFY_VOID_D0(n, d)                                                \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d)
+#define ITTNOTIFY_VOID_D1(n, d, x)                                             \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x)
+#define ITTNOTIFY_VOID_D2(n, d, x, y)                                          \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y)
+#define ITTNOTIFY_VOID_D3(n, d, x, y, z)                                       \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z)
+#define ITTNOTIFY_VOID_D4(n, d, x, y, z, a)                                    \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a)
+#define ITTNOTIFY_VOID_D5(n, d, x, y, z, a, b)                                 \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a, b)
+#define ITTNOTIFY_VOID_D6(n, d, x, y, z, a, b, c)                              \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c)
+#define ITTNOTIFY_DATA_D0(n, d)                                                \
+  (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d)
+#define ITTNOTIFY_DATA_D1(n, d, x)                                             \
+  (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x)
+#define ITTNOTIFY_DATA_D2(n, d, x, y)                                          \
+  (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y)
+#define ITTNOTIFY_DATA_D3(n, d, x, y, z)                                       \
+  (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y, z)
+#define ITTNOTIFY_DATA_D4(n, d, x, y, z, a)                                    \
+  (!(d)->flags)          ? 0                                                   \
+  : (!ITTNOTIFY_NAME(n)) ? 0                                                   \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a)
+#define ITTNOTIFY_DATA_D5(n, d, x, y, z, a, b)                                 \
+  (!(d)->flags)          ? 0                                                   \
+  : (!ITTNOTIFY_NAME(n)) ? 0                                                   \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a, b)
+#define ITTNOTIFY_DATA_D6(n, d, x, y, z, a, b, c)                              \
+  (!(d)->flags)          ? 0                                                   \
+  : (!ITTNOTIFY_NAME(n)) ? 0                                                   \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c)
 
 #ifdef ITT_STUB
 #undef ITT_STUB
 #endif
 #ifdef ITT_STUBV
 #undef ITT_STUBV
 #endif
-#define ITT_STUBV(api,type,name,args)                             \
-    typedef type (api* ITT_JOIN(ITTNOTIFY_NAME(name),_t)) args;   \
-    extern ITT_JOIN(ITTNOTIFY_NAME(name),_t) ITTNOTIFY_NAME(name);
+#define ITT_STUBV(api, type, name, args)                                       \
+  typedef type(api *ITT_JOIN(ITTNOTIFY_NAME(name), _t)) args;                  \
+  extern ITT_JOIN(ITTNOTIFY_NAME(name), _t) ITTNOTIFY_NAME(name);
 #define ITT_STUB ITT_STUBV
 /** @endcond */
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
 /** @cond exclude_from_gpa_documentation */
 /**
  * @defgroup public Public API
  * @{
  * @}
  */
 
 /**
  * @defgroup control Collection Control
  * @ingroup public
- * General behavior: application continues to run, but no profiling information is being collected
+ * General behavior: application continues to run, but no profiling information
+ * is being collected
  *
- * Pausing occurs not only for the current thread but for all process as well as spawned processes
+ * Pausing occurs not only for the current thread but for all process as well as
+ * spawned processes
  * - Intel(R) Parallel Inspector and Intel(R) Inspector XE:
  *   - Does not analyze or report errors that involve memory access.
  *   - Other errors are reported as usual. Pausing data collection in
  *     Intel(R) Parallel Inspector and Intel(R) Inspector XE
  *     only pauses tracing and analyzing memory access.
  *     It does not pause tracing or analyzing threading APIs.
  *   .
  * - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE:

 /** @brief Resume collection */
 void ITTAPI __itt_resume(void);
 /** @brief Detach collection */
 void ITTAPI __itt_detach(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, pause,  (void))
+ITT_STUBV(ITTAPI, void, pause, (void))
 ITT_STUBV(ITTAPI, void, resume, (void))
 ITT_STUBV(ITTAPI, void, detach, (void))
-#define __itt_pause      ITTNOTIFY_VOID(pause)
-#define __itt_pause_ptr  ITTNOTIFY_NAME(pause)
-#define __itt_resume     ITTNOTIFY_VOID(resume)
+#define __itt_pause ITTNOTIFY_VOID(pause)
+#define __itt_pause_ptr ITTNOTIFY_NAME(pause)
+#define __itt_resume ITTNOTIFY_VOID(resume)
 #define __itt_resume_ptr ITTNOTIFY_NAME(resume)
-#define __itt_detach     ITTNOTIFY_VOID(detach)
+#define __itt_detach ITTNOTIFY_VOID(detach)
 #define __itt_detach_ptr ITTNOTIFY_NAME(detach)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_pause()
-#define __itt_pause_ptr  0
+#define __itt_pause_ptr 0
 #define __itt_resume()
 #define __itt_resume_ptr 0
 #define __itt_detach()
 #define __itt_detach_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_pause_ptr  0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_pause_ptr 0
 #define __itt_resume_ptr 0
 #define __itt_detach_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} control group */
 /** @endcond */
 
 /**
  * @defgroup threads Threads
  * @ingroup public
  * Give names to threads
  * @{
  */
 /**
  * @brief Sets thread name of calling thread
  * @param[in] name - name of thread
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-void ITTAPI __itt_thread_set_nameA(const char    *name);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+void ITTAPI __itt_thread_set_nameA(const char *name);
 void ITTAPI __itt_thread_set_nameW(const wchar_t *name);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_thread_set_name     __itt_thread_set_nameW
-#  define __itt_thread_set_name_ptr __itt_thread_set_nameW_ptr
+#define __itt_thread_set_name __itt_thread_set_nameW
+#define __itt_thread_set_name_ptr __itt_thread_set_nameW_ptr
 #else /* UNICODE */
-#  define __itt_thread_set_name     __itt_thread_set_nameA
-#  define __itt_thread_set_name_ptr __itt_thread_set_nameA_ptr
+#define __itt_thread_set_name __itt_thread_set_nameA
+#define __itt_thread_set_name_ptr __itt_thread_set_nameA_ptr
 #endif /* UNICODE */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 void ITTAPI __itt_thread_set_name(const char *name);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char    *name))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char *name))
 ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, thread_set_name,  (const char    *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, thread_set_name, (const char *name))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_thread_set_nameA     ITTNOTIFY_VOID(thread_set_nameA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_thread_set_nameA ITTNOTIFY_VOID(thread_set_nameA)
 #define __itt_thread_set_nameA_ptr ITTNOTIFY_NAME(thread_set_nameA)
-#define __itt_thread_set_nameW     ITTNOTIFY_VOID(thread_set_nameW)
+#define __itt_thread_set_nameW ITTNOTIFY_VOID(thread_set_nameW)
 #define __itt_thread_set_nameW_ptr ITTNOTIFY_NAME(thread_set_nameW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_thread_set_name     ITTNOTIFY_VOID(thread_set_name)
+#define __itt_thread_set_name ITTNOTIFY_VOID(thread_set_name)
 #define __itt_thread_set_name_ptr ITTNOTIFY_NAME(thread_set_name)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_thread_set_nameA(name)
 #define __itt_thread_set_nameA_ptr 0
 #define __itt_thread_set_nameW(name)
 #define __itt_thread_set_nameW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_thread_set_name(name)
 #define __itt_thread_set_name_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_thread_set_nameA_ptr 0
 #define __itt_thread_set_nameW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_thread_set_name_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @cond exclude_from_gpa_documentation */
 
 /**
- * @brief Mark current thread as ignored from this point on, for the duration of its existence.
+ * @brief Mark current thread as ignored from this point on, for the duration of
+ * its existence.
  */
 void ITTAPI __itt_thread_ignore(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, thread_ignore, (void))
-#define __itt_thread_ignore     ITTNOTIFY_VOID(thread_ignore)
+#define __itt_thread_ignore ITTNOTIFY_VOID(thread_ignore)
 #define __itt_thread_ignore_ptr ITTNOTIFY_NAME(thread_ignore)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_thread_ignore()
 #define __itt_thread_ignore_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_thread_ignore_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} threads group */
 
 /**
  * @defgroup suppress Error suppression
  * @ingroup public
  * General behavior: application continues to run, but errors are suppressed
  *
  * @{
  */
 
-/*****************************************************************//**
- * @name group of functions used for error suppression in correctness tools
+/*****************************************************************/ /**
+                                                                     * @name
+                                                                     *group of
+                                                                     *functions
+                                                                     *used for
+                                                                     *error
+                                                                     *suppression
+                                                                     *in
+                                                                     *correctness
+                                                                     *tools
                                                                      *********************************************************************/
 /** @{ */
 /**
  * @hideinitializer
  * @brief possible value for suppression mask
  */
 #define __itt_suppress_all_errors 0x7fffffff
 
 /**
  * @hideinitializer
- * @brief possible value for suppression mask (suppresses errors from threading analysis)
+ * @brief possible value for suppression mask (suppresses errors from threading
+ * analysis)
  */
 #define __itt_suppress_threading_errors 0x000000ff
 
 /**
  * @hideinitializer
- * @brief possible value for suppression mask (suppresses errors from memory analysis)
+ * @brief possible value for suppression mask (suppresses errors from memory
+ * analysis)
  */
 #define __itt_suppress_memory_errors 0x0000ff00
 
 /**
  * @brief Start suppressing errors identified in mask on this thread
  */
 void ITTAPI __itt_suppress_push(unsigned int mask);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, suppress_push, (unsigned int mask))
-#define __itt_suppress_push     ITTNOTIFY_VOID(suppress_push)
+#define __itt_suppress_push ITTNOTIFY_VOID(suppress_push)
 #define __itt_suppress_push_ptr ITTNOTIFY_NAME(suppress_push)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_suppress_push(mask)
 #define __itt_suppress_push_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_suppress_push_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Undo the effects of the matching call to __itt_suppress_push
  */
 void ITTAPI __itt_suppress_pop(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, suppress_pop, (void))
-#define __itt_suppress_pop     ITTNOTIFY_VOID(suppress_pop)
+#define __itt_suppress_pop ITTNOTIFY_VOID(suppress_pop)
 #define __itt_suppress_pop_ptr ITTNOTIFY_NAME(suppress_pop)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_suppress_pop()
 #define __itt_suppress_pop_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_suppress_pop_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @enum __itt_model_disable
  * @brief Enumerator for the disable methods
  */
 typedef enum __itt_suppress_mode {
-    __itt_unsuppress_range,
-    __itt_suppress_range
 } __itt_suppress_mode_t;
 
 /**
- * @brief Mark a range of memory for error suppression or unsuppression for error types included in mask
+ * @brief Mark a range of memory for error suppression or unsuppression for
+ * error types included in mask
  */
-void ITTAPI __itt_suppress_mark_range(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size);
+void ITTAPI __itt_suppress_mark_range(__itt_suppress_mode_t mode,
+                                      unsigned int mask, void *address,
+                                      size_t size);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, suppress_mark_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size))
-#define __itt_suppress_mark_range     ITTNOTIFY_VOID(suppress_mark_range)
+ITT_STUBV(ITTAPI, void, suppress_mark_range,
+          (__itt_suppress_mode_t mode, unsigned int mask, void *address,
+           size_t size))
+#define __itt_suppress_mark_range ITTNOTIFY_VOID(suppress_mark_range)
 #define __itt_suppress_mark_range_ptr ITTNOTIFY_NAME(suppress_mark_range)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_suppress_mark_range(mask)
 #define __itt_suppress_mark_range_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_suppress_mark_range_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Undo the effect of a matching call to __itt_suppress_mark_range.   If not matching
- *        call is found, nothing is changed.
+ * @brief Undo the effect of a matching call to __itt_suppress_mark_range.   If
+ * not matching call is found, nothing is changed.
  */
-void ITTAPI __itt_suppress_clear_range(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size);
+void ITTAPI __itt_suppress_clear_range(__itt_suppress_mode_t mode,
+                                       unsigned int mask, void *address,
+                                       size_t size);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, suppress_clear_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size))
-#define __itt_suppress_clear_range     ITTNOTIFY_VOID(suppress_clear_range)
+ITT_STUBV(ITTAPI, void, suppress_clear_range,
+          (__itt_suppress_mode_t mode, unsigned int mask, void *address,
+           size_t size))
+#define __itt_suppress_clear_range ITTNOTIFY_VOID(suppress_clear_range)
 #define __itt_suppress_clear_range_ptr ITTNOTIFY_NAME(suppress_clear_range)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_suppress_clear_range(mask)
 #define __itt_suppress_clear_range_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_suppress_clear_range_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} */
 /** @} suppress group */
 
 /**
  * @defgroup sync Synchronization
  * @ingroup public
  * Indicate user-written synchronization code
  * @{
  */
 /**
  * @hideinitializer
  * @brief possible value of attribute argument for sync object type
  */
 #define __itt_attr_barrier 1
 
 /**
  * @hideinitializer
  * @brief possible value of attribute argument for sync object type
  */
-#define __itt_attr_mutex   2
+#define __itt_attr_mutex 2
 
 /**
 @brief Name a synchronization object
 @param[in] addr       Handle for the synchronization object. You should
 use a real address to uniquely identify the synchronization object.
 @param[in] objtype    null-terminated object type string. If NULL is
 passed, the name will be "User Synchronization".
 @param[in] objname    null-terminated object name string. If NULL,
 no name will be assigned to the object.
 @param[in] attribute  one of [#__itt_attr_barrier, #__itt_attr_mutex]
  */
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-void ITTAPI __itt_sync_createA(void *addr, const char    *objtype, const char    *objname, int attribute);
-void ITTAPI __itt_sync_createW(void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+void ITTAPI __itt_sync_createA(void *addr, const char *objtype,
+                               const char *objname, int attribute);
+void ITTAPI __itt_sync_createW(void *addr, const wchar_t *objtype,
+                               const wchar_t *objname, int attribute);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_sync_create     __itt_sync_createW
-#  define __itt_sync_create_ptr __itt_sync_createW_ptr
+#define __itt_sync_create __itt_sync_createW
+#define __itt_sync_create_ptr __itt_sync_createW_ptr
 #else /* UNICODE */
-#  define __itt_sync_create     __itt_sync_createA
-#  define __itt_sync_create_ptr __itt_sync_createA_ptr
+#define __itt_sync_create __itt_sync_createA
+#define __itt_sync_create_ptr __itt_sync_createA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-void ITTAPI __itt_sync_create (void *addr, const char *objtype, const char *objname, int attribute);
+void ITTAPI __itt_sync_create(void *addr, const char *objtype,
+                              const char *objname, int attribute);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, sync_createA, (void *addr, const char    *objtype, const char    *objname, int attribute))
-ITT_STUBV(ITTAPI, void, sync_createW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, sync_create,  (void *addr, const char*    objtype, const char*    objname, int attribute))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_createA,
+          (void *addr, const char *objtype, const char *objname, int attribute))
+ITT_STUBV(ITTAPI, void, sync_createW,
+          (void *addr, const wchar_t *objtype, const wchar_t *objname,
+           int attribute))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_create,
+          (void *addr, const char *objtype, const char *objname, int attribute))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_sync_createA     ITTNOTIFY_VOID(sync_createA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_sync_createA ITTNOTIFY_VOID(sync_createA)
 #define __itt_sync_createA_ptr ITTNOTIFY_NAME(sync_createA)
-#define __itt_sync_createW     ITTNOTIFY_VOID(sync_createW)
+#define __itt_sync_createW ITTNOTIFY_VOID(sync_createW)
 #define __itt_sync_createW_ptr ITTNOTIFY_NAME(sync_createW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_sync_create     ITTNOTIFY_VOID(sync_create)
+#define __itt_sync_create ITTNOTIFY_VOID(sync_create)
 #define __itt_sync_create_ptr ITTNOTIFY_NAME(sync_create)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_sync_createA(addr, objtype, objname, attribute)
 #define __itt_sync_createA_ptr 0
 #define __itt_sync_createW(addr, objtype, objname, attribute)
 #define __itt_sync_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_sync_create(addr, objtype, objname, attribute)
 #define __itt_sync_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_sync_createA_ptr 0
 #define __itt_sync_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_sync_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
 @brief Rename a synchronization object
 
 You can use the rename call to assign or reassign a name to a given
 synchronization object.
 @param[in] addr  handle for the synchronization object.
 @param[in] name  null-terminated object name string.
 */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-void ITTAPI __itt_sync_renameA(void *addr, const char    *name);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+void ITTAPI __itt_sync_renameA(void *addr, const char *name);
 void ITTAPI __itt_sync_renameW(void *addr, const wchar_t *name);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_sync_rename     __itt_sync_renameW
-#  define __itt_sync_rename_ptr __itt_sync_renameW_ptr
+#define __itt_sync_rename __itt_sync_renameW
+#define __itt_sync_rename_ptr __itt_sync_renameW_ptr
 #else /* UNICODE */
-#  define __itt_sync_rename     __itt_sync_renameA
-#  define __itt_sync_rename_ptr __itt_sync_renameA_ptr
+#define __itt_sync_rename __itt_sync_renameA
+#define __itt_sync_rename_ptr __itt_sync_renameA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 void ITTAPI __itt_sync_rename(void *addr, const char *name);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char    *name))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char *name))
 ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, sync_rename,  (void *addr, const char    *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_rename, (void *addr, const char *name))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_sync_renameA     ITTNOTIFY_VOID(sync_renameA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_sync_renameA ITTNOTIFY_VOID(sync_renameA)
 #define __itt_sync_renameA_ptr ITTNOTIFY_NAME(sync_renameA)
-#define __itt_sync_renameW     ITTNOTIFY_VOID(sync_renameW)
+#define __itt_sync_renameW ITTNOTIFY_VOID(sync_renameW)
 #define __itt_sync_renameW_ptr ITTNOTIFY_NAME(sync_renameW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_sync_rename     ITTNOTIFY_VOID(sync_rename)
+#define __itt_sync_rename ITTNOTIFY_VOID(sync_rename)
 #define __itt_sync_rename_ptr ITTNOTIFY_NAME(sync_rename)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_sync_renameA(addr, name)
 #define __itt_sync_renameA_ptr 0
 #define __itt_sync_renameW(addr, name)
 #define __itt_sync_renameW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_sync_rename(addr, name)
 #define __itt_sync_rename_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_sync_renameA_ptr 0
 #define __itt_sync_renameW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_sync_rename_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  @brief Destroy a synchronization object.
  @param addr Handle for the synchronization object.
  */
 void ITTAPI __itt_sync_destroy(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, sync_destroy, (void *addr))
-#define __itt_sync_destroy     ITTNOTIFY_VOID(sync_destroy)
+#define __itt_sync_destroy ITTNOTIFY_VOID(sync_destroy)
 #define __itt_sync_destroy_ptr ITTNOTIFY_NAME(sync_destroy)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_sync_destroy(addr)
 #define __itt_sync_destroy_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_sync_destroy_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
-/*****************************************************************//**
- * @name group of functions is used for performance measurement tools
+/*****************************************************************/ /**
+                                                                     * @name
+                                                                     *group of
+                                                                     *functions
+                                                                     *is used
+                                                                     *for
+                                                                     *performance
+                                                                     *measurement
+                                                                     *tools
                                                                      *********************************************************************/
 /** @{ */
 /**
  * @brief Enter spin loop on user-defined sync object
  */
-void ITTAPI __itt_sync_prepare(void* addr);
+void ITTAPI __itt_sync_prepare(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, sync_prepare, (void *addr))
-#define __itt_sync_prepare     ITTNOTIFY_VOID(sync_prepare)
+#define __itt_sync_prepare ITTNOTIFY_VOID(sync_prepare)
 #define __itt_sync_prepare_ptr ITTNOTIFY_NAME(sync_prepare)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_sync_prepare(addr)
 #define __itt_sync_prepare_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_sync_prepare_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Quit spin loop without acquiring spin object
  */
 void ITTAPI __itt_sync_cancel(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, sync_cancel, (void *addr))
-#define __itt_sync_cancel     ITTNOTIFY_VOID(sync_cancel)
+#define __itt_sync_cancel ITTNOTIFY_VOID(sync_cancel)
 #define __itt_sync_cancel_ptr ITTNOTIFY_NAME(sync_cancel)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_sync_cancel(addr)
 #define __itt_sync_cancel_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_sync_cancel_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Successful spin loop completion (sync object acquired)
  */
 void ITTAPI __itt_sync_acquired(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, sync_acquired, (void *addr))
-#define __itt_sync_acquired     ITTNOTIFY_VOID(sync_acquired)
+#define __itt_sync_acquired ITTNOTIFY_VOID(sync_acquired)
 #define __itt_sync_acquired_ptr ITTNOTIFY_NAME(sync_acquired)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_sync_acquired(addr)
 #define __itt_sync_acquired_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_sync_acquired_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Start sync object releasing code. Is called before the lock release call.
+ * @brief Start sync object releasing code. Is called before the lock release
+ * call.
  */
-void ITTAPI __itt_sync_releasing(void* addr);
+void ITTAPI __itt_sync_releasing(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, sync_releasing, (void *addr))
-#define __itt_sync_releasing     ITTNOTIFY_VOID(sync_releasing)
+#define __itt_sync_releasing ITTNOTIFY_VOID(sync_releasing)
 #define __itt_sync_releasing_ptr ITTNOTIFY_NAME(sync_releasing)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_sync_releasing(addr)
 #define __itt_sync_releasing_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_sync_releasing_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} */
 
 /** @} sync group */
 
-/**************************************************************//**
- * @name group of functions is used for correctness checking tools
+/**************************************************************/ /**
+                                                                  * @name group
+                                                                  *of functions
+                                                                  *is used for
+                                                                  *correctness
+                                                                  *checking
+                                                                  *tools
                                                                   ******************************************************************/
 /** @{ */
 /**
  * @ingroup legacy
  * @deprecated Legacy API
  * @brief Fast synchronization which does no require spinning.
- * - This special function is to be used by TBB and OpenMP libraries only when they know
- *   there is no spin but they need to suppress TC warnings about shared variable modifications.
- * - It only has corresponding pointers in static library and does not have corresponding function
- *   in dynamic library.
+ * - This special function is to be used by TBB and OpenMP libraries only when
+ * they know there is no spin but they need to suppress TC warnings about shared
+ * variable modifications.
+ * - It only has corresponding pointers in static library and does not have
+ * corresponding function in dynamic library.
  * @see void __itt_sync_prepare(void* addr);
  */
-void ITTAPI __itt_fsync_prepare(void* addr);
+void ITTAPI __itt_fsync_prepare(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, fsync_prepare, (void *addr))
-#define __itt_fsync_prepare     ITTNOTIFY_VOID(fsync_prepare)
+#define __itt_fsync_prepare ITTNOTIFY_VOID(fsync_prepare)
 #define __itt_fsync_prepare_ptr ITTNOTIFY_NAME(fsync_prepare)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_fsync_prepare(addr)
 #define __itt_fsync_prepare_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_fsync_prepare_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup legacy
  * @deprecated Legacy API
  * @brief Fast synchronization which does no require spinning.
- * - This special function is to be used by TBB and OpenMP libraries only when they know
- *   there is no spin but they need to suppress TC warnings about shared variable modifications.
- * - It only has corresponding pointers in static library and does not have corresponding function
- *   in dynamic library.
+ * - This special function is to be used by TBB and OpenMP libraries only when
+ * they know there is no spin but they need to suppress TC warnings about shared
+ * variable modifications.
+ * - It only has corresponding pointers in static library and does not have
+ * corresponding function in dynamic library.
  * @see void __itt_sync_cancel(void *addr);
  */
 void ITTAPI __itt_fsync_cancel(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, fsync_cancel, (void *addr))
-#define __itt_fsync_cancel     ITTNOTIFY_VOID(fsync_cancel)
+#define __itt_fsync_cancel ITTNOTIFY_VOID(fsync_cancel)
 #define __itt_fsync_cancel_ptr ITTNOTIFY_NAME(fsync_cancel)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_fsync_cancel(addr)
 #define __itt_fsync_cancel_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_fsync_cancel_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup legacy
  * @deprecated Legacy API
  * @brief Fast synchronization which does no require spinning.
- * - This special function is to be used by TBB and OpenMP libraries only when they know
- *   there is no spin but they need to suppress TC warnings about shared variable modifications.
- * - It only has corresponding pointers in static library and does not have corresponding function
- *   in dynamic library.
+ * - This special function is to be used by TBB and OpenMP libraries only when
+ * they know there is no spin but they need to suppress TC warnings about shared
+ * variable modifications.
+ * - It only has corresponding pointers in static library and does not have
+ * corresponding function in dynamic library.
  * @see void __itt_sync_acquired(void *addr);
  */
 void ITTAPI __itt_fsync_acquired(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, fsync_acquired, (void *addr))
-#define __itt_fsync_acquired     ITTNOTIFY_VOID(fsync_acquired)
+#define __itt_fsync_acquired ITTNOTIFY_VOID(fsync_acquired)
 #define __itt_fsync_acquired_ptr ITTNOTIFY_NAME(fsync_acquired)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_fsync_acquired(addr)
 #define __itt_fsync_acquired_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_fsync_acquired_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup legacy
  * @deprecated Legacy API
  * @brief Fast synchronization which does no require spinning.
- * - This special function is to be used by TBB and OpenMP libraries only when they know
- *   there is no spin but they need to suppress TC warnings about shared variable modifications.
- * - It only has corresponding pointers in static library and does not have corresponding function
- *   in dynamic library.
+ * - This special function is to be used by TBB and OpenMP libraries only when
+ * they know there is no spin but they need to suppress TC warnings about shared
+ * variable modifications.
+ * - It only has corresponding pointers in static library and does not have
+ * corresponding function in dynamic library.
  * @see void __itt_sync_releasing(void* addr);
  */
-void ITTAPI __itt_fsync_releasing(void* addr);
+void ITTAPI __itt_fsync_releasing(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, fsync_releasing, (void *addr))
-#define __itt_fsync_releasing     ITTNOTIFY_VOID(fsync_releasing)
+#define __itt_fsync_releasing ITTNOTIFY_VOID(fsync_releasing)
 #define __itt_fsync_releasing_ptr ITTNOTIFY_NAME(fsync_releasing)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_fsync_releasing(addr)
 #define __itt_fsync_releasing_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_fsync_releasing_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} */
 
 /**
  * @defgroup model Modeling by Intel(R) Parallel Advisor
  * @ingroup public

  * API used by the Intel(R) Parallel Advisor to describe potential concurrency
  * and related activities. User-added source annotations expand to calls
  * to these procedures to enable modeling of a hypothetical concurrent
  * execution serially.
  * @{
  */
 #if !defined(_ADVISOR_ANNOTATE_H_) || defined(ANNOTATE_EXPAND_NULL)
 
-typedef void* __itt_model_site;             /*!< @brief handle for lexical site     */
-typedef void* __itt_model_site_instance;    /*!< @brief handle for dynamic instance */
-typedef void* __itt_model_task;             /*!< @brief handle for lexical site     */
-typedef void* __itt_model_task_instance;    /*!< @brief handle for dynamic instance */
+typedef void *__itt_model_site; /*!< @brief handle for lexical site     */
+typedef void
+    *__itt_model_site_instance; /*!< @brief handle for dynamic instance */
+typedef void *__itt_model_task; /*!< @brief handle for lexical site     */
+typedef void
+    *__itt_model_task_instance; /*!< @brief handle for dynamic instance */
 
 /**
  * @enum __itt_model_disable
  * @brief Enumerator for the disable methods
  */
 typedef enum {
-    __itt_model_disable_observation,
-    __itt_model_disable_collection
 } __itt_model_disable;
 
 #endif /* !_ADVISOR_ANNOTATE_H_ || ANNOTATE_EXPAND_NULL */
 
 /**
  * @brief ANNOTATE_SITE_BEGIN/ANNOTATE_SITE_END support.
  *
  * site_begin/end model a potential concurrency site.
  * site instances may be recursively nested with themselves.
  * site_end exits the most recently started but unended site for the current
  * thread.  The handle passed to end may be used to validate structure.
  * Instances of a site encountered on different threads concurrently
  * are considered completely distinct. If the site name for two different
  * lexical sites match, it is unspecified whether they are treated as the
  * same or different for data presentation.
  */
-void ITTAPI __itt_model_site_begin(__itt_model_site *site, __itt_model_site_instance *instance, const char *name);
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_model_site_begin(__itt_model_site *site,
+                                   __itt_model_site_instance *instance,
+                                   const char *name);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 void ITTAPI __itt_model_site_beginW(const wchar_t *name);
 #endif
 void ITTAPI __itt_model_site_beginA(const char *name);
 void ITTAPI __itt_model_site_beginAL(const char *name, size_t siteNameLen);
-void ITTAPI __itt_model_site_end  (__itt_model_site *site, __itt_model_site_instance *instance);
+void ITTAPI __itt_model_site_end(__itt_model_site *site,
+                                 __itt_model_site_instance *instance);
 void ITTAPI __itt_model_site_end_2(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, model_site_begin,  (__itt_model_site *site, __itt_model_site_instance *instance, const char *name))
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, model_site_beginW,  (const wchar_t *name))
+ITT_STUBV(ITTAPI, void, model_site_begin,
+          (__itt_model_site * site, __itt_model_site_instance *instance,
+           const char *name))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, model_site_beginW, (const wchar_t *name))
 #endif
-ITT_STUBV(ITTAPI, void, model_site_beginA,  (const char *name))
-ITT_STUBV(ITTAPI, void, model_site_beginAL,  (const char *name, size_t siteNameLen))
-ITT_STUBV(ITTAPI, void, model_site_end,    (__itt_model_site *site, __itt_model_site_instance *instance))
-ITT_STUBV(ITTAPI, void, model_site_end_2,  (void))
-#define __itt_model_site_begin      ITTNOTIFY_VOID(model_site_begin)
-#define __itt_model_site_begin_ptr  ITTNOTIFY_NAME(model_site_begin)
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_model_site_beginW      ITTNOTIFY_VOID(model_site_beginW)
-#define __itt_model_site_beginW_ptr  ITTNOTIFY_NAME(model_site_beginW)
+ITT_STUBV(ITTAPI, void, model_site_beginA, (const char *name))
+ITT_STUBV(ITTAPI, void, model_site_beginAL,
+          (const char *name, size_t siteNameLen))
+ITT_STUBV(ITTAPI, void, model_site_end,
+          (__itt_model_site * site, __itt_model_site_instance *instance))
+ITT_STUBV(ITTAPI, void, model_site_end_2, (void))
+#define __itt_model_site_begin ITTNOTIFY_VOID(model_site_begin)
+#define __itt_model_site_begin_ptr ITTNOTIFY_NAME(model_site_begin)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_model_site_beginW ITTNOTIFY_VOID(model_site_beginW)
+#define __itt_model_site_beginW_ptr ITTNOTIFY_NAME(model_site_beginW)
 #endif
-#define __itt_model_site_beginA      ITTNOTIFY_VOID(model_site_beginA)
-#define __itt_model_site_beginA_ptr  ITTNOTIFY_NAME(model_site_beginA)
-#define __itt_model_site_beginAL      ITTNOTIFY_VOID(model_site_beginAL)
-#define __itt_model_site_beginAL_ptr  ITTNOTIFY_NAME(model_site_beginAL)
-#define __itt_model_site_end        ITTNOTIFY_VOID(model_site_end)
-#define __itt_model_site_end_ptr    ITTNOTIFY_NAME(model_site_end)
-#define __itt_model_site_end_2        ITTNOTIFY_VOID(model_site_end_2)
-#define __itt_model_site_end_2_ptr    ITTNOTIFY_NAME(model_site_end_2)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_site_beginA ITTNOTIFY_VOID(model_site_beginA)
+#define __itt_model_site_beginA_ptr ITTNOTIFY_NAME(model_site_beginA)
+#define __itt_model_site_beginAL ITTNOTIFY_VOID(model_site_beginAL)
+#define __itt_model_site_beginAL_ptr ITTNOTIFY_NAME(model_site_beginAL)
+#define __itt_model_site_end ITTNOTIFY_VOID(model_site_end)
+#define __itt_model_site_end_ptr ITTNOTIFY_NAME(model_site_end)
+#define __itt_model_site_end_2 ITTNOTIFY_VOID(model_site_end_2)
+#define __itt_model_site_end_2_ptr ITTNOTIFY_NAME(model_site_end_2)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_model_site_begin(site, instance, name)
-#define __itt_model_site_begin_ptr  0
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_model_site_begin_ptr 0
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_model_site_beginW(name)
-#define __itt_model_site_beginW_ptr  0
+#define __itt_model_site_beginW_ptr 0
 #endif
 #define __itt_model_site_beginA(name)
-#define __itt_model_site_beginA_ptr  0
+#define __itt_model_site_beginA_ptr 0
 #define __itt_model_site_beginAL(name, siteNameLen)
-#define __itt_model_site_beginAL_ptr  0
+#define __itt_model_site_beginAL_ptr 0
 #define __itt_model_site_end(site, instance)
-#define __itt_model_site_end_ptr    0
+#define __itt_model_site_end_ptr 0
 #define __itt_model_site_end_2()
-#define __itt_model_site_end_2_ptr    0
+#define __itt_model_site_end_2_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_model_site_begin_ptr  0
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_model_site_beginW_ptr  0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_site_begin_ptr 0
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_model_site_beginW_ptr 0
 #endif
-#define __itt_model_site_beginA_ptr  0
-#define __itt_model_site_beginAL_ptr  0
-#define __itt_model_site_end_ptr    0
-#define __itt_model_site_end_2_ptr    0
+#define __itt_model_site_beginA_ptr 0
+#define __itt_model_site_beginAL_ptr 0
+#define __itt_model_site_end_ptr 0
+#define __itt_model_site_end_2_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief ANNOTATE_TASK_BEGIN/ANNOTATE_TASK_END support
  *
  * task_begin/end model a potential task, which is contained within the most
  * closely enclosing dynamic site.  task_end exits the most recently started
  * but unended task.  The handle passed to end may be used to validate
  * structure.  It is unspecified if bad dynamic nesting is detected.  If it
  * is, it should be encoded in the resulting data collection.  The collector
  * should not fail due to construct nesting issues, nor attempt to directly
  * indicate the problem.
  */
-void ITTAPI __itt_model_task_begin(__itt_model_task *task, __itt_model_task_instance *instance, const char *name);
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+void ITTAPI __itt_model_task_begin(__itt_model_task *task,
+                                   __itt_model_task_instance *instance,
+                                   const char *name);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 void ITTAPI __itt_model_task_beginW(const wchar_t *name);
 void ITTAPI __itt_model_iteration_taskW(const wchar_t *name);
 #endif
 void ITTAPI __itt_model_task_beginA(const char *name);
 void ITTAPI __itt_model_task_beginAL(const char *name, size_t taskNameLen);
 void ITTAPI __itt_model_iteration_taskA(const char *name);
 void ITTAPI __itt_model_iteration_taskAL(const char *name, size_t taskNameLen);
-void ITTAPI __itt_model_task_end  (__itt_model_task *task, __itt_model_task_instance *instance);
+void ITTAPI __itt_model_task_end(__itt_model_task *task,
+                                 __itt_model_task_instance *instance);
 void ITTAPI __itt_model_task_end_2(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, model_task_begin,  (__itt_model_task *task, __itt_model_task_instance *instance, const char *name))
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, model_task_beginW,  (const wchar_t *name))
+ITT_STUBV(ITTAPI, void, model_task_begin,
+          (__itt_model_task * task, __itt_model_task_instance *instance,
+           const char *name))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, model_task_beginW, (const wchar_t *name))
 ITT_STUBV(ITTAPI, void, model_iteration_taskW, (const wchar_t *name))
 #endif
-ITT_STUBV(ITTAPI, void, model_task_beginA,  (const char *name))
-ITT_STUBV(ITTAPI, void, model_task_beginAL,  (const char *name, size_t taskNameLen))
-ITT_STUBV(ITTAPI, void, model_iteration_taskA,  (const char *name))
-ITT_STUBV(ITTAPI, void, model_iteration_taskAL,  (const char *name, size_t taskNameLen))
-ITT_STUBV(ITTAPI, void, model_task_end,    (__itt_model_task *task, __itt_model_task_instance *instance))
-ITT_STUBV(ITTAPI, void, model_task_end_2,  (void))
-#define __itt_model_task_begin      ITTNOTIFY_VOID(model_task_begin)
-#define __itt_model_task_begin_ptr  ITTNOTIFY_NAME(model_task_begin)
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_model_task_beginW     ITTNOTIFY_VOID(model_task_beginW)
+ITT_STUBV(ITTAPI, void, model_task_beginA, (const char *name))
+ITT_STUBV(ITTAPI, void, model_task_beginAL,
+          (const char *name, size_t taskNameLen))
+ITT_STUBV(ITTAPI, void, model_iteration_taskA, (const char *name))
+ITT_STUBV(ITTAPI, void, model_iteration_taskAL,
+          (const char *name, size_t taskNameLen))
+ITT_STUBV(ITTAPI, void, model_task_end,
+          (__itt_model_task * task, __itt_model_task_instance *instance))
+ITT_STUBV(ITTAPI, void, model_task_end_2, (void))
+#define __itt_model_task_begin ITTNOTIFY_VOID(model_task_begin)
+#define __itt_model_task_begin_ptr ITTNOTIFY_NAME(model_task_begin)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_model_task_beginW ITTNOTIFY_VOID(model_task_beginW)
 #define __itt_model_task_beginW_ptr ITTNOTIFY_NAME(model_task_beginW)
-#define __itt_model_iteration_taskW     ITTNOTIFY_VOID(model_iteration_taskW)
+#define __itt_model_iteration_taskW ITTNOTIFY_VOID(model_iteration_taskW)
 #define __itt_model_iteration_taskW_ptr ITTNOTIFY_NAME(model_iteration_taskW)
 #endif
-#define __itt_model_task_beginA    ITTNOTIFY_VOID(model_task_beginA)
+#define __itt_model_task_beginA ITTNOTIFY_VOID(model_task_beginA)
 #define __itt_model_task_beginA_ptr ITTNOTIFY_NAME(model_task_beginA)
-#define __itt_model_task_beginAL    ITTNOTIFY_VOID(model_task_beginAL)
+#define __itt_model_task_beginAL ITTNOTIFY_VOID(model_task_beginAL)
 #define __itt_model_task_beginAL_ptr ITTNOTIFY_NAME(model_task_beginAL)
-#define __itt_model_iteration_taskA    ITTNOTIFY_VOID(model_iteration_taskA)
+#define __itt_model_iteration_taskA ITTNOTIFY_VOID(model_iteration_taskA)
 #define __itt_model_iteration_taskA_ptr ITTNOTIFY_NAME(model_iteration_taskA)
-#define __itt_model_iteration_taskAL    ITTNOTIFY_VOID(model_iteration_taskAL)
+#define __itt_model_iteration_taskAL ITTNOTIFY_VOID(model_iteration_taskAL)
 #define __itt_model_iteration_taskAL_ptr ITTNOTIFY_NAME(model_iteration_taskAL)
-#define __itt_model_task_end        ITTNOTIFY_VOID(model_task_end)
-#define __itt_model_task_end_ptr    ITTNOTIFY_NAME(model_task_end)
-#define __itt_model_task_end_2        ITTNOTIFY_VOID(model_task_end_2)
-#define __itt_model_task_end_2_ptr    ITTNOTIFY_NAME(model_task_end_2)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_task_end ITTNOTIFY_VOID(model_task_end)
+#define __itt_model_task_end_ptr ITTNOTIFY_NAME(model_task_end)
+#define __itt_model_task_end_2 ITTNOTIFY_VOID(model_task_end_2)
+#define __itt_model_task_end_2_ptr ITTNOTIFY_NAME(model_task_end_2)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_model_task_begin(task, instance, name)
-#define __itt_model_task_begin_ptr  0
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#define __itt_model_task_begin_ptr 0
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_model_task_beginW(name)
-#define __itt_model_task_beginW_ptr  0
+#define __itt_model_task_beginW_ptr 0
 #endif
 #define __itt_model_task_beginA(name)
-#define __itt_model_task_beginA_ptr  0
+#define __itt_model_task_beginA_ptr 0
 #define __itt_model_task_beginAL(name, siteNameLen)
-#define __itt_model_task_beginAL_ptr  0
+#define __itt_model_task_beginAL_ptr 0
 #define __itt_model_iteration_taskA(name)
-#define __itt_model_iteration_taskA_ptr  0
+#define __itt_model_iteration_taskA_ptr 0
 #define __itt_model_iteration_taskAL(name, siteNameLen)
-#define __itt_model_iteration_taskAL_ptr  0
+#define __itt_model_iteration_taskAL_ptr 0
 #define __itt_model_task_end(task, instance)
-#define __itt_model_task_end_ptr    0
+#define __itt_model_task_end_ptr 0
 #define __itt_model_task_end_2()
-#define __itt_model_task_end_2_ptr    0
+#define __itt_model_task_end_2_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_model_task_begin_ptr  0
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_task_begin_ptr 0
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_model_task_beginW_ptr 0
 #endif
-#define __itt_model_task_beginA_ptr  0
-#define __itt_model_task_beginAL_ptr  0
-#define __itt_model_iteration_taskA_ptr    0
-#define __itt_model_iteration_taskAL_ptr    0
-#define __itt_model_task_end_ptr    0
-#define __itt_model_task_end_2_ptr    0
+#define __itt_model_task_beginA_ptr 0
+#define __itt_model_task_beginAL_ptr 0
+#define __itt_model_iteration_taskA_ptr 0
+#define __itt_model_iteration_taskAL_ptr 0
+#define __itt_model_task_end_ptr 0
+#define __itt_model_task_end_2_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief ANNOTATE_LOCK_ACQUIRE/ANNOTATE_LOCK_RELEASE support
  *
  * lock_acquire/release model a potential lock for both lockset and
  * performance modeling.  Each unique address is modeled as a separate

 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, model_lock_acquire, (void *lock))
 ITT_STUBV(ITTAPI, void, model_lock_acquire_2, (void *lock))
 ITT_STUBV(ITTAPI, void, model_lock_release, (void *lock))
 ITT_STUBV(ITTAPI, void, model_lock_release_2, (void *lock))
-#define __itt_model_lock_acquire     ITTNOTIFY_VOID(model_lock_acquire)
+#define __itt_model_lock_acquire ITTNOTIFY_VOID(model_lock_acquire)
 #define __itt_model_lock_acquire_ptr ITTNOTIFY_NAME(model_lock_acquire)
-#define __itt_model_lock_acquire_2     ITTNOTIFY_VOID(model_lock_acquire_2)
+#define __itt_model_lock_acquire_2 ITTNOTIFY_VOID(model_lock_acquire_2)
 #define __itt_model_lock_acquire_2_ptr ITTNOTIFY_NAME(model_lock_acquire_2)
-#define __itt_model_lock_release     ITTNOTIFY_VOID(model_lock_release)
+#define __itt_model_lock_release ITTNOTIFY_VOID(model_lock_release)
 #define __itt_model_lock_release_ptr ITTNOTIFY_NAME(model_lock_release)
-#define __itt_model_lock_release_2     ITTNOTIFY_VOID(model_lock_release_2)
+#define __itt_model_lock_release_2 ITTNOTIFY_VOID(model_lock_release_2)
 #define __itt_model_lock_release_2_ptr ITTNOTIFY_NAME(model_lock_release_2)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_model_lock_acquire(lock)
 #define __itt_model_lock_acquire_ptr 0
 #define __itt_model_lock_acquire_2(lock)
 #define __itt_model_lock_acquire_2_ptr 0
 #define __itt_model_lock_release(lock)
 #define __itt_model_lock_release_ptr 0
 #define __itt_model_lock_release_2(lock)
 #define __itt_model_lock_release_2_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_model_lock_acquire_ptr 0
 #define __itt_model_lock_acquire_2_ptr 0
 #define __itt_model_lock_release_ptr 0
 #define __itt_model_lock_release_2_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief ANNOTATE_RECORD_ALLOCATION/ANNOTATE_RECORD_DEALLOCATION support
  *
  * record_allocation/deallocation describe user-defined memory allocator
  * behavior, which may be required for correctness modeling to understand
  * when storage is not expected to be actually reused across threads.
  */
-void ITTAPI __itt_model_record_allocation  (void *addr, size_t size);
+void ITTAPI __itt_model_record_allocation(void *addr, size_t size);
 void ITTAPI __itt_model_record_deallocation(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, model_record_allocation,   (void *addr, size_t size))
+ITT_STUBV(ITTAPI, void, model_record_allocation, (void *addr, size_t size))
 ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr))
-#define __itt_model_record_allocation       ITTNOTIFY_VOID(model_record_allocation)
-#define __itt_model_record_allocation_ptr   ITTNOTIFY_NAME(model_record_allocation)
-#define __itt_model_record_deallocation     ITTNOTIFY_VOID(model_record_deallocation)
-#define __itt_model_record_deallocation_ptr ITTNOTIFY_NAME(model_record_deallocation)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_record_allocation ITTNOTIFY_VOID(model_record_allocation)
+#define __itt_model_record_allocation_ptr                                      \
+  ITTNOTIFY_NAME(model_record_allocation)
+#define __itt_model_record_deallocation                                        \
+  ITTNOTIFY_VOID(model_record_deallocation)
+#define __itt_model_record_deallocation_ptr                                    \
+  ITTNOTIFY_NAME(model_record_deallocation)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_model_record_allocation(addr, size)
-#define __itt_model_record_allocation_ptr   0
+#define __itt_model_record_allocation_ptr 0
 #define __itt_model_record_deallocation(addr)
 #define __itt_model_record_deallocation_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_model_record_allocation_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_record_allocation_ptr 0
 #define __itt_model_record_deallocation_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief ANNOTATE_INDUCTION_USES support
  *
  * Note particular storage is inductive through the end of the current site
  */
-void ITTAPI __itt_model_induction_uses(void* addr, size_t size);
+void ITTAPI __itt_model_induction_uses(void *addr, size_t size);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, model_induction_uses, (void *addr, size_t size))
-#define __itt_model_induction_uses     ITTNOTIFY_VOID(model_induction_uses)
+#define __itt_model_induction_uses ITTNOTIFY_VOID(model_induction_uses)
 #define __itt_model_induction_uses_ptr ITTNOTIFY_NAME(model_induction_uses)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_model_induction_uses(addr, size)
-#define __itt_model_induction_uses_ptr   0
+#define __itt_model_induction_uses_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_model_induction_uses_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_induction_uses_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief ANNOTATE_REDUCTION_USES support
  *
  * Note particular storage is used for reduction through the end
  * of the current site
  */
-void ITTAPI __itt_model_reduction_uses(void* addr, size_t size);
+void ITTAPI __itt_model_reduction_uses(void *addr, size_t size);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, model_reduction_uses, (void *addr, size_t size))
-#define __itt_model_reduction_uses     ITTNOTIFY_VOID(model_reduction_uses)
+#define __itt_model_reduction_uses ITTNOTIFY_VOID(model_reduction_uses)
 #define __itt_model_reduction_uses_ptr ITTNOTIFY_NAME(model_reduction_uses)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_model_reduction_uses(addr, size)
-#define __itt_model_reduction_uses_ptr   0
+#define __itt_model_reduction_uses_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_model_reduction_uses_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_reduction_uses_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief ANNOTATE_OBSERVE_USES support
  *
  * Have correctness modeling record observations about uses of storage
  * through the end of the current site
  */
-void ITTAPI __itt_model_observe_uses(void* addr, size_t size);
+void ITTAPI __itt_model_observe_uses(void *addr, size_t size);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, model_observe_uses, (void *addr, size_t size))
-#define __itt_model_observe_uses     ITTNOTIFY_VOID(model_observe_uses)
+#define __itt_model_observe_uses ITTNOTIFY_VOID(model_observe_uses)
 #define __itt_model_observe_uses_ptr ITTNOTIFY_NAME(model_observe_uses)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_model_observe_uses(addr, size)
-#define __itt_model_observe_uses_ptr   0
+#define __itt_model_observe_uses_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_model_observe_uses_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_model_observe_uses_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief ANNOTATE_CLEAR_USES support
  *
  * Clear the special handling of a piece of storage related to induction,
  * reduction or observe_uses
  */
-void ITTAPI __itt_model_clear_uses(void* addr);
+void ITTAPI __itt_model_clear_uses(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, model_clear_uses, (void *addr))
-#define __itt_model_clear_uses     ITTNOTIFY_VOID(model_clear_uses)
+#define __itt_model_clear_uses ITTNOTIFY_VOID(model_clear_uses)
 #define __itt_model_clear_uses_ptr ITTNOTIFY_NAME(model_clear_uses)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_model_clear_uses(addr)
 #define __itt_model_clear_uses_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_model_clear_uses_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief ANNOTATE_DISABLE_*_PUSH/ANNOTATE_DISABLE_*_POP support
  *
  * disable_push/disable_pop push and pop disabling based on a parameter.

 void ITTAPI __itt_model_disable_push(__itt_model_disable x);
 void ITTAPI __itt_model_disable_pop(void);
 void ITTAPI __itt_model_aggregate_task(size_t x);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, model_disable_push, (__itt_model_disable x))
-ITT_STUBV(ITTAPI, void, model_disable_pop,  (void))
+ITT_STUBV(ITTAPI, void, model_disable_pop, (void))
 ITT_STUBV(ITTAPI, void, model_aggregate_task, (size_t x))
-#define __itt_model_disable_push     ITTNOTIFY_VOID(model_disable_push)
+#define __itt_model_disable_push ITTNOTIFY_VOID(model_disable_push)
 #define __itt_model_disable_push_ptr ITTNOTIFY_NAME(model_disable_push)
-#define __itt_model_disable_pop      ITTNOTIFY_VOID(model_disable_pop)
-#define __itt_model_disable_pop_ptr  ITTNOTIFY_NAME(model_disable_pop)
-#define __itt_model_aggregate_task      ITTNOTIFY_VOID(model_aggregate_task)
-#define __itt_model_aggregate_task_ptr  ITTNOTIFY_NAME(model_aggregate_task)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_model_disable_pop ITTNOTIFY_VOID(model_disable_pop)
+#define __itt_model_disable_pop_ptr ITTNOTIFY_NAME(model_disable_pop)
+#define __itt_model_aggregate_task ITTNOTIFY_VOID(model_aggregate_task)
+#define __itt_model_aggregate_task_ptr ITTNOTIFY_NAME(model_aggregate_task)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_model_disable_push(x)
 #define __itt_model_disable_push_ptr 0
 #define __itt_model_disable_pop()
 #define __itt_model_disable_pop_ptr 0
 #define __itt_model_aggregate_task(x)
 #define __itt_model_aggregate_task_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_model_disable_push_ptr 0
 #define __itt_model_disable_pop_ptr 0
 #define __itt_model_aggregate_task_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} model group */
 
 /**
  * @defgroup heap Heap
  * @ingroup public
  * Heap group
  * @{
  */
 
-typedef void* __itt_heap_function;
+typedef void *__itt_heap_function;
 
 /**
  * @brief Create an identification for heap function
  * @return non-zero identifier or NULL
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_heap_function ITTAPI __itt_heap_function_createA(const char*    name, const char*    domain);
-__itt_heap_function ITTAPI __itt_heap_function_createW(const wchar_t* name, const wchar_t* domain);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_heap_function ITTAPI __itt_heap_function_createA(const char *name,
+                                                       const char *domain);
+__itt_heap_function ITTAPI __itt_heap_function_createW(const wchar_t *name,
+                                                       const wchar_t *domain);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_heap_function_create     __itt_heap_function_createW
-#  define __itt_heap_function_create_ptr __itt_heap_function_createW_ptr
+#define __itt_heap_function_create __itt_heap_function_createW
+#define __itt_heap_function_create_ptr __itt_heap_function_createW_ptr
 #else
-#  define __itt_heap_function_create     __itt_heap_function_createA
-#  define __itt_heap_function_create_ptr __itt_heap_function_createA_ptr
+#define __itt_heap_function_create __itt_heap_function_createA
+#define __itt_heap_function_create_ptr __itt_heap_function_createA_ptr
 #endif /* UNICODE */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-__itt_heap_function ITTAPI __itt_heap_function_create(const char* name, const char* domain);
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_heap_function ITTAPI __itt_heap_function_create(const char *name,
+                                                      const char *domain);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA, (const char*    name, const char*    domain))
-ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW, (const wchar_t* name, const wchar_t* domain))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create,  (const char*    name, const char*    domain))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA,
+         (const char *name, const char *domain))
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW,
+         (const wchar_t *name, const wchar_t *domain))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create,
+         (const char *name, const char *domain))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_heap_function_createA     ITTNOTIFY_DATA(heap_function_createA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_heap_function_createA ITTNOTIFY_DATA(heap_function_createA)
 #define __itt_heap_function_createA_ptr ITTNOTIFY_NAME(heap_function_createA)
-#define __itt_heap_function_createW     ITTNOTIFY_DATA(heap_function_createW)
+#define __itt_heap_function_createW ITTNOTIFY_DATA(heap_function_createW)
 #define __itt_heap_function_createW_ptr ITTNOTIFY_NAME(heap_function_createW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_heap_function_create      ITTNOTIFY_DATA(heap_function_create)
-#define __itt_heap_function_create_ptr  ITTNOTIFY_NAME(heap_function_create)
+#define __itt_heap_function_create ITTNOTIFY_DATA(heap_function_create)
+#define __itt_heap_function_create_ptr ITTNOTIFY_NAME(heap_function_create)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_heap_function_createA(name, domain) (__itt_heap_function)0
 #define __itt_heap_function_createA_ptr 0
 #define __itt_heap_function_createW(name, domain) (__itt_heap_function)0
 #define __itt_heap_function_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_heap_function_create(name, domain)  (__itt_heap_function)0
-#define __itt_heap_function_create_ptr  0
+#define __itt_heap_function_create(name, domain) (__itt_heap_function)0
+#define __itt_heap_function_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_heap_function_createA_ptr 0
 #define __itt_heap_function_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_heap_function_create_ptr  0
+#define __itt_heap_function_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record an allocation begin occurrence.
  */
-void ITTAPI __itt_heap_allocate_begin(__itt_heap_function h, size_t size, int initialized);
+void ITTAPI __itt_heap_allocate_begin(__itt_heap_function h, size_t size,
+                                      int initialized);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, heap_allocate_begin, (__itt_heap_function h, size_t size, int initialized))
-#define __itt_heap_allocate_begin     ITTNOTIFY_VOID(heap_allocate_begin)
+ITT_STUBV(ITTAPI, void, heap_allocate_begin,
+          (__itt_heap_function h, size_t size, int initialized))
+#define __itt_heap_allocate_begin ITTNOTIFY_VOID(heap_allocate_begin)
 #define __itt_heap_allocate_begin_ptr ITTNOTIFY_NAME(heap_allocate_begin)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_allocate_begin(h, size, initialized)
-#define __itt_heap_allocate_begin_ptr   0
+#define __itt_heap_allocate_begin_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_heap_allocate_begin_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_allocate_begin_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record an allocation end occurrence.
  */
-void ITTAPI __itt_heap_allocate_end(__itt_heap_function h, void** addr, size_t size, int initialized);
+void ITTAPI __itt_heap_allocate_end(__itt_heap_function h, void **addr,
+                                    size_t size, int initialized);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, heap_allocate_end, (__itt_heap_function h, void** addr, size_t size, int initialized))
-#define __itt_heap_allocate_end     ITTNOTIFY_VOID(heap_allocate_end)
+ITT_STUBV(ITTAPI, void, heap_allocate_end,
+          (__itt_heap_function h, void **addr, size_t size, int initialized))
+#define __itt_heap_allocate_end ITTNOTIFY_VOID(heap_allocate_end)
 #define __itt_heap_allocate_end_ptr ITTNOTIFY_NAME(heap_allocate_end)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_allocate_end(h, addr, size, initialized)
-#define __itt_heap_allocate_end_ptr   0
+#define __itt_heap_allocate_end_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_heap_allocate_end_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_allocate_end_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record a free begin occurrence.
  */
-void ITTAPI __itt_heap_free_begin(__itt_heap_function h, void* addr);
+void ITTAPI __itt_heap_free_begin(__itt_heap_function h, void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void* addr))
-#define __itt_heap_free_begin     ITTNOTIFY_VOID(heap_free_begin)
+ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void *addr))
+#define __itt_heap_free_begin ITTNOTIFY_VOID(heap_free_begin)
 #define __itt_heap_free_begin_ptr ITTNOTIFY_NAME(heap_free_begin)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_free_begin(h, addr)
-#define __itt_heap_free_begin_ptr   0
+#define __itt_heap_free_begin_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_heap_free_begin_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_free_begin_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record a free end occurrence.
  */
-void ITTAPI __itt_heap_free_end(__itt_heap_function h, void* addr);
+void ITTAPI __itt_heap_free_end(__itt_heap_function h, void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void* addr))
-#define __itt_heap_free_end     ITTNOTIFY_VOID(heap_free_end)
+ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void *addr))
+#define __itt_heap_free_end ITTNOTIFY_VOID(heap_free_end)
 #define __itt_heap_free_end_ptr ITTNOTIFY_NAME(heap_free_end)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_free_end(h, addr)
-#define __itt_heap_free_end_ptr   0
+#define __itt_heap_free_end_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_heap_free_end_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_free_end_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record a reallocation begin occurrence.
  */
-void ITTAPI __itt_heap_reallocate_begin(__itt_heap_function h, void* addr, size_t new_size, int initialized);
+void ITTAPI __itt_heap_reallocate_begin(__itt_heap_function h, void *addr,
+                                        size_t new_size, int initialized);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, heap_reallocate_begin, (__itt_heap_function h, void* addr, size_t new_size, int initialized))
-#define __itt_heap_reallocate_begin     ITTNOTIFY_VOID(heap_reallocate_begin)
+ITT_STUBV(ITTAPI, void, heap_reallocate_begin,
+          (__itt_heap_function h, void *addr, size_t new_size, int initialized))
+#define __itt_heap_reallocate_begin ITTNOTIFY_VOID(heap_reallocate_begin)
 #define __itt_heap_reallocate_begin_ptr ITTNOTIFY_NAME(heap_reallocate_begin)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_reallocate_begin(h, addr, new_size, initialized)
-#define __itt_heap_reallocate_begin_ptr   0
+#define __itt_heap_reallocate_begin_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_heap_reallocate_begin_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_reallocate_begin_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record a reallocation end occurrence.
  */
-void ITTAPI __itt_heap_reallocate_end(__itt_heap_function h, void* addr, void** new_addr, size_t new_size, int initialized);
+void ITTAPI __itt_heap_reallocate_end(__itt_heap_function h, void *addr,
+                                      void **new_addr, size_t new_size,
+                                      int initialized);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, heap_reallocate_end, (__itt_heap_function h, void* addr, void** new_addr, size_t new_size, int initialized))
-#define __itt_heap_reallocate_end     ITTNOTIFY_VOID(heap_reallocate_end)
+ITT_STUBV(ITTAPI, void, heap_reallocate_end,
+          (__itt_heap_function h, void *addr, void **new_addr, size_t new_size,
+           int initialized))
+#define __itt_heap_reallocate_end ITTNOTIFY_VOID(heap_reallocate_end)
 #define __itt_heap_reallocate_end_ptr ITTNOTIFY_NAME(heap_reallocate_end)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_reallocate_end(h, addr, new_addr, new_size, initialized)
-#define __itt_heap_reallocate_end_ptr   0
+#define __itt_heap_reallocate_end_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_heap_reallocate_end_ptr   0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_reallocate_end_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @brief internal access begin */
 void ITTAPI __itt_heap_internal_access_begin(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, heap_internal_access_begin,  (void))
-#define __itt_heap_internal_access_begin      ITTNOTIFY_VOID(heap_internal_access_begin)
-#define __itt_heap_internal_access_begin_ptr  ITTNOTIFY_NAME(heap_internal_access_begin)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void))
+#define __itt_heap_internal_access_begin                                       \
+  ITTNOTIFY_VOID(heap_internal_access_begin)
+#define __itt_heap_internal_access_begin_ptr                                   \
+  ITTNOTIFY_NAME(heap_internal_access_begin)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_internal_access_begin()
-#define __itt_heap_internal_access_begin_ptr  0
+#define __itt_heap_internal_access_begin_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_heap_internal_access_begin_ptr  0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_internal_access_begin_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @brief internal access end */
 void ITTAPI __itt_heap_internal_access_end(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, heap_internal_access_end, (void))
-#define __itt_heap_internal_access_end     ITTNOTIFY_VOID(heap_internal_access_end)
-#define __itt_heap_internal_access_end_ptr ITTNOTIFY_NAME(heap_internal_access_end)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_internal_access_end ITTNOTIFY_VOID(heap_internal_access_end)
+#define __itt_heap_internal_access_end_ptr                                     \
+  ITTNOTIFY_NAME(heap_internal_access_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_internal_access_end()
 #define __itt_heap_internal_access_end_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_heap_internal_access_end_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @brief record memory growth begin */
 void ITTAPI __itt_heap_record_memory_growth_begin(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin,  (void))
-#define __itt_heap_record_memory_growth_begin      ITTNOTIFY_VOID(heap_record_memory_growth_begin)
-#define __itt_heap_record_memory_growth_begin_ptr  ITTNOTIFY_NAME(heap_record_memory_growth_begin)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void))
+#define __itt_heap_record_memory_growth_begin                                  \
+  ITTNOTIFY_VOID(heap_record_memory_growth_begin)
+#define __itt_heap_record_memory_growth_begin_ptr                              \
+  ITTNOTIFY_NAME(heap_record_memory_growth_begin)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_record_memory_growth_begin()
-#define __itt_heap_record_memory_growth_begin_ptr  0
+#define __itt_heap_record_memory_growth_begin_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_heap_record_memory_growth_begin_ptr  0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_record_memory_growth_begin_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @brief record memory growth end */
 void ITTAPI __itt_heap_record_memory_growth_end(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end, (void))
-#define __itt_heap_record_memory_growth_end     ITTNOTIFY_VOID(heap_record_memory_growth_end)
-#define __itt_heap_record_memory_growth_end_ptr ITTNOTIFY_NAME(heap_record_memory_growth_end)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_heap_record_memory_growth_end                                    \
+  ITTNOTIFY_VOID(heap_record_memory_growth_end)
+#define __itt_heap_record_memory_growth_end_ptr                                \
+  ITTNOTIFY_NAME(heap_record_memory_growth_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_record_memory_growth_end()
 #define __itt_heap_record_memory_growth_end_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_heap_record_memory_growth_end_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Specify the type of heap detection/reporting to modify.
  */
 /**
  * @hideinitializer
  * @brief Report on memory leaks.
  */
 #define __itt_heap_leaks 0x00000001
 
 /**
  * @hideinitializer
  * @brief Report on memory growth.
  */
 #define __itt_heap_growth 0x00000002
 
-
 /** @brief heap reset detection */
 void ITTAPI __itt_heap_reset_detection(unsigned int reset_mask);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, heap_reset_detection,  (unsigned int reset_mask))
-#define __itt_heap_reset_detection      ITTNOTIFY_VOID(heap_reset_detection)
-#define __itt_heap_reset_detection_ptr  ITTNOTIFY_NAME(heap_reset_detection)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask))
+#define __itt_heap_reset_detection ITTNOTIFY_VOID(heap_reset_detection)
+#define __itt_heap_reset_detection_ptr ITTNOTIFY_NAME(heap_reset_detection)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_reset_detection()
-#define __itt_heap_reset_detection_ptr  0
+#define __itt_heap_reset_detection_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_heap_reset_detection_ptr  0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_heap_reset_detection_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @brief report */
 void ITTAPI __itt_heap_record(unsigned int record_mask);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, heap_record, (unsigned int record_mask))
-#define __itt_heap_record     ITTNOTIFY_VOID(heap_record)
+#define __itt_heap_record ITTNOTIFY_VOID(heap_record)
 #define __itt_heap_record_ptr ITTNOTIFY_NAME(heap_record)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_record()
 #define __itt_heap_record_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_heap_record_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @} heap group */
 /** @endcond */
 /* ========================================================================== */
 
 /**
  * @defgroup domains Domains
  * @ingroup public
  * Domains group
  * @{
  */
 
 /** @cond exclude_from_documentation */
 #pragma pack(push, 8)
 
-typedef struct ___itt_domain
-{
-    volatile int flags; /*!< Zero if disabled, non-zero if enabled. The meaning of different non-zero values is reserved to the runtime */
-    const char* nameA;  /*!< Copy of original name in ASCII. */
+typedef struct ___itt_domain {
+  volatile int flags; /*!< Zero if disabled, non-zero if enabled. The meaning of
+                         different non-zero values is reserved to the runtime */
+  const char *nameA; /*!< Copy of original name in ASCII. */
 #if defined(UNICODE) || defined(_UNICODE)
-    const wchar_t* nameW; /*!< Copy of original name in UNICODE. */
-#else  /* UNICODE || _UNICODE */
-    void* nameW;
+  const wchar_t *nameW; /*!< Copy of original name in UNICODE. */
+#else /* UNICODE || _UNICODE */
+  void *nameW;
 #endif /* UNICODE || _UNICODE */
-    int   extra1; /*!< Reserved to the runtime */
-    void* extra2; /*!< Reserved to the runtime */
-    struct ___itt_domain* next;
+  int extra1; /*!< Reserved to the runtime */
+  void *extra2; /*!< Reserved to the runtime */
+  struct ___itt_domain *next;
 } __itt_domain;
 
 #pragma pack(pop)
 /** @endcond */
 
 /**
  * @ingroup domains
  * @brief Create a domain.
  * Create domain using some domain name: the URI naming style is recommended.
  * Because the set of domains is expected to be static over the application's
  * execution time, there is no mechanism to destroy a domain.
  * Any domain can be accessed by any thread in the process, regardless of
  * which thread created the domain. This call is thread-safe.
  * @param[in] name name of domain
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_domain* ITTAPI __itt_domain_createA(const char    *name);
-__itt_domain* ITTAPI __itt_domain_createW(const wchar_t *name);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_domain *ITTAPI __itt_domain_createA(const char *name);
+__itt_domain *ITTAPI __itt_domain_createW(const wchar_t *name);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_domain_create     __itt_domain_createW
-#  define __itt_domain_create_ptr __itt_domain_createW_ptr
+#define __itt_domain_create __itt_domain_createW
+#define __itt_domain_create_ptr __itt_domain_createW_ptr
 #else /* UNICODE */
-#  define __itt_domain_create     __itt_domain_createA
-#  define __itt_domain_create_ptr __itt_domain_createA_ptr
+#define __itt_domain_create __itt_domain_createA
+#define __itt_domain_create_ptr __itt_domain_createA_ptr
 #endif /* UNICODE */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-__itt_domain* ITTAPI __itt_domain_create(const char *name);
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_domain *ITTAPI __itt_domain_create(const char *name);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_domain*, domain_createA, (const char    *name))
-ITT_STUB(ITTAPI, __itt_domain*, domain_createW, (const wchar_t *name))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_domain*, domain_create,  (const char    *name))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_domain *, domain_createA, (const char *name))
+ITT_STUB(ITTAPI, __itt_domain *, domain_createW, (const wchar_t *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_domain *, domain_create, (const char *name))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_domain_createA     ITTNOTIFY_DATA(domain_createA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_domain_createA ITTNOTIFY_DATA(domain_createA)
 #define __itt_domain_createA_ptr ITTNOTIFY_NAME(domain_createA)
-#define __itt_domain_createW     ITTNOTIFY_DATA(domain_createW)
+#define __itt_domain_createW ITTNOTIFY_DATA(domain_createW)
 #define __itt_domain_createW_ptr ITTNOTIFY_NAME(domain_createW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_domain_create     ITTNOTIFY_DATA(domain_create)
+#define __itt_domain_create ITTNOTIFY_DATA(domain_create)
 #define __itt_domain_create_ptr ITTNOTIFY_NAME(domain_create)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_domain_createA(name) (__itt_domain*)0
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_domain_createA(name) (__itt_domain *)0
 #define __itt_domain_createA_ptr 0
-#define __itt_domain_createW(name) (__itt_domain*)0
+#define __itt_domain_createW(name) (__itt_domain *)0
 #define __itt_domain_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_domain_create(name)  (__itt_domain*)0
+#define __itt_domain_create(name) (__itt_domain *)0
 #define __itt_domain_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_domain_createA_ptr 0
 #define __itt_domain_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_domain_create_ptr  0
+#define __itt_domain_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} domains group */
 
 /**
  * @defgroup ids IDs
  * @ingroup public
  * IDs group
  * @{
  */
 
 /** @cond exclude_from_documentation */
 #pragma pack(push, 8)
 
-typedef struct ___itt_id
-{
-    unsigned long long d1, d2, d3;
+typedef struct ___itt_id {
 } __itt_id;
 
 #pragma pack(pop)
 /** @endcond */
 
-static const __itt_id __itt_null = { 0, 0, 0 };
+static const __itt_id __itt_null = {0, 0, 0};
 
 /**
  * @ingroup ids
- * @brief A convenience function is provided to create an ID without domain control.
- * @brief This is a convenience function to initialize an __itt_id structure. This function
- * does not affect the collector runtime in any way. After you make the ID with this
- * function, you still must create it with the __itt_id_create function before using the ID
- * to identify a named entity.
+ * @brief A convenience function is provided to create an ID without domain
+ * control.
+ * @brief This is a convenience function to initialize an __itt_id structure.
+ * This function does not affect the collector runtime in any way. After you
+ * make the ID with this function, you still must create it with the
+ * __itt_id_create function before using the ID to identify a named entity.
  * @param[in] addr The address of object; high QWORD of the ID value.
- * @param[in] extra The extra data to unique identify object; low QWORD of the ID value.
+ * @param[in] extra The extra data to unique identify object; low QWORD of the
+ * ID value.
  */
 
-ITT_INLINE __itt_id ITTAPI __itt_id_make(void* addr, unsigned long long extra) ITT_INLINE_ATTRIBUTE;
-ITT_INLINE __itt_id ITTAPI __itt_id_make(void* addr, unsigned long long extra)
-{
-    __itt_id id = __itt_null;
-    id.d1 = (unsigned long long)((uintptr_t)addr);
-    id.d2 = (unsigned long long)extra;
-    id.d3 = (unsigned long long)0; /* Reserved. Must be zero */
-    return id;
+ITT_INLINE __itt_id ITTAPI __itt_id_make(void *addr, unsigned long long extra)
+    ITT_INLINE_ATTRIBUTE;
+ITT_INLINE __itt_id ITTAPI __itt_id_make(void *addr, unsigned long long extra) {
 }
 
 /**
  * @ingroup ids
  * @brief Create an instance of identifier.
  * This establishes the beginning of the lifetime of an instance of
  * the given ID in the trace. Once this lifetime starts, the ID
  * can be used to tag named entity instances in calls such as
  * __itt_task_begin, and to specify relationships among
  * identified named entity instances, using the \ref relations APIs.
  * Instance IDs are not domain specific!
  * @param[in] domain The domain controlling the execution of this call.
  * @param[in] id The ID to create.
  */
 void ITTAPI __itt_id_create(const __itt_domain *domain, __itt_id id);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, id_create, (const __itt_domain *domain, __itt_id id))
-#define __itt_id_create(d,x) ITTNOTIFY_VOID_D1(id_create,d,x)
-#define __itt_id_create_ptr  ITTNOTIFY_NAME(id_create)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_id_create(domain,id)
+#define __itt_id_create(d, x) ITTNOTIFY_VOID_D1(id_create, d, x)
+#define __itt_id_create_ptr ITTNOTIFY_NAME(id_create)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_id_create(domain, id)
 #define __itt_id_create_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_id_create_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup ids
  * @brief Destroy an instance of identifier.
- * This ends the lifetime of the current instance of the given ID value in the trace.
- * Any relationships that are established after this lifetime ends are invalid.
- * This call must be performed before the given ID value can be reused for a different
- * named entity instance.
+ * This ends the lifetime of the current instance of the given ID value in the
+ * trace. Any relationships that are established after this lifetime ends are
+ * invalid. This call must be performed before the given ID value can be reused
+ * for a different named entity instance.
  * @param[in] domain The domain controlling the execution of this call.
  * @param[in] id The ID to destroy.
  */
 void ITTAPI __itt_id_destroy(const __itt_domain *domain, __itt_id id);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id))
-#define __itt_id_destroy(d,x) ITTNOTIFY_VOID_D1(id_destroy,d,x)
-#define __itt_id_destroy_ptr  ITTNOTIFY_NAME(id_destroy)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_id_destroy(domain,id)
+#define __itt_id_destroy(d, x) ITTNOTIFY_VOID_D1(id_destroy, d, x)
+#define __itt_id_destroy_ptr ITTNOTIFY_NAME(id_destroy)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_id_destroy(domain, id)
 #define __itt_id_destroy_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_id_destroy_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} ids group */
 
 /**
  * @defgroup handless String Handles
  * @ingroup public
  * String Handles group
  * @{
  */
 
 /** @cond exclude_from_documentation */
 #pragma pack(push, 8)
 
-typedef struct ___itt_string_handle
-{
-    const char* strA; /*!< Copy of original string in ASCII. */
+typedef struct ___itt_string_handle {
+  const char *strA; /*!< Copy of original string in ASCII. */
 #if defined(UNICODE) || defined(_UNICODE)
-    const wchar_t* strW; /*!< Copy of original string in UNICODE. */
-#else  /* UNICODE || _UNICODE */
-    void* strW;
+  const wchar_t *strW; /*!< Copy of original string in UNICODE. */
+#else /* UNICODE || _UNICODE */
+  void *strW;
 #endif /* UNICODE || _UNICODE */
-    int   extra1; /*!< Reserved. Must be zero   */
-    void* extra2; /*!< Reserved. Must be zero   */
-    struct ___itt_string_handle* next;
+  int extra1; /*!< Reserved. Must be zero   */
+  void *extra2; /*!< Reserved. Must be zero   */
+  struct ___itt_string_handle *next;
 } __itt_string_handle;
 
 #pragma pack(pop)
 /** @endcond */
 
 /**
  * @ingroup handles
  * @brief Create a string handle.
  * Create and return handle value that can be associated with a string.
  * Consecutive calls to __itt_string_handle_create with the same name
- * return the same value. Because the set of string handles is expected to remain
- * static during the application's execution time, there is no mechanism to destroy a string handle.
- * Any string handle can be accessed by any thread in the process, regardless of which thread created
- * the string handle. This call is thread-safe.
+ * return the same value. Because the set of string handles is expected to
+ * remain static during the application's execution time, there is no mechanism
+ * to destroy a string handle. Any string handle can be accessed by any thread
+ * in the process, regardless of which thread created the string handle. This
+ * call is thread-safe.
  * @param[in] name The input string
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_string_handle* ITTAPI __itt_string_handle_createA(const char    *name);
-__itt_string_handle* ITTAPI __itt_string_handle_createW(const wchar_t *name);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_string_handle *ITTAPI __itt_string_handle_createA(const char *name);
+__itt_string_handle *ITTAPI __itt_string_handle_createW(const wchar_t *name);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_string_handle_create     __itt_string_handle_createW
-#  define __itt_string_handle_create_ptr __itt_string_handle_createW_ptr
+#define __itt_string_handle_create __itt_string_handle_createW
+#define __itt_string_handle_create_ptr __itt_string_handle_createW_ptr
 #else /* UNICODE */
-#  define __itt_string_handle_create     __itt_string_handle_createA
-#  define __itt_string_handle_create_ptr __itt_string_handle_createA_ptr
+#define __itt_string_handle_create __itt_string_handle_createA
+#define __itt_string_handle_create_ptr __itt_string_handle_createA_ptr
 #endif /* UNICODE */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-__itt_string_handle* ITTAPI __itt_string_handle_create(const char *name);
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+__itt_string_handle *ITTAPI __itt_string_handle_create(const char *name);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createA, (const char    *name))
-ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createW, (const wchar_t *name))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_create,  (const char    *name))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createA,
+         (const char *name))
+ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createW,
+         (const wchar_t *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_create,
+         (const char *name))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_string_handle_createA     ITTNOTIFY_DATA(string_handle_createA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_string_handle_createA ITTNOTIFY_DATA(string_handle_createA)
 #define __itt_string_handle_createA_ptr ITTNOTIFY_NAME(string_handle_createA)
-#define __itt_string_handle_createW     ITTNOTIFY_DATA(string_handle_createW)
+#define __itt_string_handle_createW ITTNOTIFY_DATA(string_handle_createW)
 #define __itt_string_handle_createW_ptr ITTNOTIFY_NAME(string_handle_createW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_string_handle_create     ITTNOTIFY_DATA(string_handle_create)
+#define __itt_string_handle_create ITTNOTIFY_DATA(string_handle_create)
 #define __itt_string_handle_create_ptr ITTNOTIFY_NAME(string_handle_create)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_string_handle_createA(name) (__itt_string_handle*)0
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_string_handle_createA(name) (__itt_string_handle *)0
 #define __itt_string_handle_createA_ptr 0
-#define __itt_string_handle_createW(name) (__itt_string_handle*)0
+#define __itt_string_handle_createW(name) (__itt_string_handle *)0
 #define __itt_string_handle_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_string_handle_create(name)  (__itt_string_handle*)0
+#define __itt_string_handle_create(name) (__itt_string_handle *)0
 #define __itt_string_handle_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_string_handle_createA_ptr 0
 #define __itt_string_handle_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_string_handle_create_ptr  0
+#define __itt_string_handle_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} handles group */
 
 /** @cond exclude_from_documentation */
 typedef unsigned long long __itt_timestamp;
 /** @endcond */
 
 #define __itt_timestamp_none ((__itt_timestamp)-1LL)
 
 /** @cond exclude_from_gpa_documentation */
 
 /**
  * @ingroup timestamps
  * @brief Return timestamp corresponding to the current moment.
- * This returns the timestamp in the format that is the most relevant for the current
- * host or platform (RDTSC, QPC, and others). You can use the "<" operator to
- * compare __itt_timestamp values.
+ * This returns the timestamp in the format that is the most relevant for the
+ * current host or platform (RDTSC, QPC, and others). You can use the "<"
+ * operator to compare __itt_timestamp values.
  */
 __itt_timestamp ITTAPI __itt_get_timestamp(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void))
-#define __itt_get_timestamp      ITTNOTIFY_DATA(get_timestamp)
-#define __itt_get_timestamp_ptr  ITTNOTIFY_NAME(get_timestamp)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_get_timestamp ITTNOTIFY_DATA(get_timestamp)
+#define __itt_get_timestamp_ptr ITTNOTIFY_NAME(get_timestamp)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_get_timestamp()
 #define __itt_get_timestamp_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_get_timestamp_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} timestamps */
 /** @endcond */
 
 /** @cond exclude_from_gpa_documentation */
 
 /**
  * @defgroup regions Regions
  * @ingroup public
  * Regions group
  * @{
  */
 /**
  * @ingroup regions
  * @brief Begin of region instance.
  * Successive calls to __itt_region_begin with the same ID are ignored
  * until a call to __itt_region_end with the same ID
  * @param[in] domain The domain for this region instance
- * @param[in] id The instance ID for this region instance. Must not be __itt_null
- * @param[in] parentid The instance ID for the parent of this region instance, or __itt_null
+ * @param[in] id The instance ID for this region instance. Must not be
+ * __itt_null
+ * @param[in] parentid The instance ID for the parent of this region instance,
+ * or __itt_null
  * @param[in] name The name of this region
  */
-void ITTAPI __itt_region_begin(const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name);
+void ITTAPI __itt_region_begin(const __itt_domain *domain, __itt_id id,
+                               __itt_id parentid, __itt_string_handle *name);
 
 /**
  * @ingroup regions
  * @brief End of region instance.
  * The first call to __itt_region_end with a given ID ends the
  * region. Successive calls with the same ID are ignored, as are
  * calls that do not have a matching __itt_region_begin call.
  * @param[in] domain The domain for this region instance
  * @param[in] id The instance ID for this region instance
  */
 void ITTAPI __itt_region_end(const __itt_domain *domain, __itt_id id);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, region_begin, (const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name))
-ITT_STUBV(ITTAPI, void, region_end,   (const __itt_domain *domain, __itt_id id))
-#define __itt_region_begin(d,x,y,z) ITTNOTIFY_VOID_D3(region_begin,d,x,y,z)
-#define __itt_region_begin_ptr      ITTNOTIFY_NAME(region_begin)
-#define __itt_region_end(d,x)       ITTNOTIFY_VOID_D1(region_end,d,x)
-#define __itt_region_end_ptr        ITTNOTIFY_NAME(region_end)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_region_begin(d,x,y,z)
+ITT_STUBV(ITTAPI, void, region_begin,
+          (const __itt_domain *domain, __itt_id id, __itt_id parentid,
+           __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, region_end, (const __itt_domain *domain, __itt_id id))
+#define __itt_region_begin(d, x, y, z)                                         \
+  ITTNOTIFY_VOID_D3(region_begin, d, x, y, z)
+#define __itt_region_begin_ptr ITTNOTIFY_NAME(region_begin)
+#define __itt_region_end(d, x) ITTNOTIFY_VOID_D1(region_end, d, x)
+#define __itt_region_end_ptr ITTNOTIFY_NAME(region_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_region_begin(d, x, y, z)
 #define __itt_region_begin_ptr 0
-#define __itt_region_end(d,x)
-#define __itt_region_end_ptr   0
+#define __itt_region_end(d, x)
+#define __itt_region_end_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_region_begin_ptr 0
-#define __itt_region_end_ptr   0
+#define __itt_region_end_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} regions group */
 
 /**
  * @defgroup frames Frames
  * @ingroup public
- * Frames are similar to regions, but are intended to be easier to use and to implement.
- * In particular:
+ * Frames are similar to regions, but are intended to be easier to use and to
+ * implement. In particular:
  * - Frames always represent periods of elapsed time
  * - By default, frames have no nesting relationships
  * @{
  */
 
 /**
  * @ingroup frames
  * @brief Begin a frame instance.

  * Passing special __itt_timestamp_none value as "end" argument means
  * take the current timestamp as the end timestamp.
  * @param[in] domain The domain for this frame instance
  * @param[in] id The instance ID for this frame instance or NULL
  * @param[in] begin Timestamp of the beginning of the frame
  * @param[in] end Timestamp of the end of the frame
  */
 void ITTAPI __itt_frame_submit_v3(const __itt_domain *domain, __itt_id *id,
                                   __itt_timestamp begin, __itt_timestamp end);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, frame_begin_v3,  (const __itt_domain *domain, __itt_id *id))
-ITT_STUBV(ITTAPI, void, frame_end_v3,    (const __itt_domain *domain, __itt_id *id))
-ITT_STUBV(ITTAPI, void, frame_submit_v3, (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin, __itt_timestamp end))
-#define __itt_frame_begin_v3(d,x)      ITTNOTIFY_VOID_D1(frame_begin_v3,d,x)
-#define __itt_frame_begin_v3_ptr       ITTNOTIFY_NAME(frame_begin_v3)
-#define __itt_frame_end_v3(d,x)        ITTNOTIFY_VOID_D1(frame_end_v3,d,x)
-#define __itt_frame_end_v3_ptr         ITTNOTIFY_NAME(frame_end_v3)
-#define __itt_frame_submit_v3(d,x,b,e) ITTNOTIFY_VOID_D3(frame_submit_v3,d,x,b,e)
-#define __itt_frame_submit_v3_ptr      ITTNOTIFY_NAME(frame_submit_v3)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_frame_begin_v3(domain,id)
+ITT_STUBV(ITTAPI, void, frame_begin_v3,
+          (const __itt_domain *domain, __itt_id *id))
+ITT_STUBV(ITTAPI, void, frame_end_v3,
+          (const __itt_domain *domain, __itt_id *id))
+ITT_STUBV(ITTAPI, void, frame_submit_v3,
+          (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin,
+           __itt_timestamp end))
+#define __itt_frame_begin_v3(d, x) ITTNOTIFY_VOID_D1(frame_begin_v3, d, x)
+#define __itt_frame_begin_v3_ptr ITTNOTIFY_NAME(frame_begin_v3)
+#define __itt_frame_end_v3(d, x) ITTNOTIFY_VOID_D1(frame_end_v3, d, x)
+#define __itt_frame_end_v3_ptr ITTNOTIFY_NAME(frame_end_v3)
+#define __itt_frame_submit_v3(d, x, b, e)                                      \
+  ITTNOTIFY_VOID_D3(frame_submit_v3, d, x, b, e)
+#define __itt_frame_submit_v3_ptr ITTNOTIFY_NAME(frame_submit_v3)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_frame_begin_v3(domain, id)
 #define __itt_frame_begin_v3_ptr 0
-#define __itt_frame_end_v3(domain,id)
-#define __itt_frame_end_v3_ptr   0
-#define __itt_frame_submit_v3(domain,id,begin,end)
-#define __itt_frame_submit_v3_ptr   0
+#define __itt_frame_end_v3(domain, id)
+#define __itt_frame_end_v3_ptr 0
+#define __itt_frame_submit_v3(domain, id, begin, end)
+#define __itt_frame_submit_v3_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_frame_begin_v3_ptr 0
-#define __itt_frame_end_v3_ptr   0
-#define __itt_frame_submit_v3_ptr   0
+#define __itt_frame_end_v3_ptr 0
+#define __itt_frame_submit_v3_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} frames group */
 /** @endcond */
 
 /**
  * @defgroup taskgroup Task Group
  * @ingroup public
  * Task Group
  * @{
  */
 /**
  * @ingroup task_groups
  * @brief Denotes a task_group instance.
  * Successive calls to __itt_task_group with the same ID are ignored.
  * @param[in] domain The domain for this task_group instance
- * @param[in] id The instance ID for this task_group instance. Must not be __itt_null.
- * @param[in] parentid The instance ID for the parent of this task_group instance, or __itt_null.
+ * @param[in] id The instance ID for this task_group instance. Must not be
+ * __itt_null.
+ * @param[in] parentid The instance ID for the parent of this task_group
+ * instance, or __itt_null.
  * @param[in] name The name of this task_group
  */
-void ITTAPI __itt_task_group(const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name);
+void ITTAPI __itt_task_group(const __itt_domain *domain, __itt_id id,
+                             __itt_id parentid, __itt_string_handle *name);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, task_group, (const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name))
-#define __itt_task_group(d,x,y,z) ITTNOTIFY_VOID_D3(task_group,d,x,y,z)
-#define __itt_task_group_ptr      ITTNOTIFY_NAME(task_group)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_task_group(d,x,y,z)
+ITT_STUBV(ITTAPI, void, task_group,
+          (const __itt_domain *domain, __itt_id id, __itt_id parentid,
+           __itt_string_handle *name))
+#define __itt_task_group(d, x, y, z) ITTNOTIFY_VOID_D3(task_group, d, x, y, z)
+#define __itt_task_group_ptr ITTNOTIFY_NAME(task_group)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_task_group(d, x, y, z)
 #define __itt_task_group_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_task_group_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} taskgroup group */
 
 /**
  * @defgroup tasks Tasks
  * @ingroup public

  * @{
  */
 
 /**
  * @ingroup tasks
  * @brief Begin a task instance.
  * @param[in] domain The domain for this task
  * @param[in] taskid The instance ID for this task instance, or __itt_null
- * @param[in] parentid The parent instance to which this task instance belongs, or __itt_null
+ * @param[in] parentid The parent instance to which this task instance belongs,
+ * or __itt_null
  * @param[in] name The name of this task
  */
-void ITTAPI __itt_task_begin(const __itt_domain *domain, __itt_id taskid, __itt_id parentid, __itt_string_handle *name);
+void ITTAPI __itt_task_begin(const __itt_domain *domain, __itt_id taskid,
+                             __itt_id parentid, __itt_string_handle *name);
 
 /**
  * @ingroup tasks
  * @brief Begin a task instance.
  * @param[in] domain The domain for this task
  * @param[in] taskid The identifier for this task instance (may be 0)
  * @param[in] parentid The parent of this task (may be 0)
  * @param[in] fn The pointer to the function you are tracing
  */
-void ITTAPI __itt_task_begin_fn(const __itt_domain *domain, __itt_id taskid, __itt_id parentid, void* fn);
+void ITTAPI __itt_task_begin_fn(const __itt_domain *domain, __itt_id taskid,
+                                __itt_id parentid, void *fn);
 
 /**
  * @ingroup tasks
  * @brief End the current task instance.
  * @param[in] domain The domain for this task
  */
 void ITTAPI __itt_task_end(const __itt_domain *domain);
 
 /**
  * @ingroup tasks
  * @brief Begin an overlapped task instance.
  * @param[in] domain The domain for this task.
- * @param[in] taskid The identifier for this task instance, *cannot* be __itt_null.
+ * @param[in] taskid The identifier for this task instance, *cannot* be
+ * __itt_null.
  * @param[in] parentid The parent of this task, or __itt_null.
  * @param[in] name The name of this task.
  */
-void ITTAPI __itt_task_begin_overlapped(const __itt_domain* domain, __itt_id taskid, __itt_id parentid, __itt_string_handle* name);
+void ITTAPI __itt_task_begin_overlapped(const __itt_domain *domain,
+                                        __itt_id taskid, __itt_id parentid,
+                                        __itt_string_handle *name);
 
 /**
  * @ingroup tasks
  * @brief End an overlapped task instance.
  * @param[in] domain The domain for this task
  * @param[in] taskid Explicit ID of finished task
  */
-void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain, __itt_id taskid);
+void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain,
+                                      __itt_id taskid);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, task_begin,    (const __itt_domain *domain, __itt_id id, __itt_id parentid, __itt_string_handle *name))
-ITT_STUBV(ITTAPI, void, task_begin_fn, (const __itt_domain *domain, __itt_id id, __itt_id parentid, void* fn))
-ITT_STUBV(ITTAPI, void, task_end,      (const __itt_domain *domain))
-ITT_STUBV(ITTAPI, void, task_begin_overlapped, (const __itt_domain *domain, __itt_id taskid, __itt_id parentid, __itt_string_handle *name))
-ITT_STUBV(ITTAPI, void, task_end_overlapped,   (const __itt_domain *domain, __itt_id taskid))
-#define __itt_task_begin(d,x,y,z)    ITTNOTIFY_VOID_D3(task_begin,d,x,y,z)
-#define __itt_task_begin_ptr         ITTNOTIFY_NAME(task_begin)
-#define __itt_task_begin_fn(d,x,y,z) ITTNOTIFY_VOID_D3(task_begin_fn,d,x,y,z)
-#define __itt_task_begin_fn_ptr      ITTNOTIFY_NAME(task_begin_fn)
-#define __itt_task_end(d)            ITTNOTIFY_VOID_D0(task_end,d)
-#define __itt_task_end_ptr           ITTNOTIFY_NAME(task_end)
-#define __itt_task_begin_overlapped(d,x,y,z) ITTNOTIFY_VOID_D3(task_begin_overlapped,d,x,y,z)
-#define __itt_task_begin_overlapped_ptr      ITTNOTIFY_NAME(task_begin_overlapped)
-#define __itt_task_end_overlapped(d,x)       ITTNOTIFY_VOID_D1(task_end_overlapped,d,x)
-#define __itt_task_end_overlapped_ptr        ITTNOTIFY_NAME(task_end_overlapped)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_task_begin(domain,id,parentid,name)
-#define __itt_task_begin_ptr    0
-#define __itt_task_begin_fn(domain,id,parentid,fn)
+ITT_STUBV(ITTAPI, void, task_begin,
+          (const __itt_domain *domain, __itt_id id, __itt_id parentid,
+           __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, task_begin_fn,
+          (const __itt_domain *domain, __itt_id id, __itt_id parentid,
+           void *fn))
+ITT_STUBV(ITTAPI, void, task_end, (const __itt_domain *domain))
+ITT_STUBV(ITTAPI, void, task_begin_overlapped,
+          (const __itt_domain *domain, __itt_id taskid, __itt_id parentid,
+           __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, task_end_overlapped,
+          (const __itt_domain *domain, __itt_id taskid))
+#define __itt_task_begin(d, x, y, z) ITTNOTIFY_VOID_D3(task_begin, d, x, y, z)
+#define __itt_task_begin_ptr ITTNOTIFY_NAME(task_begin)
+#define __itt_task_begin_fn(d, x, y, z)                                        \
+  ITTNOTIFY_VOID_D3(task_begin_fn, d, x, y, z)
+#define __itt_task_begin_fn_ptr ITTNOTIFY_NAME(task_begin_fn)
+#define __itt_task_end(d) ITTNOTIFY_VOID_D0(task_end, d)
+#define __itt_task_end_ptr ITTNOTIFY_NAME(task_end)
+#define __itt_task_begin_overlapped(d, x, y, z)                                \
+  ITTNOTIFY_VOID_D3(task_begin_overlapped, d, x, y, z)
+#define __itt_task_begin_overlapped_ptr ITTNOTIFY_NAME(task_begin_overlapped)
+#define __itt_task_end_overlapped(d, x)                                        \
+  ITTNOTIFY_VOID_D1(task_end_overlapped, d, x)
+#define __itt_task_end_overlapped_ptr ITTNOTIFY_NAME(task_end_overlapped)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_task_begin(domain, id, parentid, name)
+#define __itt_task_begin_ptr 0
+#define __itt_task_begin_fn(domain, id, parentid, fn)
 #define __itt_task_begin_fn_ptr 0
 #define __itt_task_end(domain)
-#define __itt_task_end_ptr      0
-#define __itt_task_begin_overlapped(domain,taskid,parentid,name)
-#define __itt_task_begin_overlapped_ptr         0
-#define __itt_task_end_overlapped(domain,taskid)
-#define __itt_task_end_overlapped_ptr           0
+#define __itt_task_end_ptr 0
+#define __itt_task_begin_overlapped(domain, taskid, parentid, name)
+#define __itt_task_begin_overlapped_ptr 0
+#define __itt_task_end_overlapped(domain, taskid)
+#define __itt_task_end_overlapped_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_task_begin_ptr    0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_task_begin_ptr 0
 #define __itt_task_begin_fn_ptr 0
-#define __itt_task_end_ptr      0
+#define __itt_task_end_ptr 0
 #define __itt_task_begin_overlapped_ptr 0
-#define __itt_task_end_overlapped_ptr   0
+#define __itt_task_end_overlapped_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} tasks group */
 
-
 /**
  * @defgroup markers Markers
  * Markers represent a single discreet event in time. Markers have a scope,
  * described by an enumerated type __itt_scope. Markers are created by
  * the API call __itt_marker. A marker instance can be given an ID for use in
  * adding metadata.
  * @{
  */
 
 /**
  * @brief Describes the scope of an event object in the trace.
  */
-typedef enum
-{
-    __itt_scope_unknown = 0,
-    __itt_scope_global,
-    __itt_scope_track_group,
-    __itt_scope_track,
-    __itt_scope_task,
-    __itt_scope_marker
+typedef enum {
 } __itt_scope;
 
 /** @cond exclude_from_documentation */
-#define __itt_marker_scope_unknown  __itt_scope_unknown
-#define __itt_marker_scope_global   __itt_scope_global
-#define __itt_marker_scope_process  __itt_scope_track_group
-#define __itt_marker_scope_thread   __itt_scope_track
-#define __itt_marker_scope_task     __itt_scope_task
+#define __itt_marker_scope_unknown __itt_scope_unknown
+#define __itt_marker_scope_global __itt_scope_global
+#define __itt_marker_scope_process __itt_scope_track_group
+#define __itt_marker_scope_thread __itt_scope_track
+#define __itt_marker_scope_task __itt_scope_task
 /** @endcond */
 
 /**
  * @ingroup markers
  * @brief Create a marker instance
  * @param[in] domain The domain for this marker
  * @param[in] id The instance ID for this marker or __itt_null
  * @param[in] name The name for this marker
  * @param[in] scope The scope for this marker
  */
-void ITTAPI __itt_marker(const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope);
+void ITTAPI __itt_marker(const __itt_domain *domain, __itt_id id,
+                         __itt_string_handle *name, __itt_scope scope);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, marker, (const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope))
-#define __itt_marker(d,x,y,z) ITTNOTIFY_VOID_D3(marker,d,x,y,z)
-#define __itt_marker_ptr      ITTNOTIFY_NAME(marker)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_marker(domain,id,name,scope)
+ITT_STUBV(ITTAPI, void, marker,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *name,
+           __itt_scope scope))
+#define __itt_marker(d, x, y, z) ITTNOTIFY_VOID_D3(marker, d, x, y, z)
+#define __itt_marker_ptr ITTNOTIFY_NAME(marker)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_marker(domain, id, name, scope)
 #define __itt_marker_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_marker_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} markers group */
 
 /**
  * @defgroup metadata Metadata
  * The metadata API is used to attach extra information to named
  * entities. Metadata can be attached to an identified named entity by ID,
  * or to the current entity (which is always a task).
  *
  * Conceptually metadata has a type (what kind of metadata), a key (the
  * name of the metadata), and a value (the actual data). The encoding of
  * the value depends on the type of the metadata.
  *
  * The type of metadata is specified by an enumerated type __itt_metadata_type.
  * @{
  */
 
 /**
  * @ingroup parameters
  * @brief describes the type of metadata
  */
 typedef enum {
-    __itt_metadata_unknown = 0,
-    __itt_metadata_u64,     /**< Unsigned 64-bit integer */
-    __itt_metadata_s64,     /**< Signed 64-bit integer */
-    __itt_metadata_u32,     /**< Unsigned 32-bit integer */
-    __itt_metadata_s32,     /**< Signed 32-bit integer */
-    __itt_metadata_u16,     /**< Unsigned 16-bit integer */
-    __itt_metadata_s16,     /**< Signed 16-bit integer */
-    __itt_metadata_float,   /**< Signed 32-bit floating-point */
-    __itt_metadata_double   /**< SIgned 64-bit floating-point */
+  __itt_metadata_u64, /**< Unsigned 64-bit integer */
+  __itt_metadata_s64, /**< Signed 64-bit integer */
+  __itt_metadata_u32, /**< Unsigned 32-bit integer */
+  __itt_metadata_s32, /**< Signed 32-bit integer */
+  __itt_metadata_u16, /**< Unsigned 16-bit integer */
+  __itt_metadata_s16, /**< Signed 16-bit integer */
+  __itt_metadata_float, /**< Signed 32-bit floating-point */
+  __itt_metadata_double /**< SIgned 64-bit floating-point */
 } __itt_metadata_type;
 
 /**
  * @ingroup parameters
  * @brief Add metadata to an instance of a named entity.
  * @param[in] domain The domain controlling the call
- * @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task
+ * @param[in] id The identifier of the instance to which the metadata is to be
+ * added, or __itt_null to add to the current task
  * @param[in] key The name of the metadata
  * @param[in] type The type of the metadata
- * @param[in] count The number of elements of the given type. If count == 0, no metadata will be added.
+ * @param[in] count The number of elements of the given type. If count == 0, no
+ * metadata will be added.
  * @param[in] data The metadata itself
  */
-void ITTAPI __itt_metadata_add(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data);
+void ITTAPI __itt_metadata_add(const __itt_domain *domain, __itt_id id,
+                               __itt_string_handle *key,
+                               __itt_metadata_type type, size_t count,
+                               void *data);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, metadata_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data))
-#define __itt_metadata_add(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(metadata_add,d,x,y,z,a,b)
-#define __itt_metadata_add_ptr          ITTNOTIFY_NAME(metadata_add)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_metadata_add(d,x,y,z,a,b)
+ITT_STUBV(ITTAPI, void, metadata_add,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
+           __itt_metadata_type type, size_t count, void *data))
+#define __itt_metadata_add(d, x, y, z, a, b)                                   \
+  ITTNOTIFY_VOID_D5(metadata_add, d, x, y, z, a, b)
+#define __itt_metadata_add_ptr ITTNOTIFY_NAME(metadata_add)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_metadata_add(d, x, y, z, a, b)
 #define __itt_metadata_add_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_metadata_add_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup parameters
  * @brief Add string metadata to an instance of a named entity.
  * @param[in] domain The domain controlling the call
- * @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task
+ * @param[in] id The identifier of the instance to which the metadata is to be
+ * added, or __itt_null to add to the current task
  * @param[in] key The name of the metadata
  * @param[in] data The metadata itself
- * @param[in] length The number of characters in the string, or -1 if the length is unknown but the string is null-terminated
+ * @param[in] length The number of characters in the string, or -1 if the length
+ * is unknown but the string is null-terminated
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-void ITTAPI __itt_metadata_str_addA(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length);
-void ITTAPI __itt_metadata_str_addW(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t *data, size_t length);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+void ITTAPI __itt_metadata_str_addA(const __itt_domain *domain, __itt_id id,
+                                    __itt_string_handle *key, const char *data,
+                                    size_t length);
+void ITTAPI __itt_metadata_str_addW(const __itt_domain *domain, __itt_id id,
+                                    __itt_string_handle *key,
+                                    const wchar_t *data, size_t length);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_metadata_str_add     __itt_metadata_str_addW
-#  define __itt_metadata_str_add_ptr __itt_metadata_str_addW_ptr
+#define __itt_metadata_str_add __itt_metadata_str_addW
+#define __itt_metadata_str_add_ptr __itt_metadata_str_addW_ptr
 #else /* UNICODE */
-#  define __itt_metadata_str_add     __itt_metadata_str_addA
-#  define __itt_metadata_str_add_ptr __itt_metadata_str_addA_ptr
+#define __itt_metadata_str_add __itt_metadata_str_addA
+#define __itt_metadata_str_add_ptr __itt_metadata_str_addA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-void ITTAPI __itt_metadata_str_add(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length);
+void ITTAPI __itt_metadata_str_add(const __itt_domain *domain, __itt_id id,
+                                   __itt_string_handle *key, const char *data,
+                                   size_t length);
 #endif
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, metadata_str_addA, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length))
-ITT_STUBV(ITTAPI, void, metadata_str_addW, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t *data, size_t length))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, metadata_str_add, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, metadata_str_addA,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
+           const char *data, size_t length))
+ITT_STUBV(ITTAPI, void, metadata_str_addW,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
+           const wchar_t *data, size_t length))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, metadata_str_add,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
+           const char *data, size_t length))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_metadata_str_addA(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_addA,d,x,y,z,a)
-#define __itt_metadata_str_addA_ptr        ITTNOTIFY_NAME(metadata_str_addA)
-#define __itt_metadata_str_addW(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_addW,d,x,y,z,a)
-#define __itt_metadata_str_addW_ptr        ITTNOTIFY_NAME(metadata_str_addW)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_metadata_str_addA(d, x, y, z, a)                                 \
+  ITTNOTIFY_VOID_D4(metadata_str_addA, d, x, y, z, a)
+#define __itt_metadata_str_addA_ptr ITTNOTIFY_NAME(metadata_str_addA)
+#define __itt_metadata_str_addW(d, x, y, z, a)                                 \
+  ITTNOTIFY_VOID_D4(metadata_str_addW, d, x, y, z, a)
+#define __itt_metadata_str_addW_ptr ITTNOTIFY_NAME(metadata_str_addW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_metadata_str_add(d,x,y,z,a)  ITTNOTIFY_VOID_D4(metadata_str_add,d,x,y,z,a)
-#define __itt_metadata_str_add_ptr         ITTNOTIFY_NAME(metadata_str_add)
+#define __itt_metadata_str_add(d, x, y, z, a)                                  \
+  ITTNOTIFY_VOID_D4(metadata_str_add, d, x, y, z, a)
+#define __itt_metadata_str_add_ptr ITTNOTIFY_NAME(metadata_str_add)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_metadata_str_addA(d,x,y,z,a)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_metadata_str_addA(d, x, y, z, a)
 #define __itt_metadata_str_addA_ptr 0
-#define __itt_metadata_str_addW(d,x,y,z,a)
+#define __itt_metadata_str_addW(d, x, y, z, a)
 #define __itt_metadata_str_addW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_metadata_str_add(d,x,y,z,a)
+#define __itt_metadata_str_add(d, x, y, z, a)
 #define __itt_metadata_str_add_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_metadata_str_addA_ptr 0
 #define __itt_metadata_str_addW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_metadata_str_add_ptr  0
+#define __itt_metadata_str_add_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup parameters
  * @brief Add metadata to an instance of a named entity.
  * @param[in] domain The domain controlling the call
- * @param[in] scope The scope of the instance to which the metadata is to be added
+ * @param[in] scope The scope of the instance to which the metadata is to be
+ added
 
- * @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task
+ * @param[in] id The identifier of the instance to which the metadata is to be
+ added, or __itt_null to add to the current task
 
  * @param[in] key The name of the metadata
  * @param[in] type The type of the metadata
- * @param[in] count The number of elements of the given type. If count == 0, no metadata will be added.
+ * @param[in] count The number of elements of the given type. If count == 0, no
+ metadata will be added.
  * @param[in] data The metadata itself
 */
-void ITTAPI __itt_metadata_add_with_scope(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data);
+void ITTAPI __itt_metadata_add_with_scope(const __itt_domain *domain,
+                                          __itt_scope scope,
+                                          __itt_string_handle *key,
+                                          __itt_metadata_type type,
+                                          size_t count, void *data);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, metadata_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data))
-#define __itt_metadata_add_with_scope(d,x,y,z,a,b) ITTNOTIFY_VOID_D5(metadata_add_with_scope,d,x,y,z,a,b)
-#define __itt_metadata_add_with_scope_ptr          ITTNOTIFY_NAME(metadata_add_with_scope)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_metadata_add_with_scope(d,x,y,z,a,b)
+ITT_STUBV(ITTAPI, void, metadata_add_with_scope,
+          (const __itt_domain *domain, __itt_scope scope,
+           __itt_string_handle *key, __itt_metadata_type type, size_t count,
+           void *data))
+#define __itt_metadata_add_with_scope(d, x, y, z, a, b)                        \
+  ITTNOTIFY_VOID_D5(metadata_add_with_scope, d, x, y, z, a, b)
+#define __itt_metadata_add_with_scope_ptr                                      \
+  ITTNOTIFY_NAME(metadata_add_with_scope)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_metadata_add_with_scope(d, x, y, z, a, b)
 #define __itt_metadata_add_with_scope_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_metadata_add_with_scope_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup parameters
  * @brief Add string metadata to an instance of a named entity.
  * @param[in] domain The domain controlling the call
- * @param[in] scope The scope of the instance to which the metadata is to be added
+ * @param[in] scope The scope of the instance to which the metadata is to be
+ added
 
- * @param[in] id The identifier of the instance to which the metadata is to be added, or __itt_null to add to the current task
+ * @param[in] id The identifier of the instance to which the metadata is to be
+ added, or __itt_null to add to the current task
 
  * @param[in] key The name of the metadata
  * @param[in] data The metadata itself
- * @param[in] length The number of characters in the string, or -1 if the length is unknown but the string is null-terminated
+ * @param[in] length The number of characters in the string, or -1 if the length
+ is unknown but the string is null-terminated
 */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-void ITTAPI __itt_metadata_str_add_with_scopeA(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length);
-void ITTAPI __itt_metadata_str_add_with_scopeW(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+void ITTAPI __itt_metadata_str_add_with_scopeA(const __itt_domain *domain,
+                                               __itt_scope scope,
+                                               __itt_string_handle *key,
+                                               const char *data, size_t length);
+void ITTAPI __itt_metadata_str_add_with_scopeW(const __itt_domain *domain,
+                                               __itt_scope scope,
+                                               __itt_string_handle *key,
+                                               const wchar_t *data,
+                                               size_t length);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_metadata_str_add_with_scope     __itt_metadata_str_add_with_scopeW
-#  define __itt_metadata_str_add_with_scope_ptr __itt_metadata_str_add_with_scopeW_ptr
+#define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeW
+#define __itt_metadata_str_add_with_scope_ptr                                  \
+  __itt_metadata_str_add_with_scopeW_ptr
 #else /* UNICODE */
-#  define __itt_metadata_str_add_with_scope     __itt_metadata_str_add_with_scopeA
-#  define __itt_metadata_str_add_with_scope_ptr __itt_metadata_str_add_with_scopeA_ptr
+#define __itt_metadata_str_add_with_scope __itt_metadata_str_add_with_scopeA
+#define __itt_metadata_str_add_with_scope_ptr                                  \
+  __itt_metadata_str_add_with_scopeA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-void ITTAPI __itt_metadata_str_add_with_scope(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length);
+void ITTAPI __itt_metadata_str_add_with_scope(const __itt_domain *domain,
+                                              __itt_scope scope,
+                                              __itt_string_handle *key,
+                                              const char *data, size_t length);
 #endif
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length))
-ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length))
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_metadata_str_add_with_scopeA(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeA,d,x,y,z,a)
-#define __itt_metadata_str_add_with_scopeA_ptr        ITTNOTIFY_NAME(metadata_str_add_with_scopeA)
-#define __itt_metadata_str_add_with_scopeW(d,x,y,z,a) ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeW,d,x,y,z,a)
-#define __itt_metadata_str_add_with_scopeW_ptr        ITTNOTIFY_NAME(metadata_str_add_with_scopeW)
-#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_metadata_str_add_with_scope(d,x,y,z,a)  ITTNOTIFY_VOID_D4(metadata_str_add_with_scope,d,x,y,z,a)
-#define __itt_metadata_str_add_with_scope_ptr         ITTNOTIFY_NAME(metadata_str_add_with_scope)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA,
+          (const __itt_domain *domain, __itt_scope scope,
+           __itt_string_handle *key, const char *data, size_t length))
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW,
+          (const __itt_domain *domain, __itt_scope scope,
+           __itt_string_handle *key, const wchar_t *data, size_t length))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope,
+          (const __itt_domain *domain, __itt_scope scope,
+           __itt_string_handle *key, const char *data, size_t length))
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_metadata_str_add_with_scopeA(d, x, y, z, a)                      \
+  ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeA, d, x, y, z, a)
+#define __itt_metadata_str_add_with_scopeA_ptr                                 \
+  ITTNOTIFY_NAME(metadata_str_add_with_scopeA)
+#define __itt_metadata_str_add_with_scopeW(d, x, y, z, a)                      \
+  ITTNOTIFY_VOID_D4(metadata_str_add_with_scopeW, d, x, y, z, a)
+#define __itt_metadata_str_add_with_scopeW_ptr                                 \
+  ITTNOTIFY_NAME(metadata_str_add_with_scopeW)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#define __itt_metadata_str_add_with_scope(d, x, y, z, a)                       \
+  ITTNOTIFY_VOID_D4(metadata_str_add_with_scope, d, x, y, z, a)
+#define __itt_metadata_str_add_with_scope_ptr                                  \
+  ITTNOTIFY_NAME(metadata_str_add_with_scope)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_metadata_str_add_with_scopeA(d,x,y,z,a)
-#define __itt_metadata_str_add_with_scopeA_ptr  0
-#define __itt_metadata_str_add_with_scopeW(d,x,y,z,a)
-#define __itt_metadata_str_add_with_scopeW_ptr  0
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_metadata_str_add_with_scopeA(d, x, y, z, a)
+#define __itt_metadata_str_add_with_scopeA_ptr 0
+#define __itt_metadata_str_add_with_scopeW(d, x, y, z, a)
+#define __itt_metadata_str_add_with_scopeW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_metadata_str_add_with_scope(d,x,y,z,a)
-#define __itt_metadata_str_add_with_scope_ptr   0
+#define __itt_metadata_str_add_with_scope(d, x, y, z, a)
+#define __itt_metadata_str_add_with_scope_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_metadata_str_add_with_scopeA_ptr  0
-#define __itt_metadata_str_add_with_scopeW_ptr  0
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_metadata_str_add_with_scopeA_ptr 0
+#define __itt_metadata_str_add_with_scopeW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_metadata_str_add_with_scope_ptr   0
+#define __itt_metadata_str_add_with_scope_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @} metadata group */
 
 /**
  * @defgroup relations Relations
  * Instances of named entities can be explicitly associated with other
  * instances using instance IDs and the relationship API calls.
  *
  * @{
  */
 
 /**
  * @ingroup relations
- * @brief The kind of relation between two instances is specified by the enumerated type __itt_relation.
- * Relations between instances can be added with an API call. The relation
- * API uses instance IDs. Relations can be added before or after the actual
- * instances are created and persist independently of the instances. This
- * is the motivation for having different lifetimes for instance IDs and
- * the actual instances.
+ * @brief The kind of relation between two instances is specified by the
+ * enumerated type __itt_relation. Relations between instances can be added with
+ * an API call. The relation API uses instance IDs. Relations can be added
+ * before or after the actual instances are created and persist independently of
+ * the instances. This is the motivation for having different lifetimes for
+ * instance IDs and the actual instances.
  */
-typedef enum
-{
-    __itt_relation_is_unknown = 0,
-    __itt_relation_is_dependent_on,         /**< "A is dependent on B" means that A cannot start until B completes */
-    __itt_relation_is_sibling_of,           /**< "A is sibling of B" means that A and B were created as a group */
-    __itt_relation_is_parent_of,            /**< "A is parent of B" means that A created B */
-    __itt_relation_is_continuation_of,      /**< "A is continuation of B" means that A assumes the dependencies of B */
-    __itt_relation_is_child_of,             /**< "A is child of B" means that A was created by B (inverse of is_parent_of) */
-    __itt_relation_is_continued_by,         /**< "A is continued by B" means that B assumes the dependencies of A (inverse of is_continuation_of) */
-    __itt_relation_is_predecessor_to        /**< "A is predecessor to B" means that B cannot start until A completes (inverse of is_dependent_on) */
+typedef enum {
+  __itt_relation_is_dependent_on, /**< "A is dependent on B" means that A cannot
+                                     start until B completes */
+  __itt_relation_is_sibling_of, /**< "A is sibling of B" means that A and B were
+                                   created as a group */
+  __itt_relation_is_parent_of, /**< "A is parent of B" means that A created B */
+  __itt_relation_is_continuation_of, /**< "A is continuation of B" means that A
+                                        assumes the dependencies of B */
+  __itt_relation_is_child_of, /**< "A is child of B" means that A was created by
+                                 B (inverse of is_parent_of) */
+  __itt_relation_is_continued_by, /**< "A is continued by B" means that B
+                                     assumes the dependencies of A (inverse of
+                                     is_continuation_of) */
+  __itt_relation_is_predecessor_to /**< "A is predecessor to B" means that B
+                                      cannot start until A completes (inverse of
+                                      is_dependent_on) */
 } __itt_relation;
 
 /**
  * @ingroup relations
  * @brief Add a relation to the current task instance.
  * The current task instance is the head of the relation.
  * @param[in] domain The domain controlling this call
  * @param[in] relation The kind of relation
  * @param[in] tail The ID for the tail of the relation
  */
-void ITTAPI __itt_relation_add_to_current(const __itt_domain *domain, __itt_relation relation, __itt_id tail);
+void ITTAPI __itt_relation_add_to_current(const __itt_domain *domain,
+                                          __itt_relation relation,
+                                          __itt_id tail);
 
 /**
  * @ingroup relations
  * @brief Add a relation between two instance identifiers.
  * @param[in] domain The domain controlling this call
  * @param[in] head The ID for the head of the relation
  * @param[in] relation The kind of relation
  * @param[in] tail The ID for the tail of the relation
  */
-void ITTAPI __itt_relation_add(const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail);
+void ITTAPI __itt_relation_add(const __itt_domain *domain, __itt_id head,
+                               __itt_relation relation, __itt_id tail);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, relation_add_to_current, (const __itt_domain *domain, __itt_relation relation, __itt_id tail))
-ITT_STUBV(ITTAPI, void, relation_add,            (const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail))
-#define __itt_relation_add_to_current(d,x,y) ITTNOTIFY_VOID_D2(relation_add_to_current,d,x,y)
-#define __itt_relation_add_to_current_ptr    ITTNOTIFY_NAME(relation_add_to_current)
-#define __itt_relation_add(d,x,y,z)          ITTNOTIFY_VOID_D3(relation_add,d,x,y,z)
-#define __itt_relation_add_ptr               ITTNOTIFY_NAME(relation_add)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_relation_add_to_current(d,x,y)
+ITT_STUBV(ITTAPI, void, relation_add_to_current,
+          (const __itt_domain *domain, __itt_relation relation, __itt_id tail))
+ITT_STUBV(ITTAPI, void, relation_add,
+          (const __itt_domain *domain, __itt_id head, __itt_relation relation,
+           __itt_id tail))
+#define __itt_relation_add_to_current(d, x, y)                                 \
+  ITTNOTIFY_VOID_D2(relation_add_to_current, d, x, y)
+#define __itt_relation_add_to_current_ptr                                      \
+  ITTNOTIFY_NAME(relation_add_to_current)
+#define __itt_relation_add(d, x, y, z)                                         \
+  ITTNOTIFY_VOID_D3(relation_add, d, x, y, z)
+#define __itt_relation_add_ptr ITTNOTIFY_NAME(relation_add)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_relation_add_to_current(d, x, y)
 #define __itt_relation_add_to_current_ptr 0
-#define __itt_relation_add(d,x,y,z)
+#define __itt_relation_add(d, x, y, z)
 #define __itt_relation_add_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_relation_add_to_current_ptr 0
 #define __itt_relation_add_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} relations group */
 
 /** @cond exclude_from_documentation */
 #pragma pack(push, 8)
 
-typedef struct ___itt_clock_info
-{
-    unsigned long long clock_freq; /*!< Clock domain frequency */
-    unsigned long long clock_base; /*!< Clock domain base timestamp */
+typedef struct ___itt_clock_info {
 } __itt_clock_info;
 
 #pragma pack(pop)
 /** @endcond */
 
 /** @cond exclude_from_documentation */
-typedef void (ITTAPI *__itt_get_clock_info_fn)(__itt_clock_info* clock_info, void* data);
+typedef void(ITTAPI *__itt_get_clock_info_fn)(__itt_clock_info *clock_info,
+                                              void *data);
 /** @endcond */
 
 /** @cond exclude_from_documentation */
 #pragma pack(push, 8)
 
-typedef struct ___itt_clock_domain
-{
-    __itt_clock_info info;      /*!< Most recent clock domain info */
-    __itt_get_clock_info_fn fn; /*!< Callback function pointer */
-    void* fn_data;              /*!< Input argument for the callback function */
-    int   extra1;               /*!< Reserved. Must be zero */
-    void* extra2;               /*!< Reserved. Must be zero */
-    struct ___itt_clock_domain* next;
+typedef struct ___itt_clock_domain {
+  __itt_clock_info info; /*!< Most recent clock domain info */
+  void *fn_data; /*!< Input argument for the callback function */
+  int extra1; /*!< Reserved. Must be zero */
+  void *extra2; /*!< Reserved. Must be zero */
+  struct ___itt_clock_domain *next;
 } __itt_clock_domain;
 
 #pragma pack(pop)
 /** @endcond */
 
 /**
  * @ingroup clockdomains
  * @brief Create a clock domain.
  * Certain applications require the capability to trace their application using
- * a clock domain different than the CPU, for instance the instrumentation of events
- * that occur on a GPU.
- * Because the set of domains is expected to be static over the application's execution time,
- * there is no mechanism to destroy a domain.
- * Any domain can be accessed by any thread in the process, regardless of which thread created
- * the domain. This call is thread-safe.
- * @param[in] fn A pointer to a callback function which retrieves alternative CPU timestamps
+ * a clock domain different than the CPU, for instance the instrumentation of
+ * events that occur on a GPU. Because the set of domains is expected to be
+ * static over the application's execution time, there is no mechanism to
+ * destroy a domain. Any domain can be accessed by any thread in the process,
+ * regardless of which thread created the domain. This call is thread-safe.
+ * @param[in] fn A pointer to a callback function which retrieves alternative
+ * CPU timestamps
  * @param[in] fn_data Argument for a callback function; may be NULL
  */
-__itt_clock_domain* ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn, void* fn_data);
+__itt_clock_domain *ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn,
+                                                     void *fn_data);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUB(ITTAPI, __itt_clock_domain*, clock_domain_create, (__itt_get_clock_info_fn fn, void* fn_data))
-#define __itt_clock_domain_create     ITTNOTIFY_DATA(clock_domain_create)
+ITT_STUB(ITTAPI, __itt_clock_domain *, clock_domain_create,
+         (__itt_get_clock_info_fn fn, void *fn_data))
+#define __itt_clock_domain_create ITTNOTIFY_DATA(clock_domain_create)
 #define __itt_clock_domain_create_ptr ITTNOTIFY_NAME(clock_domain_create)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_clock_domain_create(fn,fn_data) (__itt_clock_domain*)0
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_clock_domain_create(fn, fn_data) (__itt_clock_domain *)0
 #define __itt_clock_domain_create_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_clock_domain_create_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup clockdomains
  * @brief Recalculate clock domains frequencies and clock base timestamps.
  */
 void ITTAPI __itt_clock_domain_reset(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, clock_domain_reset, (void))
-#define __itt_clock_domain_reset     ITTNOTIFY_VOID(clock_domain_reset)
+#define __itt_clock_domain_reset ITTNOTIFY_VOID(clock_domain_reset)
 #define __itt_clock_domain_reset_ptr ITTNOTIFY_NAME(clock_domain_reset)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_clock_domain_reset()
 #define __itt_clock_domain_reset_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_clock_domain_reset_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup clockdomain
- * @brief Create an instance of identifier. This establishes the beginning of the lifetime of
- * an instance of the given ID in the trace. Once this lifetime starts, the ID can be used to
- * tag named entity instances in calls such as __itt_task_begin, and to specify relationships among
- * identified named entity instances, using the \ref relations APIs.
+ * @brief Create an instance of identifier. This establishes the beginning of
+ * the lifetime of an instance of the given ID in the trace. Once this lifetime
+ * starts, the ID can be used to tag named entity instances in calls such as
+ * __itt_task_begin, and to specify relationships among identified named entity
+ * instances, using the \ref relations APIs.
  * @param[in] domain The domain controlling the execution of this call.
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
  * @param[in] id The ID to create.
  */
-void ITTAPI __itt_id_create_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id);
+void ITTAPI __itt_id_create_ex(const __itt_domain *domain,
+                               __itt_clock_domain *clock_domain,
+                               unsigned long long timestamp, __itt_id id);
 
 /**
  * @ingroup clockdomain
- * @brief Destroy an instance of identifier. This ends the lifetime of the current instance of the
- * given ID value in the trace. Any relationships that are established after this lifetime ends are
- * invalid. This call must be performed before the given ID value can be reused for a different
- * named entity instance.
+ * @brief Destroy an instance of identifier. This ends the lifetime of the
+ * current instance of the given ID value in the trace. Any relationships that
+ * are established after this lifetime ends are invalid. This call must be
+ * performed before the given ID value can be reused for a different named
+ * entity instance.
  * @param[in] domain The domain controlling the execution of this call.
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
  * @param[in] id The ID to destroy.
  */
-void ITTAPI __itt_id_destroy_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id);
+void ITTAPI __itt_id_destroy_ex(const __itt_domain *domain,
+                                __itt_clock_domain *clock_domain,
+                                unsigned long long timestamp, __itt_id id);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, id_create_ex,  (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id))
-ITT_STUBV(ITTAPI, void, id_destroy_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id))
-#define __itt_id_create_ex(d,x,y,z)  ITTNOTIFY_VOID_D3(id_create_ex,d,x,y,z)
-#define __itt_id_create_ex_ptr       ITTNOTIFY_NAME(id_create_ex)
-#define __itt_id_destroy_ex(d,x,y,z) ITTNOTIFY_VOID_D3(id_destroy_ex,d,x,y,z)
-#define __itt_id_destroy_ex_ptr      ITTNOTIFY_NAME(id_destroy_ex)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_id_create_ex(domain,clock_domain,timestamp,id)
-#define __itt_id_create_ex_ptr    0
-#define __itt_id_destroy_ex(domain,clock_domain,timestamp,id)
+ITT_STUBV(ITTAPI, void, id_create_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id))
+ITT_STUBV(ITTAPI, void, id_destroy_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id))
+#define __itt_id_create_ex(d, x, y, z)                                         \
+  ITTNOTIFY_VOID_D3(id_create_ex, d, x, y, z)
+#define __itt_id_create_ex_ptr ITTNOTIFY_NAME(id_create_ex)
+#define __itt_id_destroy_ex(d, x, y, z)                                        \
+  ITTNOTIFY_VOID_D3(id_destroy_ex, d, x, y, z)
+#define __itt_id_destroy_ex_ptr ITTNOTIFY_NAME(id_destroy_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_id_create_ex(domain, clock_domain, timestamp, id)
+#define __itt_id_create_ex_ptr 0
+#define __itt_id_destroy_ex(domain, clock_domain, timestamp, id)
 #define __itt_id_destroy_ex_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_id_create_ex_ptr    0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_id_create_ex_ptr 0
 #define __itt_id_destroy_ex_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup clockdomain
  * @brief Begin a task instance.
  * @param[in] domain The domain for this task
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
  * @param[in] taskid The instance ID for this task instance, or __itt_null
- * @param[in] parentid The parent instance to which this task instance belongs, or __itt_null
+ * @param[in] parentid The parent instance to which this task instance belongs,
+ * or __itt_null
  * @param[in] name The name of this task
  */
-void ITTAPI __itt_task_begin_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name);
+void ITTAPI __itt_task_begin_ex(const __itt_domain *domain,
+                                __itt_clock_domain *clock_domain,
+                                unsigned long long timestamp, __itt_id taskid,
+                                __itt_id parentid, __itt_string_handle *name);
 
 /**
  * @ingroup clockdomain
  * @brief Begin a task instance.
  * @param[in] domain The domain for this task
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
  * @param[in] taskid The identifier for this task instance, or __itt_null
  * @param[in] parentid The parent of this task, or __itt_null
  * @param[in] fn The pointer to the function you are tracing
  */
-void ITTAPI __itt_task_begin_fn_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, void* fn);
+void ITTAPI __itt_task_begin_fn_ex(const __itt_domain *domain,
+                                   __itt_clock_domain *clock_domain,
+                                   unsigned long long timestamp,
+                                   __itt_id taskid, __itt_id parentid,
+                                   void *fn);
 
 /**
  * @ingroup clockdomain
  * @brief End the current task instance.
  * @param[in] domain The domain for this task
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
  */
-void ITTAPI __itt_task_end_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp);
+void ITTAPI __itt_task_end_ex(const __itt_domain *domain,
+                              __itt_clock_domain *clock_domain,
+                              unsigned long long timestamp);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, task_begin_ex,        (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name))
-ITT_STUBV(ITTAPI, void, task_begin_fn_ex,     (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, void* fn))
-ITT_STUBV(ITTAPI, void, task_end_ex,          (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp))
-#define __itt_task_begin_ex(d,x,y,z,a,b)      ITTNOTIFY_VOID_D5(task_begin_ex,d,x,y,z,a,b)
-#define __itt_task_begin_ex_ptr               ITTNOTIFY_NAME(task_begin_ex)
-#define __itt_task_begin_fn_ex(d,x,y,z,a,b)   ITTNOTIFY_VOID_D5(task_begin_fn_ex,d,x,y,z,a,b)
-#define __itt_task_begin_fn_ex_ptr            ITTNOTIFY_NAME(task_begin_fn_ex)
-#define __itt_task_end_ex(d,x,y)              ITTNOTIFY_VOID_D2(task_end_ex,d,x,y)
-#define __itt_task_end_ex_ptr                 ITTNOTIFY_NAME(task_end_ex)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_task_begin_ex(domain,clock_domain,timestamp,id,parentid,name)
-#define __itt_task_begin_ex_ptr          0
-#define __itt_task_begin_fn_ex(domain,clock_domain,timestamp,id,parentid,fn)
-#define __itt_task_begin_fn_ex_ptr       0
-#define __itt_task_end_ex(domain,clock_domain,timestamp)
-#define __itt_task_end_ex_ptr            0
+ITT_STUBV(ITTAPI, void, task_begin_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id, __itt_id parentid,
+           __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, task_begin_fn_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id, __itt_id parentid,
+           void *fn))
+ITT_STUBV(ITTAPI, void, task_end_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp))
+#define __itt_task_begin_ex(d, x, y, z, a, b)                                  \
+  ITTNOTIFY_VOID_D5(task_begin_ex, d, x, y, z, a, b)
+#define __itt_task_begin_ex_ptr ITTNOTIFY_NAME(task_begin_ex)
+#define __itt_task_begin_fn_ex(d, x, y, z, a, b)                               \
+  ITTNOTIFY_VOID_D5(task_begin_fn_ex, d, x, y, z, a, b)
+#define __itt_task_begin_fn_ex_ptr ITTNOTIFY_NAME(task_begin_fn_ex)
+#define __itt_task_end_ex(d, x, y) ITTNOTIFY_VOID_D2(task_end_ex, d, x, y)
+#define __itt_task_end_ex_ptr ITTNOTIFY_NAME(task_end_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_task_begin_ex(domain, clock_domain, timestamp, id, parentid, name)
+#define __itt_task_begin_ex_ptr 0
+#define __itt_task_begin_fn_ex(domain, clock_domain, timestamp, id, parentid,  \
+                               fn)
+#define __itt_task_begin_fn_ex_ptr 0
+#define __itt_task_end_ex(domain, clock_domain, timestamp)
+#define __itt_task_end_ex_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_task_begin_ex_ptr          0
-#define __itt_task_begin_fn_ex_ptr       0
-#define __itt_task_end_ex_ptr            0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_task_begin_ex_ptr 0
+#define __itt_task_begin_fn_ex_ptr 0
+#define __itt_task_end_ex_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @defgroup counters Counters
  * @ingroup public
  * Counters are user-defined objects with a monotonically increasing
  * value. Counter values are 64-bit unsigned integers.
  * Counters have names that can be displayed in
  * the tools.
  * @{
  */
 
 /**
  * @brief opaque structure for counter identification
  */
 /** @cond exclude_from_documentation */
 
-typedef struct ___itt_counter* __itt_counter;
+typedef struct ___itt_counter *__itt_counter;
 
 /**
  * @brief Create an unsigned 64 bits integer counter with given name/domain
  *
- * After __itt_counter_create() is called, __itt_counter_inc(id), __itt_counter_inc_delta(id, delta),
- * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
- * can be used to change the value of the counter, where value_ptr is a pointer to an unsigned 64 bits integer
+ * After __itt_counter_create() is called, __itt_counter_inc(id),
+ * __itt_counter_inc_delta(id, delta),
+ * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id,
+ * clock_domain, timestamp, value_ptr) can be used to change the value of the
+ * counter, where value_ptr is a pointer to an unsigned 64 bits integer
  *
- * The call is equal to __itt_counter_create_typed(name, domain, __itt_metadata_u64)
+ * The call is equal to __itt_counter_create_typed(name, domain,
+ * __itt_metadata_u64)
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_counter ITTAPI __itt_counter_createA(const char    *name, const char    *domain);
-__itt_counter ITTAPI __itt_counter_createW(const wchar_t *name, const wchar_t *domain);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_counter ITTAPI __itt_counter_createA(const char *name,
+                                           const char *domain);
+__itt_counter ITTAPI __itt_counter_createW(const wchar_t *name,
+                                           const wchar_t *domain);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_counter_create     __itt_counter_createW
-#  define __itt_counter_create_ptr __itt_counter_createW_ptr
+#define __itt_counter_create __itt_counter_createW
+#define __itt_counter_create_ptr __itt_counter_createW_ptr
 #else /* UNICODE */
-#  define __itt_counter_create     __itt_counter_createA
-#  define __itt_counter_create_ptr __itt_counter_createA_ptr
+#define __itt_counter_create __itt_counter_createA
+#define __itt_counter_create_ptr __itt_counter_createA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 __itt_counter ITTAPI __itt_counter_create(const char *name, const char *domain);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char    *name, const char    *domain))
-ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_counter, counter_create,  (const char *name, const char *domain))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_createA,
+         (const char *name, const char *domain))
+ITT_STUB(ITTAPI, __itt_counter, counter_createW,
+         (const wchar_t *name, const wchar_t *domain))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create,
+         (const char *name, const char *domain))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_counter_createA     ITTNOTIFY_DATA(counter_createA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_counter_createA ITTNOTIFY_DATA(counter_createA)
 #define __itt_counter_createA_ptr ITTNOTIFY_NAME(counter_createA)
-#define __itt_counter_createW     ITTNOTIFY_DATA(counter_createW)
+#define __itt_counter_createW ITTNOTIFY_DATA(counter_createW)
 #define __itt_counter_createW_ptr ITTNOTIFY_NAME(counter_createW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_counter_create     ITTNOTIFY_DATA(counter_create)
+#define __itt_counter_create ITTNOTIFY_DATA(counter_create)
 #define __itt_counter_create_ptr ITTNOTIFY_NAME(counter_create)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_counter_createA(name, domain)
 #define __itt_counter_createA_ptr 0
 #define __itt_counter_createW(name, domain)
 #define __itt_counter_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_counter_create(name, domain)
-#define __itt_counter_create_ptr  0
+#define __itt_counter_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_counter_createA_ptr 0
 #define __itt_counter_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_counter_create_ptr  0
+#define __itt_counter_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Increment the unsigned 64 bits integer counter value
  *
  * Calling this function to non-unsigned 64 bits integer counters has no effect
  */
 void ITTAPI __itt_counter_inc(__itt_counter id);
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id))
-#define __itt_counter_inc     ITTNOTIFY_VOID(counter_inc)
+#define __itt_counter_inc ITTNOTIFY_VOID(counter_inc)
 #define __itt_counter_inc_ptr ITTNOTIFY_NAME(counter_inc)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_counter_inc(id)
 #define __itt_counter_inc_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_counter_inc_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /**
  * @brief Increment the unsigned 64 bits integer counter value with x
  *
  * Calling this function to non-unsigned 64 bits integer counters has no effect
  */
 void ITTAPI __itt_counter_inc_delta(__itt_counter id, unsigned long long value);
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, counter_inc_delta, (__itt_counter id, unsigned long long value))
-#define __itt_counter_inc_delta     ITTNOTIFY_VOID(counter_inc_delta)
+ITT_STUBV(ITTAPI, void, counter_inc_delta,
+          (__itt_counter id, unsigned long long value))
+#define __itt_counter_inc_delta ITTNOTIFY_VOID(counter_inc_delta)
 #define __itt_counter_inc_delta_ptr ITTNOTIFY_NAME(counter_inc_delta)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_counter_inc_delta(id, value)
 #define __itt_counter_inc_delta_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_counter_inc_delta_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Decrement the unsigned 64 bits integer counter value
  *
  * Calling this function to non-unsigned 64 bits integer counters has no effect
  */
 void ITTAPI __itt_counter_dec(__itt_counter id);
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id))
-#define __itt_counter_dec     ITTNOTIFY_VOID(counter_dec)
+#define __itt_counter_dec ITTNOTIFY_VOID(counter_dec)
 #define __itt_counter_dec_ptr ITTNOTIFY_NAME(counter_dec)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_counter_dec(id)
 #define __itt_counter_dec_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_counter_dec_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /**
  * @brief Decrement the unsigned 64 bits integer counter value with x
  *
  * Calling this function to non-unsigned 64 bits integer counters has no effect
  */
 void ITTAPI __itt_counter_dec_delta(__itt_counter id, unsigned long long value);
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, counter_dec_delta, (__itt_counter id, unsigned long long value))
-#define __itt_counter_dec_delta     ITTNOTIFY_VOID(counter_dec_delta)
+ITT_STUBV(ITTAPI, void, counter_dec_delta,
+          (__itt_counter id, unsigned long long value))
+#define __itt_counter_dec_delta ITTNOTIFY_VOID(counter_dec_delta)
 #define __itt_counter_dec_delta_ptr ITTNOTIFY_NAME(counter_dec_delta)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_counter_dec_delta(id, value)
 #define __itt_counter_dec_delta_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_counter_dec_delta_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup counters
  * @brief Increment a counter by one.
  * The first call with a given name creates a counter by that name and sets its
  * value to zero. Successive calls increment the counter value.
- * @param[in] domain The domain controlling the call. Counter names are not domain specific.
- *            The domain argument is used only to enable or disable the API calls.
+ * @param[in] domain The domain controlling the call. Counter names are not
+ * domain specific. The domain argument is used only to enable or disable the
+ * API calls.
  * @param[in] name The name of the counter
  */
-void ITTAPI __itt_counter_inc_v3(const __itt_domain *domain, __itt_string_handle *name);
+void ITTAPI __itt_counter_inc_v3(const __itt_domain *domain,
+                                 __itt_string_handle *name);
 
 /**
  * @ingroup counters
  * @brief Increment a counter by the value specified in delta.
- * @param[in] domain The domain controlling the call. Counter names are not domain specific.
- *            The domain argument is used only to enable or disable the API calls.
+ * @param[in] domain The domain controlling the call. Counter names are not
+ * domain specific. The domain argument is used only to enable or disable the
+ * API calls.
  * @param[in] name The name of the counter
  * @param[in] delta The amount by which to increment the counter
  */
-void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta);
+void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain *domain,
+                                       __itt_string_handle *name,
+                                       unsigned long long delta);
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, counter_inc_v3,       (const __itt_domain *domain, __itt_string_handle *name))
-ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta))
-#define __itt_counter_inc_v3(d,x)         ITTNOTIFY_VOID_D1(counter_inc_v3,d,x)
-#define __itt_counter_inc_v3_ptr          ITTNOTIFY_NAME(counter_inc_v3)
-#define __itt_counter_inc_delta_v3(d,x,y) ITTNOTIFY_VOID_D2(counter_inc_delta_v3,d,x,y)
-#define __itt_counter_inc_delta_v3_ptr    ITTNOTIFY_NAME(counter_inc_delta_v3)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_counter_inc_v3(domain,name)
-#define __itt_counter_inc_v3_ptr       0
-#define __itt_counter_inc_delta_v3(domain,name,delta)
+ITT_STUBV(ITTAPI, void, counter_inc_v3,
+          (const __itt_domain *domain, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, counter_inc_delta_v3,
+          (const __itt_domain *domain, __itt_string_handle *name,
+           unsigned long long delta))
+#define __itt_counter_inc_v3(d, x) ITTNOTIFY_VOID_D1(counter_inc_v3, d, x)
+#define __itt_counter_inc_v3_ptr ITTNOTIFY_NAME(counter_inc_v3)
+#define __itt_counter_inc_delta_v3(d, x, y)                                    \
+  ITTNOTIFY_VOID_D2(counter_inc_delta_v3, d, x, y)
+#define __itt_counter_inc_delta_v3_ptr ITTNOTIFY_NAME(counter_inc_delta_v3)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_inc_v3(domain, name)
+#define __itt_counter_inc_v3_ptr 0
+#define __itt_counter_inc_delta_v3(domain, name, delta)
 #define __itt_counter_inc_delta_v3_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_counter_inc_v3_ptr       0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_inc_v3_ptr 0
 #define __itt_counter_inc_delta_v3_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
-
 /**
  * @ingroup counters
  * @brief Decrement a counter by one.
  * The first call with a given name creates a counter by that name and sets its
  * value to zero. Successive calls decrement the counter value.
- * @param[in] domain The domain controlling the call. Counter names are not domain specific.
- *            The domain argument is used only to enable or disable the API calls.
+ * @param[in] domain The domain controlling the call. Counter names are not
+ * domain specific. The domain argument is used only to enable or disable the
+ * API calls.
  * @param[in] name The name of the counter
  */
-void ITTAPI __itt_counter_dec_v3(const __itt_domain *domain, __itt_string_handle *name);
+void ITTAPI __itt_counter_dec_v3(const __itt_domain *domain,
+                                 __itt_string_handle *name);
 
 /**
  * @ingroup counters
  * @brief Decrement a counter by the value specified in delta.
- * @param[in] domain The domain controlling the call. Counter names are not domain specific.
- *            The domain argument is used only to enable or disable the API calls.
+ * @param[in] domain The domain controlling the call. Counter names are not
+ * domain specific. The domain argument is used only to enable or disable the
+ * API calls.
  * @param[in] name The name of the counter
  * @param[in] delta The amount by which to decrement the counter
  */
-void ITTAPI __itt_counter_dec_delta_v3(const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta);
+void ITTAPI __itt_counter_dec_delta_v3(const __itt_domain *domain,
+                                       __itt_string_handle *name,
+                                       unsigned long long delta);
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, counter_dec_v3,       (const __itt_domain *domain, __itt_string_handle *name))
-ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long delta))
-#define __itt_counter_dec_v3(d,x)         ITTNOTIFY_VOID_D1(counter_dec_v3,d,x)
-#define __itt_counter_dec_v3_ptr          ITTNOTIFY_NAME(counter_dec_v3)
-#define __itt_counter_dec_delta_v3(d,x,y) ITTNOTIFY_VOID_D2(counter_dec_delta_v3,d,x,y)
-#define __itt_counter_dec_delta_v3_ptr    ITTNOTIFY_NAME(counter_dec_delta_v3)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_counter_dec_v3(domain,name)
-#define __itt_counter_dec_v3_ptr       0
-#define __itt_counter_dec_delta_v3(domain,name,delta)
+ITT_STUBV(ITTAPI, void, counter_dec_v3,
+          (const __itt_domain *domain, __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, counter_dec_delta_v3,
+          (const __itt_domain *domain, __itt_string_handle *name,
+           unsigned long long delta))
+#define __itt_counter_dec_v3(d, x) ITTNOTIFY_VOID_D1(counter_dec_v3, d, x)
+#define __itt_counter_dec_v3_ptr ITTNOTIFY_NAME(counter_dec_v3)
+#define __itt_counter_dec_delta_v3(d, x, y)                                    \
+  ITTNOTIFY_VOID_D2(counter_dec_delta_v3, d, x, y)
+#define __itt_counter_dec_delta_v3_ptr ITTNOTIFY_NAME(counter_dec_delta_v3)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_counter_dec_v3(domain, name)
+#define __itt_counter_dec_v3_ptr 0
+#define __itt_counter_dec_delta_v3(domain, name, delta)
 #define __itt_counter_dec_delta_v3_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_counter_dec_v3_ptr       0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_counter_dec_v3_ptr 0
 #define __itt_counter_dec_delta_v3_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @} counters group */
 
-
 /**
  * @brief Set the counter value
  */
 void ITTAPI __itt_counter_set_value(__itt_counter id, void *value_ptr);
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr))
-#define __itt_counter_set_value     ITTNOTIFY_VOID(counter_set_value)
+#define __itt_counter_set_value ITTNOTIFY_VOID(counter_set_value)
 #define __itt_counter_set_value_ptr ITTNOTIFY_NAME(counter_set_value)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_counter_set_value(id, value_ptr)
 #define __itt_counter_set_value_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_counter_set_value_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Set the counter value
  */
-void ITTAPI __itt_counter_set_value_ex(__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr);
+void ITTAPI __itt_counter_set_value_ex(__itt_counter id,
+                                       __itt_clock_domain *clock_domain,
+                                       unsigned long long timestamp,
+                                       void *value_ptr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, counter_set_value_ex, (__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr))
-#define __itt_counter_set_value_ex     ITTNOTIFY_VOID(counter_set_value_ex)
+ITT_STUBV(ITTAPI, void, counter_set_value_ex,
+          (__itt_counter id, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, void *value_ptr))
+#define __itt_counter_set_value_ex ITTNOTIFY_VOID(counter_set_value_ex)
 #define __itt_counter_set_value_ex_ptr ITTNOTIFY_NAME(counter_set_value_ex)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
 #define __itt_counter_set_value_ex_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_counter_set_value_ex_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Create a typed counter with given name/domain
  *
- * After __itt_counter_create_typed() is called, __itt_counter_inc(id), __itt_counter_inc_delta(id, delta),
- * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id, clock_domain, timestamp, value_ptr)
- * can be used to change the value of the counter
+ * After __itt_counter_create_typed() is called, __itt_counter_inc(id),
+ * __itt_counter_inc_delta(id, delta),
+ * __itt_counter_set_value(id, value_ptr) or __itt_counter_set_value_ex(id,
+ * clock_domain, timestamp, value_ptr) can be used to change the value of the
+ * counter
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_counter ITTAPI __itt_counter_create_typedA(const char    *name, const char    *domain, __itt_metadata_type type);
-__itt_counter ITTAPI __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_counter ITTAPI __itt_counter_create_typedA(const char *name,
+                                                 const char *domain,
+                                                 __itt_metadata_type type);
+__itt_counter ITTAPI __itt_counter_create_typedW(const wchar_t *name,
+                                                 const wchar_t *domain,
+                                                 __itt_metadata_type type);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_counter_create_typed     __itt_counter_create_typedW
-#  define __itt_counter_create_typed_ptr __itt_counter_create_typedW_ptr
+#define __itt_counter_create_typed __itt_counter_create_typedW
+#define __itt_counter_create_typed_ptr __itt_counter_create_typedW_ptr
 #else /* UNICODE */
-#  define __itt_counter_create_typed     __itt_counter_create_typedA
-#  define __itt_counter_create_typed_ptr __itt_counter_create_typedA_ptr
+#define __itt_counter_create_typed __itt_counter_create_typedA
+#define __itt_counter_create_typed_ptr __itt_counter_create_typedA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-__itt_counter ITTAPI __itt_counter_create_typed(const char *name, const char *domain, __itt_metadata_type type);
+__itt_counter ITTAPI __itt_counter_create_typed(const char *name,
+                                                const char *domain,
+                                                __itt_metadata_type type);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, (const char    *name, const char    *domain, __itt_metadata_type type))
-ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_counter, counter_create_typed,  (const char *name, const char *domain, __itt_metadata_type type))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA,
+         (const char *name, const char *domain, __itt_metadata_type type))
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW,
+         (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typed,
+         (const char *name, const char *domain, __itt_metadata_type type))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_counter_create_typedA     ITTNOTIFY_DATA(counter_create_typedA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_counter_create_typedA ITTNOTIFY_DATA(counter_create_typedA)
 #define __itt_counter_create_typedA_ptr ITTNOTIFY_NAME(counter_create_typedA)
-#define __itt_counter_create_typedW     ITTNOTIFY_DATA(counter_create_typedW)
+#define __itt_counter_create_typedW ITTNOTIFY_DATA(counter_create_typedW)
 #define __itt_counter_create_typedW_ptr ITTNOTIFY_NAME(counter_create_typedW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_counter_create_typed     ITTNOTIFY_DATA(counter_create_typed)
+#define __itt_counter_create_typed ITTNOTIFY_DATA(counter_create_typed)
 #define __itt_counter_create_typed_ptr ITTNOTIFY_NAME(counter_create_typed)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_counter_create_typedA(name, domain, type)
 #define __itt_counter_create_typedA_ptr 0
 #define __itt_counter_create_typedW(name, domain, type)
 #define __itt_counter_create_typedW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_counter_create_typed(name, domain, type)
-#define __itt_counter_create_typed_ptr  0
+#define __itt_counter_create_typed_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_counter_create_typedA_ptr 0
 #define __itt_counter_create_typedW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_counter_create_typed_ptr  0
+#define __itt_counter_create_typed_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Destroy the counter identified by the pointer previously returned by __itt_counter_create() or
+ * @brief Destroy the counter identified by the pointer previously returned by
+ * __itt_counter_create() or
  * __itt_counter_create_typed()
  */
 void ITTAPI __itt_counter_destroy(__itt_counter id);
 
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id))
-#define __itt_counter_destroy     ITTNOTIFY_VOID(counter_destroy)
+#define __itt_counter_destroy ITTNOTIFY_VOID(counter_destroy)
 #define __itt_counter_destroy_ptr ITTNOTIFY_NAME(counter_destroy)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_counter_destroy(id)
 #define __itt_counter_destroy_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_counter_destroy_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} counters group */
 
 /**
  * @ingroup markers
  * @brief Create a marker instance.
  * @param[in] domain The domain for this marker
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
  * @param[in] id The instance ID for this marker, or __itt_null
  * @param[in] name The name for this marker
  * @param[in] scope The scope for this marker
  */
-void ITTAPI __itt_marker_ex(const __itt_domain *domain,  __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope);
+void ITTAPI __itt_marker_ex(const __itt_domain *domain,
+                            __itt_clock_domain *clock_domain,
+                            unsigned long long timestamp, __itt_id id,
+                            __itt_string_handle *name, __itt_scope scope);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, marker_ex,    (const __itt_domain *domain,  __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope))
-#define __itt_marker_ex(d,x,y,z,a,b)    ITTNOTIFY_VOID_D5(marker_ex,d,x,y,z,a,b)
-#define __itt_marker_ex_ptr             ITTNOTIFY_NAME(marker_ex)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_marker_ex(domain,clock_domain,timestamp,id,name,scope)
-#define __itt_marker_ex_ptr    0
+ITT_STUBV(ITTAPI, void, marker_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id, __itt_string_handle *name,
+           __itt_scope scope))
+#define __itt_marker_ex(d, x, y, z, a, b)                                      \
+  ITTNOTIFY_VOID_D5(marker_ex, d, x, y, z, a, b)
+#define __itt_marker_ex_ptr ITTNOTIFY_NAME(marker_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_marker_ex(domain, clock_domain, timestamp, id, name, scope)
+#define __itt_marker_ex_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_marker_ex_ptr    0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_marker_ex_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup clockdomain
  * @brief Add a relation to the current task instance.
  * The current task instance is the head of the relation.
  * @param[in] domain The domain controlling this call
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
  * @param[in] relation The kind of relation
  * @param[in] tail The ID for the tail of the relation
  */
-void ITTAPI __itt_relation_add_to_current_ex(const __itt_domain *domain,  __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail);
+void ITTAPI __itt_relation_add_to_current_ex(const __itt_domain *domain,
+                                             __itt_clock_domain *clock_domain,
+                                             unsigned long long timestamp,
+                                             __itt_relation relation,
+                                             __itt_id tail);
 
 /**
  * @ingroup clockdomain
  * @brief Add a relation between two instance identifiers.
  * @param[in] domain The domain controlling this call
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
  * @param[in] head The ID for the head of the relation
  * @param[in] relation The kind of relation
  * @param[in] tail The ID for the tail of the relation
  */
-void ITTAPI __itt_relation_add_ex(const __itt_domain *domain,  __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail);
+void ITTAPI __itt_relation_add_ex(const __itt_domain *domain,
+                                  __itt_clock_domain *clock_domain,
+                                  unsigned long long timestamp, __itt_id head,
+                                  __itt_relation relation, __itt_id tail);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, relation_add_to_current_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail))
-ITT_STUBV(ITTAPI, void, relation_add_ex,            (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail))
-#define __itt_relation_add_to_current_ex(d,x,y,z,a) ITTNOTIFY_VOID_D4(relation_add_to_current_ex,d,x,y,z,a)
-#define __itt_relation_add_to_current_ex_ptr        ITTNOTIFY_NAME(relation_add_to_current_ex)
-#define __itt_relation_add_ex(d,x,y,z,a,b)          ITTNOTIFY_VOID_D5(relation_add_ex,d,x,y,z,a,b)
-#define __itt_relation_add_ex_ptr                   ITTNOTIFY_NAME(relation_add_ex)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_relation_add_to_current_ex(domain,clock_domain,timestamp,relation,tail)
+ITT_STUBV(ITTAPI, void, relation_add_to_current_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_relation relation,
+           __itt_id tail))
+ITT_STUBV(ITTAPI, void, relation_add_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id head, __itt_relation relation,
+           __itt_id tail))
+#define __itt_relation_add_to_current_ex(d, x, y, z, a)                        \
+  ITTNOTIFY_VOID_D4(relation_add_to_current_ex, d, x, y, z, a)
+#define __itt_relation_add_to_current_ex_ptr                                   \
+  ITTNOTIFY_NAME(relation_add_to_current_ex)
+#define __itt_relation_add_ex(d, x, y, z, a, b)                                \
+  ITTNOTIFY_VOID_D5(relation_add_ex, d, x, y, z, a, b)
+#define __itt_relation_add_ex_ptr ITTNOTIFY_NAME(relation_add_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_relation_add_to_current_ex(domain, clock_domain, timestamp,      \
+                                         relation, tail)
 #define __itt_relation_add_to_current_ex_ptr 0
-#define __itt_relation_add_ex(domain,clock_domain,timestamp,head,relation,tail)
+#define __itt_relation_add_ex(domain, clock_domain, timestamp, head, relation, \
+                              tail)
 #define __itt_relation_add_ex_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_relation_add_to_current_ex_ptr 0
 #define __itt_relation_add_ex_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @cond exclude_from_documentation */
-typedef enum ___itt_track_group_type
-{
-    __itt_track_group_type_normal = 0
+typedef enum ___itt_track_group_type {
 } __itt_track_group_type;
 /** @endcond */
 
 /** @cond exclude_from_documentation */
 #pragma pack(push, 8)
 
-typedef struct ___itt_track_group
-{
-    __itt_string_handle* name;     /*!< Name of the track group */
-    struct ___itt_track* track;    /*!< List of child tracks    */
-    __itt_track_group_type tgtype; /*!< Type of the track group */
-    int   extra1;                  /*!< Reserved. Must be zero  */
-    void* extra2;                  /*!< Reserved. Must be zero  */
-    struct ___itt_track_group* next;
+typedef struct ___itt_track_group {
+  __itt_string_handle *name; /*!< Name of the track group */
+  struct ___itt_track *track; /*!< List of child tracks    */
+  int extra1; /*!< Reserved. Must be zero  */
+  void *extra2; /*!< Reserved. Must be zero  */
+  struct ___itt_track_group *next;
 } __itt_track_group;
 
 #pragma pack(pop)
 /** @endcond */
 
 /**
  * @brief Placeholder for custom track types. Currently, "normal" custom track
  * is the only available track type.
  */
-typedef enum ___itt_track_type
-{
-    __itt_track_type_normal = 0
+typedef enum ___itt_track_type {
 #ifdef INTEL_ITTNOTIFY_API_PRIVATE
-    , __itt_track_type_queue
+  ,
+  __itt_track_type_queue
 #endif /* INTEL_ITTNOTIFY_API_PRIVATE */
 } __itt_track_type;
 
 /** @cond exclude_from_documentation */
 #pragma pack(push, 8)
 
-typedef struct ___itt_track
-{
-    __itt_string_handle* name; /*!< Name of the track group */
-    __itt_track_group* group;  /*!< Parent group to a track */
-    __itt_track_type ttype;    /*!< Type of the track       */
-    int   extra1;              /*!< Reserved. Must be zero  */
-    void* extra2;              /*!< Reserved. Must be zero  */
-    struct ___itt_track* next;
+typedef struct ___itt_track {
+  __itt_string_handle *name; /*!< Name of the track group */
+  __itt_track_group *group; /*!< Parent group to a track */
+  __itt_track_type ttype; /*!< Type of the track       */
+  int extra1; /*!< Reserved. Must be zero  */
+  void *extra2; /*!< Reserved. Must be zero  */
+  struct ___itt_track *next;
 } __itt_track;
 
 #pragma pack(pop)
 /** @endcond */
 
 /**
  * @brief Create logical track group.
  */
-__itt_track_group* ITTAPI __itt_track_group_create(__itt_string_handle* name, __itt_track_group_type track_group_type);
+__itt_track_group *ITTAPI __itt_track_group_create(
+    __itt_string_handle *name, __itt_track_group_type track_group_type);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUB(ITTAPI, __itt_track_group*, track_group_create, (__itt_string_handle* name, __itt_track_group_type track_group_type))
-#define __itt_track_group_create     ITTNOTIFY_DATA(track_group_create)
+ITT_STUB(ITTAPI, __itt_track_group *, track_group_create,
+         (__itt_string_handle * name, __itt_track_group_type track_group_type))
+#define __itt_track_group_create ITTNOTIFY_DATA(track_group_create)
 #define __itt_track_group_create_ptr ITTNOTIFY_NAME(track_group_create)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_track_group_create(name)  (__itt_track_group*)0
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_track_group_create(name) (__itt_track_group *)0
 #define __itt_track_group_create_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_track_group_create_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Create logical track.
  */
-__itt_track* ITTAPI __itt_track_create(__itt_track_group* track_group, __itt_string_handle* name, __itt_track_type track_type);
+__itt_track *ITTAPI __itt_track_create(__itt_track_group *track_group,
+                                       __itt_string_handle *name,
+                                       __itt_track_type track_type);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUB(ITTAPI, __itt_track*, track_create, (__itt_track_group* track_group,__itt_string_handle* name, __itt_track_type track_type))
-#define __itt_track_create     ITTNOTIFY_DATA(track_create)
+ITT_STUB(ITTAPI, __itt_track *, track_create,
+         (__itt_track_group * track_group, __itt_string_handle *name,
+          __itt_track_type track_type))
+#define __itt_track_create ITTNOTIFY_DATA(track_create)
 #define __itt_track_create_ptr ITTNOTIFY_NAME(track_create)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_track_create(track_group,name,track_type)  (__itt_track*)0
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_track_create(track_group, name, track_type) (__itt_track *)0
 #define __itt_track_create_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_track_create_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Set the logical track.
  */
-void ITTAPI __itt_set_track(__itt_track* track);
+void ITTAPI __itt_set_track(__itt_track *track);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, set_track, (__itt_track *track))
-#define __itt_set_track     ITTNOTIFY_VOID(set_track)
+ITT_STUBV(ITTAPI, void, set_track, (__itt_track * track))
+#define __itt_set_track ITTNOTIFY_VOID(set_track)
 #define __itt_set_track_ptr ITTNOTIFY_NAME(set_track)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_set_track(track)
 #define __itt_set_track_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_set_track_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /* ========================================================================== */
 /** @cond exclude_from_gpa_documentation */
 /**
  * @defgroup events Events
  * @ingroup public
  * Events group
  * @{
  */
 /** @brief user event type */
 typedef int __itt_event;
 
 /**
  * @brief Create an event notification
- * @note name or namelen being null/name and namelen not matching, user event feature not enabled
+ * @note name or namelen being null/name and namelen not matching, user event
+ * feature not enabled
  * @return non-zero event identifier upon success and __itt_err otherwise
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_event LIBITTAPI __itt_event_createA(const char    *name, int namelen);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_event LIBITTAPI __itt_event_createA(const char *name, int namelen);
 __itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_event_create     __itt_event_createW
-#  define __itt_event_create_ptr __itt_event_createW_ptr
+#define __itt_event_create __itt_event_createW
+#define __itt_event_create_ptr __itt_event_createW_ptr
 #else
-#  define __itt_event_create     __itt_event_createA
-#  define __itt_event_create_ptr __itt_event_createA_ptr
+#define __itt_event_create __itt_event_createA
+#define __itt_event_create_ptr __itt_event_createA_ptr
 #endif /* UNICODE */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 __itt_event LIBITTAPI __itt_event_create(const char *name, int namelen);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char    *name, int namelen))
-ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(LIBITTAPI, __itt_event, event_create,  (const char    *name, int namelen))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen))
+ITT_STUB(LIBITTAPI, __itt_event, event_createW,
+         (const wchar_t *name, int namelen))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_event_createA     ITTNOTIFY_DATA(event_createA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_event_createA ITTNOTIFY_DATA(event_createA)
 #define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA)
-#define __itt_event_createW     ITTNOTIFY_DATA(event_createW)
+#define __itt_event_createW ITTNOTIFY_DATA(event_createW)
 #define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_event_create      ITTNOTIFY_DATA(event_create)
-#define __itt_event_create_ptr  ITTNOTIFY_NAME(event_create)
+#define __itt_event_create ITTNOTIFY_DATA(event_create)
+#define __itt_event_create_ptr ITTNOTIFY_NAME(event_create)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_event_createA(name, namelen) (__itt_event)0
 #define __itt_event_createA_ptr 0
 #define __itt_event_createW(name, namelen) (__itt_event)0
 #define __itt_event_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_event_create(name, namelen)  (__itt_event)0
-#define __itt_event_create_ptr  0
+#define __itt_event_create(name, namelen) (__itt_event)0
+#define __itt_event_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_event_createA_ptr 0
 #define __itt_event_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_event_create_ptr  0
+#define __itt_event_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record an event occurrence.
- * @return __itt_err upon failure (invalid event id/user event feature not enabled)
+ * @return __itt_err upon failure (invalid event id/user event feature not
+ * enabled)
  */
 int LIBITTAPI __itt_event_start(__itt_event event);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event))
-#define __itt_event_start     ITTNOTIFY_DATA(event_start)
+#define __itt_event_start ITTNOTIFY_DATA(event_start)
 #define __itt_event_start_ptr ITTNOTIFY_NAME(event_start)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_event_start(event) (int)0
 #define __itt_event_start_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_event_start_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record an event end occurrence.
  * @note It is optional if events do not have durations.
- * @return __itt_err upon failure (invalid event id/user event feature not enabled)
+ * @return __itt_err upon failure (invalid event id/user event feature not
+ * enabled)
  */
 int LIBITTAPI __itt_event_end(__itt_event event);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event))
-#define __itt_event_end     ITTNOTIFY_DATA(event_end)
+#define __itt_event_end ITTNOTIFY_DATA(event_end)
 #define __itt_event_end_ptr ITTNOTIFY_NAME(event_end)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_event_end(event) (int)0
 #define __itt_event_end_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_event_end_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} events group */
 
-
 /**
  * @defgroup arrays Arrays Visualizer
  * @ingroup public
  * Visualize arrays
  * @{
  */
 
 /**
  * @enum __itt_av_data_type
  * @brief Defines types of arrays data (for C/C++ intrinsic types)
  */
-typedef enum
-{
-    __itt_e_first = 0,
-    __itt_e_char = 0,  /* 1-byte integer */
-    __itt_e_uchar,     /* 1-byte unsigned integer */
-    __itt_e_int16,     /* 2-byte integer */
-    __itt_e_uint16,    /* 2-byte unsigned integer  */
-    __itt_e_int32,     /* 4-byte integer */
-    __itt_e_uint32,    /* 4-byte unsigned integer */
-    __itt_e_int64,     /* 8-byte integer */
-    __itt_e_uint64,    /* 8-byte unsigned integer */
-    __itt_e_float,     /* 4-byte floating */
-    __itt_e_double,    /* 8-byte floating */
-    __itt_e_last = __itt_e_double
+typedef enum {
+  __itt_e_char = 0, /* 1-byte integer */
+  __itt_e_uchar, /* 1-byte unsigned integer */
+  __itt_e_int16, /* 2-byte integer */
+  __itt_e_uint16, /* 2-byte unsigned integer  */
+  __itt_e_int32, /* 4-byte integer */
+  __itt_e_uint32, /* 4-byte unsigned integer */
+  __itt_e_int64, /* 8-byte integer */
+  __itt_e_uint64, /* 8-byte unsigned integer */
+  __itt_e_float, /* 4-byte floating */
+  __itt_e_double, /* 8-byte floating */
 } __itt_av_data_type;
 
 /**
  * @brief Save an array data to a file.
- * Output format is defined by the file extension. The csv and bmp formats are supported (bmp - for 2-dimensional array only).
+ * Output format is defined by the file extension. The csv and bmp formats are
+ * supported (bmp - for 2-dimensional array only).
  * @param[in] data - pointer to the array data
  * @param[in] rank - the rank of the array
- * @param[in] dimensions - pointer to an array of integers, which specifies the array dimensions.
- * The size of dimensions must be equal to the rank
- * @param[in] type - the type of the array, specified as one of the __itt_av_data_type values (for intrinsic types)
- * @param[in] filePath - the file path; the output format is defined by the file extension
- * @param[in] columnOrder - defines how the array is stored in the linear memory.
- * It should be 1 for column-major order (e.g. in FORTRAN) or 0 - for row-major order (e.g. in C).
+ * @param[in] dimensions - pointer to an array of integers, which specifies the
+ * array dimensions. The size of dimensions must be equal to the rank
+ * @param[in] type - the type of the array, specified as one of the
+ * __itt_av_data_type values (for intrinsic types)
+ * @param[in] filePath - the file path; the output format is defined by the file
+ * extension
+ * @param[in] columnOrder - defines how the array is stored in the linear
+ * memory. It should be 1 for column-major order (e.g. in FORTRAN) or 0 - for
+ * row-major order (e.g. in C).
  */
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-int ITTAPI __itt_av_saveA(void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder);
-int ITTAPI __itt_av_saveW(void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+int ITTAPI __itt_av_saveA(void *data, int rank, const int *dimensions, int type,
+                          const char *filePath, int columnOrder);
+int ITTAPI __itt_av_saveW(void *data, int rank, const int *dimensions, int type,
+                          const wchar_t *filePath, int columnOrder);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_av_save     __itt_av_saveW
-#  define __itt_av_save_ptr __itt_av_saveW_ptr
+#define __itt_av_save __itt_av_saveW
+#define __itt_av_save_ptr __itt_av_saveW_ptr
 #else /* UNICODE */
-#  define __itt_av_save     __itt_av_saveA
-#  define __itt_av_save_ptr __itt_av_saveA_ptr
+#define __itt_av_save __itt_av_saveA
+#define __itt_av_save_ptr __itt_av_saveA_ptr
 #endif /* UNICODE */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-int ITTAPI __itt_av_save(void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder);
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+int ITTAPI __itt_av_save(void *data, int rank, const int *dimensions, int type,
+                         const char *filePath, int columnOrder);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, int, av_saveA, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder))
-ITT_STUB(ITTAPI, int, av_saveW, (void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, int, av_save,  (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, av_saveA,
+         (void *data, int rank, const int *dimensions, int type,
+          const char *filePath, int columnOrder))
+ITT_STUB(ITTAPI, int, av_saveW,
+         (void *data, int rank, const int *dimensions, int type,
+          const wchar_t *filePath, int columnOrder))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, av_save,
+         (void *data, int rank, const int *dimensions, int type,
+          const char *filePath, int columnOrder))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_av_saveA     ITTNOTIFY_DATA(av_saveA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_av_saveA ITTNOTIFY_DATA(av_saveA)
 #define __itt_av_saveA_ptr ITTNOTIFY_NAME(av_saveA)
-#define __itt_av_saveW     ITTNOTIFY_DATA(av_saveW)
+#define __itt_av_saveW ITTNOTIFY_DATA(av_saveW)
 #define __itt_av_saveW_ptr ITTNOTIFY_NAME(av_saveW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_av_save     ITTNOTIFY_DATA(av_save)
+#define __itt_av_save ITTNOTIFY_DATA(av_save)
 #define __itt_av_save_ptr ITTNOTIFY_NAME(av_save)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_av_saveA(name)
 #define __itt_av_saveA_ptr 0
 #define __itt_av_saveW(name)
 #define __itt_av_saveW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_av_save(name)
 #define __itt_av_save_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_av_saveA_ptr 0
 #define __itt_av_saveW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_av_save_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 void ITTAPI __itt_enable_attach(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, enable_attach, (void))
-#define __itt_enable_attach     ITTNOTIFY_VOID(enable_attach)
+#define __itt_enable_attach ITTNOTIFY_VOID(enable_attach)
 #define __itt_enable_attach_ptr ITTNOTIFY_NAME(enable_attach)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_enable_attach()
 #define __itt_enable_attach_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_enable_attach_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @cond exclude_from_gpa_documentation */
 
 /** @} arrays group */
 
 /** @endcond */
 
 /**
  * @brief Module load info
  * This API is used to report necessary information in case of module relocation
  * @param[in] start_addr - relocated module start address
  * @param[in] end_addr - relocated module end address
  * @param[in] path - file system path to the module
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-void ITTAPI __itt_module_loadA(void *start_addr, void *end_addr, const char *path);
-void ITTAPI __itt_module_loadW(void *start_addr, void *end_addr, const wchar_t *path);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+void ITTAPI __itt_module_loadA(void *start_addr, void *end_addr,
+                               const char *path);
+void ITTAPI __itt_module_loadW(void *start_addr, void *end_addr,
+                               const wchar_t *path);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_module_load     __itt_module_loadW
-#  define __itt_module_load_ptr __itt_module_loadW_ptr
+#define __itt_module_load __itt_module_loadW
+#define __itt_module_load_ptr __itt_module_loadW_ptr
 #else /* UNICODE */
-#  define __itt_module_load     __itt_module_loadA
-#  define __itt_module_load_ptr __itt_module_loadA_ptr
+#define __itt_module_load __itt_module_loadA
+#define __itt_module_load_ptr __itt_module_loadA_ptr
 #endif /* UNICODE */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-void ITTAPI __itt_module_load(void *start_addr, void *end_addr, const char *path);
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+void ITTAPI __itt_module_load(void *start_addr, void *end_addr,
+                              const char *path);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, void, module_loadA, (void *start_addr, void *end_addr, const char *path))
-ITT_STUB(ITTAPI, void, module_loadW, (void *start_addr, void *end_addr, const wchar_t *path))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, void, module_load,  (void *start_addr, void *end_addr, const char *path))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, void, module_loadA,
+         (void *start_addr, void *end_addr, const char *path))
+ITT_STUB(ITTAPI, void, module_loadW,
+         (void *start_addr, void *end_addr, const wchar_t *path))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, void, module_load,
+         (void *start_addr, void *end_addr, const char *path))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_module_loadA     ITTNOTIFY_VOID(module_loadA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_module_loadA ITTNOTIFY_VOID(module_loadA)
 #define __itt_module_loadA_ptr ITTNOTIFY_NAME(module_loadA)
-#define __itt_module_loadW     ITTNOTIFY_VOID(module_loadW)
+#define __itt_module_loadW ITTNOTIFY_VOID(module_loadW)
 #define __itt_module_loadW_ptr ITTNOTIFY_NAME(module_loadW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_module_load     ITTNOTIFY_VOID(module_load)
+#define __itt_module_load ITTNOTIFY_VOID(module_load)
 #define __itt_module_load_ptr ITTNOTIFY_NAME(module_load)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_module_loadA(start_addr, end_addr, path)
 #define __itt_module_loadA_ptr 0
 #define __itt_module_loadW(start_addr, end_addr, path)
 #define __itt_module_loadW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_module_load(start_addr, end_addr, path)
 #define __itt_module_load_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_module_loadA_ptr 0
 #define __itt_module_loadW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_module_load_ptr  0
+#define __itt_module_load_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
-
-
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
 
 #endif /* _ITTNOTIFY_H_ */
 
 #ifdef INTEL_ITTNOTIFY_API_PRIVATE
 
 #ifndef _ITTNOTIFY_PRIVATE_
 #define _ITTNOTIFY_PRIVATE_
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
 /**
  * @ingroup clockdomain
  * @brief Begin an overlapped task instance.
  * @param[in] domain The domain for this task
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
- * @param[in] taskid The identifier for this task instance, *cannot* be __itt_null.
+ * @param[in] taskid The identifier for this task instance, *cannot* be
+ * __itt_null.
  * @param[in] parentid The parent of this task, or __itt_null.
  * @param[in] name The name of this task.
  */
-void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name);
+void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain *domain,
+                                           __itt_clock_domain *clock_domain,
+                                           unsigned long long timestamp,
+                                           __itt_id taskid, __itt_id parentid,
+                                           __itt_string_handle *name);
 
 /**
  * @ingroup clockdomain
  * @brief End an overlapped task instance.
  * @param[in] domain The domain for this task
- * @param[in] clock_domain The clock domain controlling the execution of this call.
+ * @param[in] clock_domain The clock domain controlling the execution of this
+ * call.
  * @param[in] timestamp The user defined timestamp.
  * @param[in] taskid Explicit ID of finished task
  */
-void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid);
+void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain *domain,
+                                         __itt_clock_domain *clock_domain,
+                                         unsigned long long timestamp,
+                                         __itt_id taskid);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex,       (const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name))
-ITT_STUBV(ITTAPI, void, task_end_overlapped_ex,         (const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid))
-#define __itt_task_begin_overlapped_ex(d,x,y,z,a,b)     ITTNOTIFY_VOID_D5(task_begin_overlapped_ex,d,x,y,z,a,b)
-#define __itt_task_begin_overlapped_ex_ptr              ITTNOTIFY_NAME(task_begin_overlapped_ex)
-#define __itt_task_end_overlapped_ex(d,x,y,z)           ITTNOTIFY_VOID_D3(task_end_overlapped_ex,d,x,y,z)
-#define __itt_task_end_overlapped_ex_ptr                ITTNOTIFY_NAME(task_end_overlapped_ex)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_task_begin_overlapped_ex(domain,clock_domain,timestamp,taskid,parentid,name)
-#define __itt_task_begin_overlapped_ex_ptr      0
-#define __itt_task_end_overlapped_ex(domain,clock_domain,timestamp,taskid)
-#define __itt_task_end_overlapped_ex_ptr        0
+ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id taskid, __itt_id parentid,
+           __itt_string_handle *name))
+ITT_STUBV(ITTAPI, void, task_end_overlapped_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id taskid))
+#define __itt_task_begin_overlapped_ex(d, x, y, z, a, b)                       \
+  ITTNOTIFY_VOID_D5(task_begin_overlapped_ex, d, x, y, z, a, b)
+#define __itt_task_begin_overlapped_ex_ptr                                     \
+  ITTNOTIFY_NAME(task_begin_overlapped_ex)
+#define __itt_task_end_overlapped_ex(d, x, y, z)                               \
+  ITTNOTIFY_VOID_D3(task_end_overlapped_ex, d, x, y, z)
+#define __itt_task_end_overlapped_ex_ptr ITTNOTIFY_NAME(task_end_overlapped_ex)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_task_begin_overlapped_ex(domain, clock_domain, timestamp,        \
+                                       taskid, parentid, name)
+#define __itt_task_begin_overlapped_ex_ptr 0
+#define __itt_task_end_overlapped_ex(domain, clock_domain, timestamp, taskid)
+#define __itt_task_end_overlapped_ex_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_task_begin_overlapped_ex_ptr      0
-#define __itt_task_end_overlapped_ptr           0
-#define __itt_task_end_overlapped_ex_ptr        0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_task_begin_overlapped_ex_ptr 0
+#define __itt_task_end_overlapped_ptr 0
+#define __itt_task_end_overlapped_ex_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @defgroup makrs_internal Marks
  * @ingroup internal
  * Marks group
  * @warning Internal API:
  *   - It is not shipped to outside of Intel
  *   - It is delivered to internal Intel teams using e-mail or SVN access only
  * @{
  */
 /** @brief user mark type */
 typedef int __itt_mark_type;
 
 /**
- * @brief Creates a user mark type with the specified name using char or Unicode string.
+ * @brief Creates a user mark type with the specified name using char or Unicode
+ * string.
  * @param[in] name - name of mark to create
  * @return Returns a handle to the mark type
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_mark_type ITTAPI __itt_mark_createA(const char    *name);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_mark_type ITTAPI __itt_mark_createA(const char *name);
 __itt_mark_type ITTAPI __itt_mark_createW(const wchar_t *name);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_mark_create     __itt_mark_createW
-#  define __itt_mark_create_ptr __itt_mark_createW_ptr
+#define __itt_mark_create __itt_mark_createW
+#define __itt_mark_create_ptr __itt_mark_createW_ptr
 #else /* UNICODE */
-#  define __itt_mark_create     __itt_mark_createA
-#  define __itt_mark_create_ptr __itt_mark_createA_ptr
+#define __itt_mark_create __itt_mark_createA
+#define __itt_mark_create_ptr __itt_mark_createA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 __itt_mark_type ITTAPI __itt_mark_create(const char *name);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char    *name))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char *name))
 ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_mark_type, mark_create,  (const char *name))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_mark_type, mark_create, (const char *name))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_mark_createA     ITTNOTIFY_DATA(mark_createA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_mark_createA ITTNOTIFY_DATA(mark_createA)
 #define __itt_mark_createA_ptr ITTNOTIFY_NAME(mark_createA)
-#define __itt_mark_createW     ITTNOTIFY_DATA(mark_createW)
+#define __itt_mark_createW ITTNOTIFY_DATA(mark_createW)
 #define __itt_mark_createW_ptr ITTNOTIFY_NAME(mark_createW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_mark_create      ITTNOTIFY_DATA(mark_create)
-#define __itt_mark_create_ptr  ITTNOTIFY_NAME(mark_create)
+#define __itt_mark_create ITTNOTIFY_DATA(mark_create)
+#define __itt_mark_create_ptr ITTNOTIFY_NAME(mark_create)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_mark_createA(name) (__itt_mark_type)0
 #define __itt_mark_createA_ptr 0
 #define __itt_mark_createW(name) (__itt_mark_type)0
 #define __itt_mark_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_mark_create(name)  (__itt_mark_type)0
-#define __itt_mark_create_ptr  0
+#define __itt_mark_create(name) (__itt_mark_type)0
+#define __itt_mark_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_mark_createA_ptr 0
 #define __itt_mark_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_mark_create_ptr  0
+#define __itt_mark_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Creates a "discrete" user mark type of the specified type and an optional parameter using char or Unicode string.
+ * @brief Creates a "discrete" user mark type of the specified type and an
+ * optional parameter using char or Unicode string.
  *
- * - The mark of "discrete" type is placed to collection results in case of success. It appears in overtime view(s) as a special tick sign.
- * - The call is "synchronous" - function returns after mark is actually added to results.
- * - This function is useful, for example, to mark different phases of application
- *   (beginning of the next mark automatically meand end of current region).
- * - Can be used together with "continuous" marks (see below) at the same collection session
+ * - The mark of "discrete" type is placed to collection results in case of
+ * success. It appears in overtime view(s) as a special tick sign.
+ * - The call is "synchronous" - function returns after mark is actually added
+ * to results.
+ * - This function is useful, for example, to mark different phases of
+ * application (beginning of the next mark automatically meand end of current
+ * region).
+ * - Can be used together with "continuous" marks (see below) at the same
+ * collection session
  * @param[in] mt - mark, created by __itt_mark_create(const char* name) function
  * @param[in] parameter - string parameter of mark
  * @return Returns zero value in case of success, non-zero value otherwise.
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-int ITTAPI __itt_markA(__itt_mark_type mt, const char    *parameter);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+int ITTAPI __itt_markA(__itt_mark_type mt, const char *parameter);
 int ITTAPI __itt_markW(__itt_mark_type mt, const wchar_t *parameter);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_mark     __itt_markW
-#  define __itt_mark_ptr __itt_markW_ptr
+#define __itt_mark __itt_markW
+#define __itt_mark_ptr __itt_markW_ptr
 #else /* UNICODE  */
-#  define __itt_mark     __itt_markA
-#  define __itt_mark_ptr __itt_markA_ptr
+#define __itt_mark __itt_markA
+#define __itt_mark_ptr __itt_markA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 int ITTAPI __itt_mark(__itt_mark_type mt, const char *parameter);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char    *parameter))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char *parameter))
 ITT_STUB(ITTAPI, int, markW, (__itt_mark_type mt, const wchar_t *parameter))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, int, mark,  (__itt_mark_type mt, const char *parameter))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, mark, (__itt_mark_type mt, const char *parameter))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_markA     ITTNOTIFY_DATA(markA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_markA ITTNOTIFY_DATA(markA)
 #define __itt_markA_ptr ITTNOTIFY_NAME(markA)
-#define __itt_markW     ITTNOTIFY_DATA(markW)
+#define __itt_markW ITTNOTIFY_DATA(markW)
 #define __itt_markW_ptr ITTNOTIFY_NAME(markW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_mark      ITTNOTIFY_DATA(mark)
-#define __itt_mark_ptr  ITTNOTIFY_NAME(mark)
+#define __itt_mark ITTNOTIFY_DATA(mark)
+#define __itt_mark_ptr ITTNOTIFY_NAME(mark)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_markA(mt, parameter) (int)0
 #define __itt_markA_ptr 0
 #define __itt_markW(mt, parameter) (int)0
 #define __itt_markW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_mark(mt, parameter)  (int)0
-#define __itt_mark_ptr  0
+#define __itt_mark(mt, parameter) (int)0
+#define __itt_mark_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_markA_ptr 0
 #define __itt_markW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_mark_ptr  0
+#define __itt_mark_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Use this if necessary to create a "discrete" user event type (mark) for process
- * rather then for one thread
+ * @brief Use this if necessary to create a "discrete" user event type (mark)
+ * for process rather then for one thread
  * @see int __itt_mark(__itt_mark_type mt, const char* parameter);
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-int ITTAPI __itt_mark_globalA(__itt_mark_type mt, const char    *parameter);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+int ITTAPI __itt_mark_globalA(__itt_mark_type mt, const char *parameter);
 int ITTAPI __itt_mark_globalW(__itt_mark_type mt, const wchar_t *parameter);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_mark_global     __itt_mark_globalW
-#  define __itt_mark_global_ptr __itt_mark_globalW_ptr
+#define __itt_mark_global __itt_mark_globalW
+#define __itt_mark_global_ptr __itt_mark_globalW_ptr
 #else /* UNICODE  */
-#  define __itt_mark_global     __itt_mark_globalA
-#  define __itt_mark_global_ptr __itt_mark_globalA_ptr
+#define __itt_mark_global __itt_mark_globalA
+#define __itt_mark_global_ptr __itt_mark_globalA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 int ITTAPI __itt_mark_global(__itt_mark_type mt, const char *parameter);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char    *parameter))
-ITT_STUB(ITTAPI, int, mark_globalW, (__itt_mark_type mt, const wchar_t *parameter))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, int, mark_global,  (__itt_mark_type mt, const char *parameter))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char *parameter))
+ITT_STUB(ITTAPI, int, mark_globalW,
+         (__itt_mark_type mt, const wchar_t *parameter))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, mark_global, (__itt_mark_type mt, const char *parameter))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_mark_globalA     ITTNOTIFY_DATA(mark_globalA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_mark_globalA ITTNOTIFY_DATA(mark_globalA)
 #define __itt_mark_globalA_ptr ITTNOTIFY_NAME(mark_globalA)
-#define __itt_mark_globalW     ITTNOTIFY_DATA(mark_globalW)
+#define __itt_mark_globalW ITTNOTIFY_DATA(mark_globalW)
 #define __itt_mark_globalW_ptr ITTNOTIFY_NAME(mark_globalW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_mark_global      ITTNOTIFY_DATA(mark_global)
-#define __itt_mark_global_ptr  ITTNOTIFY_NAME(mark_global)
+#define __itt_mark_global ITTNOTIFY_DATA(mark_global)
+#define __itt_mark_global_ptr ITTNOTIFY_NAME(mark_global)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_mark_globalA(mt, parameter) (int)0
 #define __itt_mark_globalA_ptr 0
 #define __itt_mark_globalW(mt, parameter) (int)0
 #define __itt_mark_globalW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_mark_global(mt, parameter)  (int)0
-#define __itt_mark_global_ptr  0
+#define __itt_mark_global(mt, parameter) (int)0
+#define __itt_mark_global_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_mark_globalA_ptr 0
 #define __itt_mark_globalW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_mark_global_ptr  0
+#define __itt_mark_global_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Creates an "end" point for "continuous" mark with specified name.
  *
  * - Returns zero value in case of success, non-zero value otherwise.

  * @return Returns zero value in case of success, non-zero value otherwise.
  */
 int ITTAPI __itt_mark_off(__itt_mark_type mt);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(ITTAPI, int, mark_off, (__itt_mark_type mt))
-#define __itt_mark_off     ITTNOTIFY_DATA(mark_off)
+#define __itt_mark_off ITTNOTIFY_DATA(mark_off)
 #define __itt_mark_off_ptr ITTNOTIFY_NAME(mark_off)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_mark_off(mt) (int)0
 #define __itt_mark_off_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_mark_off_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Use this if necessary to create an "end" point for mark of process
  * @see int __itt_mark_off(__itt_mark_type mt);
  */
 int ITTAPI __itt_mark_global_off(__itt_mark_type mt);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt))
-#define __itt_mark_global_off     ITTNOTIFY_DATA(mark_global_off)
+#define __itt_mark_global_off ITTNOTIFY_DATA(mark_global_off)
 #define __itt_mark_global_off_ptr ITTNOTIFY_NAME(mark_global_off)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_mark_global_off(mt) (int)0
 #define __itt_mark_global_off_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_mark_global_off_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} marks group */
 
 /**
  * @defgroup counters_internal Counters
  * @ingroup internal
  * Counters group
  * @{
  */
 
-
 /**
  * @defgroup stitch Stack Stitching
  * @ingroup internal
  * Stack Stitching group
  * @{
  */
 /**
  * @brief opaque structure for counter identification
  */
 typedef struct ___itt_caller *__itt_caller;
 
 /**
- * @brief Create the stitch point e.g. a point in call stack where other stacks should be stitched to.
- * The function returns a unique identifier which is used to match the cut points with corresponding stitch points.
+ * @brief Create the stitch point e.g. a point in call stack where other stacks
+ * should be stitched to. The function returns a unique identifier which is used
+ * to match the cut points with corresponding stitch points.
  */
 __itt_caller ITTAPI __itt_stack_caller_create(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void))
-#define __itt_stack_caller_create     ITTNOTIFY_DATA(stack_caller_create)
+#define __itt_stack_caller_create ITTNOTIFY_DATA(stack_caller_create)
 #define __itt_stack_caller_create_ptr ITTNOTIFY_NAME(stack_caller_create)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_stack_caller_create() (__itt_caller)0
 #define __itt_stack_caller_create_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_stack_caller_create_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Destroy the information about stitch point identified by the pointer previously returned by __itt_stack_caller_create()
+ * @brief Destroy the information about stitch point identified by the pointer
+ * previously returned by __itt_stack_caller_create()
  */
 void ITTAPI __itt_stack_caller_destroy(__itt_caller id);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id))
-#define __itt_stack_caller_destroy     ITTNOTIFY_VOID(stack_caller_destroy)
+#define __itt_stack_caller_destroy ITTNOTIFY_VOID(stack_caller_destroy)
 #define __itt_stack_caller_destroy_ptr ITTNOTIFY_NAME(stack_caller_destroy)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_stack_caller_destroy(id)
 #define __itt_stack_caller_destroy_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_stack_caller_destroy_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Sets the cut point. Stack from each event which occurs after this call will be cut
- * at the same stack level the function was called and stitched to the corresponding stitch point.
+ * @brief Sets the cut point. Stack from each event which occurs after this call
+ * will be cut at the same stack level the function was called and stitched to
+ * the corresponding stitch point.
  */
 void ITTAPI __itt_stack_callee_enter(__itt_caller id);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, stack_callee_enter, (__itt_caller id))
-#define __itt_stack_callee_enter     ITTNOTIFY_VOID(stack_callee_enter)
+#define __itt_stack_callee_enter ITTNOTIFY_VOID(stack_callee_enter)
 #define __itt_stack_callee_enter_ptr ITTNOTIFY_NAME(stack_callee_enter)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_stack_callee_enter(id)
 #define __itt_stack_callee_enter_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_stack_callee_enter_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief This function eliminates the cut point which was set by latest __itt_stack_callee_enter().
+ * @brief This function eliminates the cut point which was set by latest
+ * __itt_stack_callee_enter().
  */
 void ITTAPI __itt_stack_callee_leave(__itt_caller id);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, stack_callee_leave, (__itt_caller id))
-#define __itt_stack_callee_leave     ITTNOTIFY_VOID(stack_callee_leave)
+#define __itt_stack_callee_leave ITTNOTIFY_VOID(stack_callee_leave)
 #define __itt_stack_callee_leave_ptr ITTNOTIFY_NAME(stack_callee_leave)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_stack_callee_leave(id)
 #define __itt_stack_callee_leave_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_stack_callee_leave_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @} stitch group */
 
-/* ***************************************************************************************************************************** */
+/* *****************************************************************************************************************************
+ */
 
 #include <stdarg.h>
 
 /** @cond exclude_from_documentation */
-typedef enum __itt_error_code
-{
-    __itt_error_success       = 0, /*!< no error */
-    __itt_error_no_module     = 1, /*!< module can't be loaded */
-    /* %1$s -- library name; win: %2$d -- system error code; unx: %2$s -- system error message. */
-    __itt_error_no_symbol     = 2, /*!< symbol not found */
-    /* %1$s -- library name, %2$s -- symbol name. */
-    __itt_error_unknown_group = 3, /*!< unknown group specified */
-    /* %1$s -- env var name, %2$s -- group name. */
-    __itt_error_cant_read_env = 4, /*!< GetEnvironmentVariable() failed */
-    /* %1$s -- env var name, %2$d -- system error. */
-    __itt_error_env_too_long  = 5, /*!< variable value too long */
-    /* %1$s -- env var name, %2$d -- actual length of the var, %3$d -- max allowed length. */
-    __itt_error_system        = 6  /*!< pthread_mutexattr_init or pthread_mutex_init failed */
-    /* %1$s -- function name, %2$d -- errno. */
+typedef enum __itt_error_code {
+  __itt_error_success = 0, /*!< no error */
+  __itt_error_no_module = 1, /*!< module can't be loaded */
+  /* %1$s -- library name; win: %2$d -- system error code; unx: %2$s -- system
+     error message. */
+  __itt_error_no_symbol = 2, /*!< symbol not found */
+  __itt_error_env_too_long = 5, /*!< variable value too long */
+  /* %1$s -- env var name, %2$d -- actual length of the var, %3$d -- max allowed
+     length. */
+  __itt_error_system =
+      6 /*!< pthread_mutexattr_init or pthread_mutex_init failed */
 } __itt_error_code;
 
-typedef void (__itt_error_handler_t)(__itt_error_code code, va_list);
-__itt_error_handler_t* __itt_set_error_handler(__itt_error_handler_t*);
+typedef void(__itt_error_handler_t)(__itt_error_code code, va_list);
+__itt_error_handler_t *__itt_set_error_handler(__itt_error_handler_t *);
 
-const char* ITTAPI __itt_api_version(void);
+const char *ITTAPI __itt_api_version(void);
 /** @endcond */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 #define __itt_error_handler ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, error_handler)
 void __itt_error_handler(__itt_error_code code, va_list args);
 extern const int ITTNOTIFY_NAME(err);
 #define __itt_err ITTNOTIFY_NAME(err)
-ITT_STUB(ITTAPI, const char*, api_version, (void))
-#define __itt_api_version     ITTNOTIFY_DATA(api_version)
+ITT_STUB(ITTAPI, const char *, api_version, (void))
+#define __itt_api_version ITTNOTIFY_DATA(api_version)
 #define __itt_api_version_ptr ITTNOTIFY_NAME(api_version)
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#define __itt_api_version()   (const char*)0
+#else /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_api_version() (const char *)0
 #define __itt_api_version_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_api_version_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
 
 #endif /* _ITTNOTIFY_PRIVATE_ */
 
 #endif /* INTEL_ITTNOTIFY_API_PRIVATE */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_config.h

 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _ITTNOTIFY_CONFIG_H_
 #define _ITTNOTIFY_CONFIG_H_
 
 /** @cond exclude_from_documentation */
 #ifndef ITT_OS_WIN
-#  define ITT_OS_WIN   1
+#define ITT_OS_WIN 1
 #endif /* ITT_OS_WIN */
 
 #ifndef ITT_OS_LINUX
-#  define ITT_OS_LINUX 2
+#define ITT_OS_LINUX 2
 #endif /* ITT_OS_LINUX */
 
 #ifndef ITT_OS_MAC
-#  define ITT_OS_MAC   3
+#define ITT_OS_MAC 3
 #endif /* ITT_OS_MAC */
 
 #ifndef ITT_OS_FREEBSD
-#  define ITT_OS_FREEBSD   4
+#define ITT_OS_FREEBSD 4
 #endif /* ITT_OS_FREEBSD */
 
 #ifndef ITT_OS
-#  if defined WIN32 || defined _WIN32
-#    define ITT_OS ITT_OS_WIN
-#  elif defined( __APPLE__ ) && defined( __MACH__ )
-#    define ITT_OS ITT_OS_MAC
-#  elif defined( __FreeBSD__ )
-#    define ITT_OS ITT_OS_FREEBSD
-#  else
-#    define ITT_OS ITT_OS_LINUX
-#  endif
+#if defined WIN32 || defined _WIN32
+#define ITT_OS ITT_OS_WIN
+#elif defined(__APPLE__) && defined(__MACH__)
+#define ITT_OS ITT_OS_MAC
+#elif defined(__FreeBSD__)
+#define ITT_OS ITT_OS_FREEBSD
+#else
+#define ITT_OS ITT_OS_LINUX
+#endif
 #endif /* ITT_OS */
 
 #ifndef ITT_PLATFORM_WIN
-#  define ITT_PLATFORM_WIN 1
+#define ITT_PLATFORM_WIN 1
 #endif /* ITT_PLATFORM_WIN */
 
 #ifndef ITT_PLATFORM_POSIX
-#  define ITT_PLATFORM_POSIX 2
+#define ITT_PLATFORM_POSIX 2
 #endif /* ITT_PLATFORM_POSIX */
 
 #ifndef ITT_PLATFORM_MAC
-#  define ITT_PLATFORM_MAC 3
+#define ITT_PLATFORM_MAC 3
 #endif /* ITT_PLATFORM_MAC */
 
 #ifndef ITT_PLATFORM_FREEBSD
-#  define ITT_PLATFORM_FREEBSD 4
+#define ITT_PLATFORM_FREEBSD 4
 #endif /* ITT_PLATFORM_FREEBSD */
 
 #ifndef ITT_PLATFORM
-#  if ITT_OS==ITT_OS_WIN
-#    define ITT_PLATFORM ITT_PLATFORM_WIN
-#  elif ITT_OS==ITT_OS_MAC
-#    define ITT_PLATFORM ITT_PLATFORM_MAC
-#  elif ITT_OS==ITT_OS_FREEBSD
-#    define ITT_PLATFORM ITT_PLATFORM_FREEBSD
-#  else
-#    define ITT_PLATFORM ITT_PLATFORM_POSIX
-#  endif
+#if ITT_OS == ITT_OS_WIN
+#define ITT_PLATFORM ITT_PLATFORM_WIN
+#elif ITT_OS == ITT_OS_MAC
+#define ITT_PLATFORM ITT_PLATFORM_MAC
+#elif ITT_OS == ITT_OS_FREEBSD
+#define ITT_PLATFORM ITT_PLATFORM_FREEBSD
+#else
+#define ITT_PLATFORM ITT_PLATFORM_POSIX
+#endif
 #endif /* ITT_PLATFORM */
 
 #if defined(_UNICODE) && !defined(UNICODE)
 #define UNICODE
 #endif
 
 #include <stddef.h>
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #include <tchar.h>
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #include <stdint.h>
 #if defined(UNICODE) || defined(_UNICODE)
 #include <wchar.h>
 #endif /* UNICODE || _UNICODE */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #ifndef ITTAPI_CDECL
-#  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    define ITTAPI_CDECL __cdecl
-#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#    if defined _M_IX86 || defined __i386__
-#      define ITTAPI_CDECL __attribute__ ((cdecl))
-#    else  /* _M_IX86 || __i386__ */
-#      define ITTAPI_CDECL /* actual only on x86 platform */
-#    endif /* _M_IX86 || __i386__ */
-#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define ITTAPI_CDECL __cdecl
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if defined _M_IX86 || defined __i386__
+#define ITTAPI_CDECL __attribute__((cdecl))
+#else /* _M_IX86 || __i386__ */
+#define ITTAPI_CDECL /* actual only on x86 platform */
+#endif /* _M_IX86 || __i386__ */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* ITTAPI_CDECL */
 
 #ifndef STDCALL
-#  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    define STDCALL __stdcall
-#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#    if defined _M_IX86 || defined __i386__
-#      define STDCALL __attribute__ ((stdcall))
-#    else  /* _M_IX86 || __i386__ */
-#      define STDCALL /* supported only on x86 platform */
-#    endif /* _M_IX86 || __i386__ */
-#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define STDCALL __stdcall
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if defined _M_IX86 || defined __i386__
+#define STDCALL __attribute__((stdcall))
+#else /* _M_IX86 || __i386__ */
+#define STDCALL /* supported only on x86 platform */
+#endif /* _M_IX86 || __i386__ */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* STDCALL */
 
-#define ITTAPI    ITTAPI_CDECL
+#define ITTAPI ITTAPI_CDECL
 #define LIBITTAPI ITTAPI_CDECL
 
 /* TODO: Temporary for compatibility! */
-#define ITTAPI_CALL    ITTAPI_CDECL
+#define ITTAPI_CALL ITTAPI_CDECL
 #define LIBITTAPI_CALL ITTAPI_CDECL
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 /* use __forceinline (VC++ specific) */
-#define ITT_INLINE           __forceinline
+#define ITT_INLINE __forceinline
 #define ITT_INLINE_ATTRIBUTE /* nothing */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 /*
  * Generally, functions are not inlined unless optimization is specified.
  * For functions declared inline, this attribute inlines the function even
  * if no optimization level was specified.
  */
 #ifdef __STRICT_ANSI__
-#define ITT_INLINE           static
+#define ITT_INLINE static
 #define ITT_INLINE_ATTRIBUTE __attribute__((unused))
-#else  /* __STRICT_ANSI__ */
-#define ITT_INLINE           static inline
+#else /* __STRICT_ANSI__ */
+#define ITT_INLINE static inline
 #define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
 #endif /* __STRICT_ANSI__ */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 /** @endcond */
 
 #ifndef ITT_ARCH_IA32
-#  define ITT_ARCH_IA32  1
+#define ITT_ARCH_IA32 1
 #endif /* ITT_ARCH_IA32 */
 
 #ifndef ITT_ARCH_IA32E
-#  define ITT_ARCH_IA32E 2
+#define ITT_ARCH_IA32E 2
 #endif /* ITT_ARCH_IA32E */
 
 /* Was there a magical reason we didn't have 3 here before? */
 #ifndef ITT_ARCH_AARCH64
-#  define ITT_ARCH_AARCH64  3
+#define ITT_ARCH_AARCH64 3
 #endif /* ITT_ARCH_AARCH64 */
 
 #ifndef ITT_ARCH_ARM
-#  define ITT_ARCH_ARM  4
+#define ITT_ARCH_ARM 4
 #endif /* ITT_ARCH_ARM */
 
 #ifndef ITT_ARCH_PPC64
-#  define ITT_ARCH_PPC64  5
+#define ITT_ARCH_PPC64 5
 #endif /* ITT_ARCH_PPC64 */
 
 #ifndef ITT_ARCH_MIPS
-#  define ITT_ARCH_MIPS  6
+#define ITT_ARCH_MIPS 6
 #endif /* ITT_ARCH_MIPS */
 
 #ifndef ITT_ARCH_MIPS64
-#  define ITT_ARCH_MIPS64  6
+#define ITT_ARCH_MIPS64 6
 #endif /* ITT_ARCH_MIPS64 */
 
 #ifndef ITT_ARCH_RISCV64
-#  define ITT_ARCH_RISCV64  7
+#define ITT_ARCH_RISCV64 7
 #endif /* ITT_ARCH_RISCV64 */
 
 #ifndef ITT_ARCH
-#  if defined _M_IX86 || defined __i386__
-#    define ITT_ARCH ITT_ARCH_IA32
-#  elif defined _M_X64 || defined _M_AMD64 || defined __x86_64__
-#    define ITT_ARCH ITT_ARCH_IA32E
-#  elif defined _M_IA64 || defined __ia64__
-#    define ITT_ARCH ITT_ARCH_IA64
-#  elif defined _M_ARM || defined __arm__
-#    define ITT_ARCH ITT_ARCH_ARM
-#  elif defined __powerpc64__
-#    define ITT_ARCH ITT_ARCH_PPC64
-#  elif defined __aarch64__
-#    define ITT_ARCH ITT_ARCH_AARCH64
-#  elif defined __mips__ && !defined __mips64
-#    define ITT_ARCH ITT_ARCH_MIPS
-#  elif defined __mips__ && defined __mips64
-#    define ITT_ARCH ITT_ARCH_MIPS64
-#  elif defined __riscv && __riscv_xlen == 64
-#    define ITT_ARCH ITT_ARCH_RISCV64
-#  endif
+#if defined _M_IX86 || defined __i386__
+#define ITT_ARCH ITT_ARCH_IA32
+#elif defined _M_X64 || defined _M_AMD64 || defined __x86_64__
+#define ITT_ARCH ITT_ARCH_IA32E
+#elif defined _M_IA64 || defined __ia64__
+#define ITT_ARCH ITT_ARCH_IA64
+#elif defined _M_ARM || defined __arm__
+#define ITT_ARCH ITT_ARCH_ARM
+#elif defined __powerpc64__
+#define ITT_ARCH ITT_ARCH_PPC64
+#elif defined __aarch64__
+#define ITT_ARCH ITT_ARCH_AARCH64
+#elif defined __mips__ && !defined __mips64
+#define ITT_ARCH ITT_ARCH_MIPS
+#elif defined __mips__ && defined __mips64
+#define ITT_ARCH ITT_ARCH_MIPS64
+#elif defined __riscv && __riscv_xlen == 64
+#define ITT_ARCH ITT_ARCH_RISCV64
+#endif
 #endif
 
 #ifdef __cplusplus
-#  define ITT_EXTERN_C extern "C"
-#  define ITT_EXTERN_C_BEGIN extern "C" {
-#  define ITT_EXTERN_C_END }
+#define ITT_EXTERN_C extern "C"
+#define ITT_EXTERN_C_BEGIN extern "C" {
+#define ITT_EXTERN_C_END }
 #else
-#  define ITT_EXTERN_C /* nothing */
-#  define ITT_EXTERN_C_BEGIN /* nothing */
-#  define ITT_EXTERN_C_END /* nothing */
+#define ITT_EXTERN_C /* nothing */
+#define ITT_EXTERN_C_BEGIN /* nothing */
+#define ITT_EXTERN_C_END /* nothing */
 #endif /* __cplusplus */
 
 #define ITT_TO_STR_AUX(x) #x
-#define ITT_TO_STR(x)     ITT_TO_STR_AUX(x)
+#define ITT_TO_STR(x) ITT_TO_STR_AUX(x)
 
-#define __ITT_BUILD_ASSERT(expr, suffix) do { \
-    static char __itt_build_check_##suffix[(expr) ? 1 : -1]; \
-    __itt_build_check_##suffix[0] = 0; \
-} while(0)
-#define _ITT_BUILD_ASSERT(expr, suffix)  __ITT_BUILD_ASSERT((expr), suffix)
-#define ITT_BUILD_ASSERT(expr)           _ITT_BUILD_ASSERT((expr), __LINE__)
+#define __ITT_BUILD_ASSERT(expr, suffix)                                       \
+  do {                                                                         \
+    static char __itt_build_check_##suffix[(expr) ? 1 : -1];                   \
+    __itt_build_check_##suffix[0] = 0;                                         \
+  } while (0)
+#define _ITT_BUILD_ASSERT(expr, suffix) __ITT_BUILD_ASSERT((expr), suffix)
+#define ITT_BUILD_ASSERT(expr) _ITT_BUILD_ASSERT((expr), __LINE__)
 
-#define ITT_MAGIC { 0xED, 0xAB, 0xAB, 0xEC, 0x0D, 0xEE, 0xDA, 0x30 }
+#define ITT_MAGIC                                                              \
+  { 0xED, 0xAB, 0xAB, 0xEC, 0x0D, 0xEE, 0xDA, 0x30 }
 
 /* Replace with snapshot date YYYYMMDD for promotion build. */
-#define API_VERSION_BUILD    20151119
+#define API_VERSION_BUILD 20151119
 
 #ifndef API_VERSION_NUM
 #define API_VERSION_NUM 0.0.0
 #endif /* API_VERSION_NUM */
 
-#define API_VERSION "ITT-API-Version " ITT_TO_STR(API_VERSION_NUM) \
-                                " (" ITT_TO_STR(API_VERSION_BUILD) ")"
+#define API_VERSION                                                            \
+  "ITT-API-Version " ITT_TO_STR(API_VERSION_NUM) " (" ITT_TO_STR(              \
+      API_VERSION_BUILD) ")"
 
 /* OS communication functions */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #include <windows.h>
-typedef HMODULE           lib_t;
-typedef DWORD             TIDT;
-typedef CRITICAL_SECTION  mutex_t;
-#define MUTEX_INITIALIZER { 0 }
+typedef HMODULE lib_t;
+typedef DWORD TIDT;
+typedef CRITICAL_SECTION mutex_t;
+#define MUTEX_INITIALIZER                                                      \
+  { 0 }
 #define strong_alias(name, aliasname) /* empty for Windows */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #include <dlfcn.h>
 #if defined(UNICODE) || defined(_UNICODE)
 #include <wchar.h>
 #endif /* UNICODE */
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE 1 /* need for PTHREAD_MUTEX_RECURSIVE */
 #endif /* _GNU_SOURCE */
 #ifndef __USE_UNIX98
-#define __USE_UNIX98 1 /* need for PTHREAD_MUTEX_RECURSIVE, on SLES11.1 with gcc 4.3.4 wherein pthread.h missing dependency on __USE_XOPEN2K8 */
+#define __USE_UNIX98                                                           \
+  1 /* need for PTHREAD_MUTEX_RECURSIVE, on SLES11.1 with gcc 4.3.4 wherein    \
+       pthread.h missing dependency on __USE_XOPEN2K8 */
 #endif /*__USE_UNIX98*/
 #include <pthread.h>
-typedef void*             lib_t;
-typedef pthread_t         TIDT;
-typedef pthread_mutex_t   mutex_t;
+typedef void *lib_t;
+typedef pthread_t TIDT;
+typedef pthread_mutex_t mutex_t;
 #define MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
-#define _strong_alias(name, aliasname) \
-            extern __typeof (name) aliasname __attribute__ ((alias (#name)));
+#define _strong_alias(name, aliasname)                                         \
+  extern __typeof(name) aliasname __attribute__((alias(#name)));
 #define strong_alias(name, aliasname) _strong_alias(name, aliasname)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_get_proc(lib, name) GetProcAddress(lib, name)
-#define __itt_mutex_init(mutex)   InitializeCriticalSection(mutex)
-#define __itt_mutex_lock(mutex)   EnterCriticalSection(mutex)
+#define __itt_mutex_init(mutex) InitializeCriticalSection(mutex)
+#define __itt_mutex_lock(mutex) EnterCriticalSection(mutex)
 #define __itt_mutex_unlock(mutex) LeaveCriticalSection(mutex)
-#define __itt_load_lib(name)      LoadLibraryA(name)
-#define __itt_unload_lib(handle)  FreeLibrary(handle)
-#define __itt_system_error()      (int)GetLastError()
-#define __itt_fstrcmp(s1, s2)     lstrcmpA(s1, s2)
-#define __itt_fstrnlen(s, l)      strnlen_s(s, l)
+#define __itt_load_lib(name) LoadLibraryA(name)
+#define __itt_unload_lib(handle) FreeLibrary(handle)
+#define __itt_system_error() (int)GetLastError()
+#define __itt_fstrcmp(s1, s2) lstrcmpA(s1, s2)
+#define __itt_fstrnlen(s, l) strnlen_s(s, l)
 #define __itt_fstrcpyn(s1, b, s2, l) strncpy_s(s1, b, s2, l)
-#define __itt_fstrdup(s)          _strdup(s)
-#define __itt_thread_id()         GetCurrentThreadId()
-#define __itt_thread_yield()      SwitchToThread()
+#define __itt_fstrdup(s) _strdup(s)
+#define __itt_thread_id() GetCurrentThreadId()
+#define __itt_thread_yield() SwitchToThread()
 #ifndef ITT_SIMPLE_INIT
 ITT_INLINE long
-__itt_interlocked_increment(volatile long* ptr) ITT_INLINE_ATTRIBUTE;
-ITT_INLINE long __itt_interlocked_increment(volatile long* ptr)
-{
-    return InterlockedIncrement(ptr);
+__itt_interlocked_increment(volatile long *ptr) ITT_INLINE_ATTRIBUTE;
+ITT_INLINE long __itt_interlocked_increment(volatile long *ptr) {
 }
 #endif /* ITT_SIMPLE_INIT */
 
 #define DL_SYMBOLS (1)
 #define PTHREAD_SYMBOLS (1)
 
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
 #define __itt_get_proc(lib, name) dlsym(lib, name)
-#define __itt_mutex_init(mutex)   {\
-    pthread_mutexattr_t mutex_attr;                                         \
-    int error_code = pthread_mutexattr_init(&mutex_attr);                   \
-    if (error_code)                                                         \
-        __itt_report_error(__itt_error_system, "pthread_mutexattr_init",    \
-                           error_code);                                     \
-    error_code = pthread_mutexattr_settype(&mutex_attr,                     \
-                                           PTHREAD_MUTEX_RECURSIVE);        \
-    if (error_code)                                                         \
-        __itt_report_error(__itt_error_system, "pthread_mutexattr_settype", \
-                           error_code);                                     \
-    error_code = pthread_mutex_init(mutex, &mutex_attr);                    \
-    if (error_code)                                                         \
-        __itt_report_error(__itt_error_system, "pthread_mutex_init",        \
-                           error_code);                                     \
-    error_code = pthread_mutexattr_destroy(&mutex_attr);                    \
-    if (error_code)                                                         \
-        __itt_report_error(__itt_error_system, "pthread_mutexattr_destroy", \
-                           error_code);                                     \
+#define __itt_mutex_init(mutex)                                                \
+  {                                                                            \
+    pthread_mutexattr_t mutex_attr;                                            \
+    int error_code = pthread_mutexattr_init(&mutex_attr);                      \
+    if (error_code)                                                            \
+      __itt_report_error(__itt_error_system, "pthread_mutexattr_init",         \
+                         error_code);                                          \
+    error_code =                                                               \
+        pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);       \
+    if (error_code)                                                            \
+      __itt_report_error(__itt_error_system, "pthread_mutexattr_settype",      \
+                         error_code);                                          \
+    error_code = pthread_mutex_init(mutex, &mutex_attr);                       \
+    if (error_code)                                                            \
+      __itt_report_error(__itt_error_system, "pthread_mutex_init",             \
+                         error_code);                                          \
+    error_code = pthread_mutexattr_destroy(&mutex_attr);                       \
+    if (error_code)                                                            \
+      __itt_report_error(__itt_error_system, "pthread_mutexattr_destroy",      \
+                         error_code);                                          \
   }
-#define __itt_mutex_lock(mutex)   pthread_mutex_lock(mutex)
+#define __itt_mutex_lock(mutex) pthread_mutex_lock(mutex)
 #define __itt_mutex_unlock(mutex) pthread_mutex_unlock(mutex)
-#define __itt_load_lib(name)      dlopen(name, RTLD_LAZY)
-#define __itt_unload_lib(handle)  dlclose(handle)
-#define __itt_system_error()      errno
-#define __itt_fstrcmp(s1, s2)     strcmp(s1, s2)
+#define __itt_load_lib(name) dlopen(name, RTLD_LAZY)
+#define __itt_unload_lib(handle) dlclose(handle)
+#define __itt_system_error() errno
+#define __itt_fstrcmp(s1, s2) strcmp(s1, s2)
 
 /* makes customer code define safe APIs for SDL_STRNLEN_S and SDL_STRNCPY_S */
 #ifdef SDL_STRNLEN_S
-#define __itt_fstrnlen(s, l)      SDL_STRNLEN_S(s, l)
+#define __itt_fstrnlen(s, l) SDL_STRNLEN_S(s, l)
 #else
-#define __itt_fstrnlen(s, l)      strlen(s)
+#define __itt_fstrnlen(s, l) strlen(s)
 #endif /* SDL_STRNLEN_S */
 #ifdef SDL_STRNCPY_S
 #define __itt_fstrcpyn(s1, b, s2, l) SDL_STRNCPY_S(s1, b, s2, l)
 #else
 #define __itt_fstrcpyn(s1, b, s2, l) strncpy(s1, s2, l)
 #endif /* SDL_STRNCPY_S */
 
-#define __itt_fstrdup(s)          strdup(s)
-#define __itt_thread_id()         pthread_self()
-#define __itt_thread_yield()      sched_yield()
-#if ITT_ARCH==ITT_ARCH_IA64
+#define __itt_fstrdup(s) strdup(s)
+#define __itt_thread_id() pthread_self()
+#define __itt_thread_yield() sched_yield()
+#if ITT_ARCH == ITT_ARCH_IA64
 #ifdef __INTEL_COMPILER
 #define __TBB_machine_fetchadd4(addr, val) __fetchadd4_acq((void *)addr, val)
-#else  /* __INTEL_COMPILER */
+#else /* __INTEL_COMPILER */
 /* TODO: Add Support for not Intel compilers for IA-64 architecture */
 #endif /* __INTEL_COMPILER */
-#elif ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_IA32E /* ITT_ARCH!=ITT_ARCH_IA64 */
-ITT_INLINE long
-__TBB_machine_fetchadd4(volatile void* ptr, long addend) ITT_INLINE_ATTRIBUTE;
-ITT_INLINE long __TBB_machine_fetchadd4(volatile void* ptr, long addend)
-{
-    long result;
-    __asm__ __volatile__("lock\nxadd %0,%1"
-                          : "=r"(result),"=m"(*(volatile int*)ptr)
-                          : "0"(addend), "m"(*(volatile int*)ptr)
-                          : "memory");
-    return result;
+#elif ITT_ARCH == ITT_ARCH_IA32 ||                                             \
+    ITT_ARCH == ITT_ARCH_IA32E /* ITT_ARCH!=ITT_ARCH_IA64 */
+ITT_INLINE long __TBB_machine_fetchadd4(volatile void *ptr,
+                                        long addend) ITT_INLINE_ATTRIBUTE;
+ITT_INLINE long __TBB_machine_fetchadd4(volatile void *ptr, long addend) {
+                       : "=r"(result), "=m"(*(volatile int *)ptr)
+                       : "0"(addend), "m"(*(volatile int *)ptr)
 }
 #elif ITT_ARCH == ITT_ARCH_ARM || ITT_ARCH == ITT_ARCH_PPC64 ||                \
     ITT_ARCH == ITT_ARCH_AARCH64 || ITT_ARCH == ITT_ARCH_MIPS ||               \
     ITT_ARCH == ITT_ARCH_MIPS64 || ITT_ARCH == ITT_ARCH_RISCV64
 #define __TBB_machine_fetchadd4(addr, val) __sync_fetch_and_add(addr, val)
 #endif /* ITT_ARCH==ITT_ARCH_IA64 */
 #ifndef ITT_SIMPLE_INIT
 ITT_INLINE long
-__itt_interlocked_increment(volatile long* ptr) ITT_INLINE_ATTRIBUTE;
-ITT_INLINE long __itt_interlocked_increment(volatile long* ptr)
-{
-    return __TBB_machine_fetchadd4(ptr, 1) + 1L;
+__itt_interlocked_increment(volatile long *ptr) ITT_INLINE_ATTRIBUTE;
+ITT_INLINE long __itt_interlocked_increment(volatile long *ptr) {
 }
 #endif /* ITT_SIMPLE_INIT */
 
-void* dlopen(const char*, int) __attribute__((weak));
-void* dlsym(void*, const char*) __attribute__((weak));
-int dlclose(void*) __attribute__((weak));
+void *dlopen(const char *, int) __attribute__((weak));
+void *dlsym(void *, const char *) __attribute__((weak));
+int dlclose(void *) __attribute__((weak));
 #define DL_SYMBOLS (dlopen && dlsym && dlclose)
 
-int pthread_mutex_init(pthread_mutex_t*, const pthread_mutexattr_t*) __attribute__((weak));
-int pthread_mutex_lock(pthread_mutex_t*) __attribute__((weak));
-int pthread_mutex_unlock(pthread_mutex_t*) __attribute__((weak));
-int pthread_mutex_destroy(pthread_mutex_t*) __attribute__((weak));
-int pthread_mutexattr_init(pthread_mutexattr_t*) __attribute__((weak));
-int pthread_mutexattr_settype(pthread_mutexattr_t*, int) __attribute__((weak));
-int pthread_mutexattr_destroy(pthread_mutexattr_t*) __attribute__((weak));
+int pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *)
+    __attribute__((weak));
+int pthread_mutex_lock(pthread_mutex_t *) __attribute__((weak));
+int pthread_mutex_unlock(pthread_mutex_t *) __attribute__((weak));
+int pthread_mutex_destroy(pthread_mutex_t *) __attribute__((weak));
+int pthread_mutexattr_init(pthread_mutexattr_t *) __attribute__((weak));
+int pthread_mutexattr_settype(pthread_mutexattr_t *, int) __attribute__((weak));
+int pthread_mutexattr_destroy(pthread_mutexattr_t *) __attribute__((weak));
 pthread_t pthread_self(void) __attribute__((weak));
-#define PTHREAD_SYMBOLS (pthread_mutex_init && pthread_mutex_lock && pthread_mutex_unlock && pthread_mutex_destroy && pthread_mutexattr_init && pthread_mutexattr_settype && pthread_mutexattr_destroy && pthread_self)
+#define PTHREAD_SYMBOLS                                                        \
+  (pthread_mutex_init && pthread_mutex_lock && pthread_mutex_unlock &&         \
+   pthread_mutex_destroy && pthread_mutexattr_init &&                          \
+   pthread_mutexattr_settype && pthread_mutexattr_destroy && pthread_self)
 
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 typedef enum {
-    __itt_collection_normal = 0,
-    __itt_collection_paused = 1
 } __itt_collection_state;
 
 typedef enum {
-    __itt_thread_normal  = 0,
-    __itt_thread_ignored = 1
+  __itt_thread_normal = 0,
 } __itt_thread_state;
 
 #pragma pack(push, 8)
 
-typedef struct ___itt_thread_info
-{
-    const char* nameA; /*!< Copy of original name in ASCII. */
+typedef struct ___itt_thread_info {
+  const char *nameA; /*!< Copy of original name in ASCII. */
 #if defined(UNICODE) || defined(_UNICODE)
-    const wchar_t* nameW; /*!< Copy of original name in UNICODE. */
-#else  /* UNICODE || _UNICODE */
-    void* nameW;
+  const wchar_t *nameW; /*!< Copy of original name in UNICODE. */
+#else /* UNICODE || _UNICODE */
+  void *nameW;
 #endif /* UNICODE || _UNICODE */
-    TIDT               tid;
-    __itt_thread_state state;   /*!< Thread state (paused or normal) */
-    int                extra1;  /*!< Reserved to the runtime */
-    void*              extra2;  /*!< Reserved to the runtime */
-    struct ___itt_thread_info* next;
+  TIDT tid;
+  __itt_thread_state state; /*!< Thread state (paused or normal) */
+  int extra1; /*!< Reserved to the runtime */
+  void *extra2; /*!< Reserved to the runtime */
+  struct ___itt_thread_info *next;
 } __itt_thread_info;
 
 #include "ittnotify_types.h" /* For __itt_group_id definition */
 
-typedef struct ___itt_api_info_20101001
-{
-    const char*    name;
-    void**         func_ptr;
-    void*          init_func;
-    __itt_group_id group;
-}  __itt_api_info_20101001;
+typedef struct ___itt_api_info_20101001 {
+  const char *name;
+  void **func_ptr;
+  void *init_func;
+} __itt_api_info_20101001;
 
-typedef struct ___itt_api_info
-{
-    const char*    name;
-    void**         func_ptr;
-    void*          init_func;
-    void*          null_func;
-    __itt_group_id group;
-}  __itt_api_info;
+typedef struct ___itt_api_info {
+  const char *name;
+  void **func_ptr;
+  void *init_func;
+  void *null_func;
+} __itt_api_info;
 
-typedef struct __itt_counter_info
-{
-    const char* nameA;  /*!< Copy of original name in ASCII. */
+typedef struct __itt_counter_info {
+  const char *nameA; /*!< Copy of original name in ASCII. */
 #if defined(UNICODE) || defined(_UNICODE)
-    const wchar_t* nameW; /*!< Copy of original name in UNICODE. */
-#else  /* UNICODE || _UNICODE */
-    void* nameW;
+  const wchar_t *nameW; /*!< Copy of original name in UNICODE. */
+#else /* UNICODE || _UNICODE */
+  void *nameW;
 #endif /* UNICODE || _UNICODE */
-    const char* domainA;  /*!< Copy of original name in ASCII. */
+  const char *domainA; /*!< Copy of original name in ASCII. */
 #if defined(UNICODE) || defined(_UNICODE)
-    const wchar_t* domainW; /*!< Copy of original name in UNICODE. */
-#else  /* UNICODE || _UNICODE */
-    void* domainW;
+  const wchar_t *domainW; /*!< Copy of original name in UNICODE. */
+#else /* UNICODE || _UNICODE */
+  void *domainW;
 #endif /* UNICODE || _UNICODE */
-    int type;
-    long index;
-    int   extra1; /*!< Reserved to the runtime */
-    void* extra2; /*!< Reserved to the runtime */
-    struct __itt_counter_info* next;
-}  __itt_counter_info_t;
+  int extra1; /*!< Reserved to the runtime */
+  void *extra2; /*!< Reserved to the runtime */
+  struct __itt_counter_info *next;
+} __itt_counter_info_t;
 
 struct ___itt_domain;
 struct ___itt_string_handle;
 
-typedef struct ___itt_global
-{
-    unsigned char          magic[8];
-    unsigned long          version_major;
-    unsigned long          version_minor;
-    unsigned long          version_build;
-    volatile long          api_initialized;
-    volatile long          mutex_initialized;
-    volatile long          atomic_counter;
-    mutex_t                mutex;
-    lib_t                  lib;
-    void*                  error_handler;
-    const char**           dll_path_ptr;
-    __itt_api_info*        api_list_ptr;
-    struct ___itt_global*  next;
-    /* Joinable structures below */
-    __itt_thread_info*     thread_list;
-    struct ___itt_domain*  domain_list;
-    struct ___itt_string_handle* string_list;
-    __itt_collection_state state;
-    __itt_counter_info_t* counter_list;
+typedef struct ___itt_global {
+  unsigned char magic[8];
+  unsigned long version_major;
+  unsigned long version_minor;
+  unsigned long version_build;
+  volatile long api_initialized;
+  volatile long mutex_initialized;
+  volatile long atomic_counter;
+  mutex_t mutex;
+  lib_t lib;
+  void *error_handler;
+  const char **dll_path_ptr;
+  __itt_api_info *api_list_ptr;
+  struct ___itt_global *next;
+  __itt_thread_info *thread_list;
+  struct ___itt_domain *domain_list;
+  struct ___itt_string_handle *string_list;
+  __itt_counter_info_t *counter_list;
 } __itt_global;
 
 #pragma pack(pop)
 
-#define NEW_THREAD_INFO_W(gptr,h,h_tail,t,s,n) { \
-    h = (__itt_thread_info*)malloc(sizeof(__itt_thread_info)); \
-    if (h != NULL) { \
-        h->tid    = t; \
-        h->nameA  = NULL; \
-        h->nameW  = n ? _wcsdup(n) : NULL; \
-        h->state  = s; \
-        h->extra1 = 0;    /* reserved */ \
-        h->extra2 = NULL; /* reserved */ \
-        h->next   = NULL; \
-        if (h_tail == NULL) \
-            (gptr)->thread_list = h; \
-        else \
-            h_tail->next = h; \
-    } \
+#define NEW_THREAD_INFO_W(gptr, h, h_tail, t, s, n)                            \
+  {                                                                            \
+    h = (__itt_thread_info *)malloc(sizeof(__itt_thread_info));                \
+    if (h != NULL) {                                                           \
+      h->tid = t;                                                              \
+      h->nameA = NULL;                                                         \
+      h->nameW = n ? _wcsdup(n) : NULL;                                        \
+      h->state = s;                                                            \
+      h->extra1 = 0; /* reserved */                                            \
+      h->extra2 = NULL; /* reserved */                                         \
+      h->next = NULL;                                                          \
+      if (h_tail == NULL)                                                      \
+        (gptr)->thread_list = h;                                               \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
   }
 
-#define NEW_THREAD_INFO_A(gptr,h,h_tail,t,s,n) { \
-    h = (__itt_thread_info*)malloc(sizeof(__itt_thread_info)); \
-    if (h != NULL) { \
-        h->tid    = t; \
-        h->nameA  = n ? __itt_fstrdup(n) : NULL; \
-        h->nameW  = NULL; \
-        h->state  = s; \
-        h->extra1 = 0;    /* reserved */ \
-        h->extra2 = NULL; /* reserved */ \
-        h->next   = NULL; \
-        if (h_tail == NULL) \
-            (gptr)->thread_list = h; \
-        else \
-            h_tail->next = h; \
-    } \
+#define NEW_THREAD_INFO_A(gptr, h, h_tail, t, s, n)                            \
+  {                                                                            \
+    h = (__itt_thread_info *)malloc(sizeof(__itt_thread_info));                \
+    if (h != NULL) {                                                           \
+      h->tid = t;                                                              \
+      h->nameA = n ? __itt_fstrdup(n) : NULL;                                  \
+      h->nameW = NULL;                                                         \
+      h->state = s;                                                            \
+      h->extra1 = 0; /* reserved */                                            \
+      h->extra2 = NULL; /* reserved */                                         \
+      h->next = NULL;                                                          \
+      if (h_tail == NULL)                                                      \
+        (gptr)->thread_list = h;                                               \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
   }
 
-#define NEW_DOMAIN_W(gptr,h,h_tail,name) { \
-    h = (__itt_domain*)malloc(sizeof(__itt_domain)); \
-    if (h != NULL) { \
-        h->flags  = 1;    /* domain is enabled by default */ \
-        h->nameA  = NULL; \
-        h->nameW  = name ? _wcsdup(name) : NULL; \
-        h->extra1 = 0;    /* reserved */ \
-        h->extra2 = NULL; /* reserved */ \
-        h->next   = NULL; \
-        if (h_tail == NULL) \
-            (gptr)->domain_list = h; \
-        else \
-            h_tail->next = h; \
-    } \
+#define NEW_DOMAIN_W(gptr, h, h_tail, name)                                    \
+  {                                                                            \
+    h = (__itt_domain *)malloc(sizeof(__itt_domain));                          \
+    if (h != NULL) {                                                           \
+      h->flags = 1; /* domain is enabled by default */                         \
+      h->nameA = NULL;                                                         \
+      h->nameW = name ? _wcsdup(name) : NULL;                                  \
+      h->extra1 = 0; /* reserved */                                            \
+      h->extra2 = NULL; /* reserved */                                         \
+      h->next = NULL;                                                          \
+      if (h_tail == NULL)                                                      \
+        (gptr)->domain_list = h;                                               \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
   }
 
-#define NEW_DOMAIN_A(gptr,h,h_tail,name) { \
-    h = (__itt_domain*)malloc(sizeof(__itt_domain)); \
-    if (h != NULL) { \
-        h->flags  = 1;    /* domain is enabled by default */ \
-        h->nameA  = name ? __itt_fstrdup(name) : NULL; \
-        h->nameW  = NULL; \
-        h->extra1 = 0;    /* reserved */ \
-        h->extra2 = NULL; /* reserved */ \
-        h->next   = NULL; \
-        if (h_tail == NULL) \
-            (gptr)->domain_list = h; \
-        else \
-            h_tail->next = h; \
-    } \
+#define NEW_DOMAIN_A(gptr, h, h_tail, name)                                    \
+  {                                                                            \
+    h = (__itt_domain *)malloc(sizeof(__itt_domain));                          \
+    if (h != NULL) {                                                           \
+      h->flags = 1; /* domain is enabled by default */                         \
+      h->nameA = name ? __itt_fstrdup(name) : NULL;                            \
+      h->nameW = NULL;                                                         \
+      h->extra1 = 0; /* reserved */                                            \
+      h->extra2 = NULL; /* reserved */                                         \
+      h->next = NULL;                                                          \
+      if (h_tail == NULL)                                                      \
+        (gptr)->domain_list = h;                                               \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
   }
 
-#define NEW_STRING_HANDLE_W(gptr,h,h_tail,name) { \
-    h = (__itt_string_handle*)malloc(sizeof(__itt_string_handle)); \
-    if (h != NULL) { \
-        h->strA   = NULL; \
-        h->strW   = name ? _wcsdup(name) : NULL; \
-        h->extra1 = 0;    /* reserved */ \
-        h->extra2 = NULL; /* reserved */ \
-        h->next   = NULL; \
-        if (h_tail == NULL) \
-            (gptr)->string_list = h; \
-        else \
-            h_tail->next = h; \
-    } \
+#define NEW_STRING_HANDLE_W(gptr, h, h_tail, name)                             \
+  {                                                                            \
+    h = (__itt_string_handle *)malloc(sizeof(__itt_string_handle));            \
+    if (h != NULL) {                                                           \
+      h->strA = NULL;                                                          \
+      h->strW = name ? _wcsdup(name) : NULL;                                   \
+      h->extra1 = 0; /* reserved */                                            \
+      h->extra2 = NULL; /* reserved */                                         \
+      h->next = NULL;                                                          \
+      if (h_tail == NULL)                                                      \
+        (gptr)->string_list = h;                                               \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
   }
 
-#define NEW_STRING_HANDLE_A(gptr,h,h_tail,name) { \
-    h = (__itt_string_handle*)malloc(sizeof(__itt_string_handle)); \
-    if (h != NULL) { \
-        h->strA   = name ? __itt_fstrdup(name) : NULL; \
-        h->strW   = NULL; \
-        h->extra1 = 0;    /* reserved */ \
-        h->extra2 = NULL; /* reserved */ \
-        h->next   = NULL; \
-        if (h_tail == NULL) \
-            (gptr)->string_list = h; \
-        else \
-            h_tail->next = h; \
-    } \
+#define NEW_STRING_HANDLE_A(gptr, h, h_tail, name)                             \
+  {                                                                            \
+    h = (__itt_string_handle *)malloc(sizeof(__itt_string_handle));            \
+    if (h != NULL) {                                                           \
+      h->strA = name ? __itt_fstrdup(name) : NULL;                             \
+      h->strW = NULL;                                                          \
+      h->extra1 = 0; /* reserved */                                            \
+      h->extra2 = NULL; /* reserved */                                         \
+      h->next = NULL;                                                          \
+      if (h_tail == NULL)                                                      \
+        (gptr)->string_list = h;                                               \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
   }
 
-#define NEW_COUNTER_W(gptr,h,h_tail,name,domain,type) { \
-    h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \
-    if (h != NULL) { \
-        h->nameA   = NULL; \
-        h->nameW   = name ? _wcsdup(name) : NULL; \
-        h->domainA   = NULL; \
-        h->domainW   = name ? _wcsdup(domain) : NULL; \
-        h->type = type; \
-        h->index = 0; \
-        h->next   = NULL; \
-        if (h_tail == NULL) \
-            (gptr)->counter_list = h; \
-        else \
-            h_tail->next = h; \
-    } \
+#define NEW_COUNTER_W(gptr, h, h_tail, name, domain, type)                     \
+  {                                                                            \
+    h = (__itt_counter_info_t *)malloc(sizeof(__itt_counter_info_t));          \
+    if (h != NULL) {                                                           \
+      h->nameA = NULL;                                                         \
+      h->nameW = name ? _wcsdup(name) : NULL;                                  \
+      h->domainA = NULL;                                                       \
+      h->domainW = name ? _wcsdup(domain) : NULL;                              \
+      h->type = type;                                                          \
+      h->index = 0;                                                            \
+      h->next = NULL;                                                          \
+      if (h_tail == NULL)                                                      \
+        (gptr)->counter_list = h;                                              \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
   }
 
-#define NEW_COUNTER_A(gptr,h,h_tail,name,domain,type) { \
-    h = (__itt_counter_info_t*)malloc(sizeof(__itt_counter_info_t)); \
-    if (h != NULL) { \
-        h->nameA   = name ? __itt_fstrdup(name) : NULL; \
-        h->nameW   = NULL; \
-        h->domainA   = domain ? __itt_fstrdup(domain) : NULL; \
-        h->domainW   = NULL; \
-        h->type = type; \
-        h->index = 0; \
-        h->next   = NULL; \
-        if (h_tail == NULL) \
-            (gptr)->counter_list = h; \
-        else \
-            h_tail->next = h; \
-    } \
+#define NEW_COUNTER_A(gptr, h, h_tail, name, domain, type)                     \
+  {                                                                            \
+    h = (__itt_counter_info_t *)malloc(sizeof(__itt_counter_info_t));          \
+    if (h != NULL) {                                                           \
+      h->nameA = name ? __itt_fstrdup(name) : NULL;                            \
+      h->nameW = NULL;                                                         \
+      h->domainA = domain ? __itt_fstrdup(domain) : NULL;                      \
+      h->domainW = NULL;                                                       \
+      h->type = type;                                                          \
+      h->index = 0;                                                            \
+      h->next = NULL;                                                          \
+      if (h_tail == NULL)                                                      \
+        (gptr)->counter_list = h;                                              \
+      else                                                                     \
+        h_tail->next = h;                                                      \
+    }                                                                          \
   }
 
 #endif /* _ITTNOTIFY_CONFIG_H_ */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_static.h

 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "ittnotify_config.h"
 
 #ifndef ITT_FORMAT_DEFINED
-#  ifndef ITT_FORMAT
-#    define ITT_FORMAT
-#  endif /* ITT_FORMAT */
-#  ifndef ITT_NO_PARAMS
-#    define ITT_NO_PARAMS
-#  endif /* ITT_NO_PARAMS */
+#ifndef ITT_FORMAT
+#define ITT_FORMAT
+#endif /* ITT_FORMAT */
+#ifndef ITT_NO_PARAMS
+#define ITT_NO_PARAMS
+#endif /* ITT_NO_PARAMS */
 #endif /* ITT_FORMAT_DEFINED */
 
 /*
  * parameters for macro expected:
- * ITT_STUB(api, type, func_name, arguments, params, func_name_in_dll, group, printf_fmt)
+ * ITT_STUB(api, type, func_name, arguments, params, func_name_in_dll, group,
+ * printf_fmt)
  */
 #ifdef __ITT_INTERNAL_INIT
 
 #ifndef __ITT_INTERNAL_BODY
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_domain*, domain_createA, (const char    *name), (ITT_FORMAT name), domain_createA, __itt_group_structure, "\"%s\"")
-ITT_STUB(ITTAPI, __itt_domain*, domain_createW, (const wchar_t *name), (ITT_FORMAT name), domain_createW, __itt_group_structure, "\"%S\"")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_domain*, domain_create,  (const char    *name), (ITT_FORMAT name), domain_create,  __itt_group_structure, "\"%s\"")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_domain *, domain_createA, (const char *name),
+         (ITT_FORMAT name), domain_createA, __itt_group_structure, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_domain *, domain_createW, (const wchar_t *name),
+         (ITT_FORMAT name), domain_createW, __itt_group_structure, "\"%S\"")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_domain *, domain_create, (const char *name),
+         (ITT_FORMAT name), domain_create, __itt_group_structure, "\"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createA, (const char    *name), (ITT_FORMAT name), string_handle_createA, __itt_group_structure, "\"%s\"")
-ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_createW, (const wchar_t *name), (ITT_FORMAT name), string_handle_createW, __itt_group_structure, "\"%S\"")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_string_handle*, string_handle_create,  (const char    *name), (ITT_FORMAT name), string_handle_create,  __itt_group_structure, "\"%s\"")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createA,
+         (const char *name), (ITT_FORMAT name), string_handle_createA,
+         __itt_group_structure, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_createW,
+         (const wchar_t *name), (ITT_FORMAT name), string_handle_createW,
+         __itt_group_structure, "\"%S\"")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_string_handle *, string_handle_create,
+         (const char *name), (ITT_FORMAT name), string_handle_create,
+         __itt_group_structure, "\"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_counter, counter_createA, (const char    *name, const char    *domain), (ITT_FORMAT name, domain), counter_createA, __itt_group_counter, "\"%s\", \"%s\"")
-ITT_STUB(ITTAPI, __itt_counter, counter_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), counter_createW, __itt_group_counter, "\"%s\", \"%s\"")
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_counter, counter_create,  (const char    *name, const char    *domain), (ITT_FORMAT name, domain), counter_create,  __itt_group_counter, "\"%s\", \"%s\"")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_createA,
+         (const char *name, const char *domain), (ITT_FORMAT name, domain),
+         counter_createA, __itt_group_counter, "\"%s\", \"%s\"")
+ITT_STUB(ITTAPI, __itt_counter, counter_createW,
+         (const wchar_t *name, const wchar_t *domain),
+         (ITT_FORMAT name, domain), counter_createW, __itt_group_counter,
+         "\"%s\", \"%s\"")
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create,
+         (const char *name, const char *domain), (ITT_FORMAT name, domain),
+         counter_create, __itt_group_counter, "\"%s\", \"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA, (const char    *name, const char    *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedA, __itt_group_counter, "\"%s\", \"%s\", %d")
-ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW, (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typedW, __itt_group_counter, "\"%s\", \"%s\", %d")
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_counter, counter_create_typed,  (const char    *name, const char    *domain, __itt_metadata_type type), (ITT_FORMAT name, domain, type), counter_create_typed,  __itt_group_counter, "\"%s\", \"%s\", %d")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedA,
+         (const char *name, const char *domain, __itt_metadata_type type),
+         (ITT_FORMAT name, domain, type), counter_create_typedA,
+         __itt_group_counter, "\"%s\", \"%s\", %d")
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typedW,
+         (const wchar_t *name, const wchar_t *domain, __itt_metadata_type type),
+         (ITT_FORMAT name, domain, type), counter_create_typedW,
+         __itt_group_counter, "\"%s\", \"%s\", %d")
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_counter, counter_create_typed,
+         (const char *name, const char *domain, __itt_metadata_type type),
+         (ITT_FORMAT name, domain, type), counter_create_typed,
+         __itt_group_counter, "\"%s\", \"%s\", %d")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-
-ITT_STUBV(ITTAPI, void, pause,  (void), (ITT_NO_PARAMS), pause,  __itt_group_control | __itt_group_legacy, "no args")
-ITT_STUBV(ITTAPI, void, resume, (void), (ITT_NO_PARAMS), resume, __itt_group_control | __itt_group_legacy, "no args")
+ITT_STUBV(ITTAPI, void, pause, (void), (ITT_NO_PARAMS), pause,
+          __itt_group_control | __itt_group_legacy, "no args")
+ITT_STUBV(ITTAPI, void, resume, (void), (ITT_NO_PARAMS), resume,
+          __itt_group_control | __itt_group_legacy, "no args")
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char    *name), (ITT_FORMAT name), thread_set_nameA, __itt_group_thread, "\"%s\"")
-ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name), (ITT_FORMAT name), thread_set_nameW, __itt_group_thread, "\"%S\"")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, thread_set_name,  (const char    *name), (ITT_FORMAT name), thread_set_name,  __itt_group_thread, "\"%s\"")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, thread_set_nameA, (const char *name), (ITT_FORMAT name),
+          thread_set_nameA, __itt_group_thread, "\"%s\"")
+ITT_STUBV(ITTAPI, void, thread_set_nameW, (const wchar_t *name),
+          (ITT_FORMAT name), thread_set_nameW, __itt_group_thread, "\"%S\"")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, thread_set_name, (const char *name), (ITT_FORMAT name),
+          thread_set_name, __itt_group_thread, "\"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, thread_ignore, (void), (ITT_NO_PARAMS), thread_ignore, __itt_group_thread, "no args")
+ITT_STUBV(ITTAPI, void, thread_ignore, (void), (ITT_NO_PARAMS), thread_ignore,
+          __itt_group_thread, "no args")
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(LIBITTAPI, int,  thr_name_setA, (const char    *name, int namelen), (ITT_FORMAT name, namelen), thr_name_setA, __itt_group_thread | __itt_group_legacy, "\"%s\", %d")
-ITT_STUB(LIBITTAPI, int,  thr_name_setW, (const wchar_t *name, int namelen), (ITT_FORMAT name, namelen), thr_name_setW, __itt_group_thread | __itt_group_legacy, "\"%S\", %d")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUB(LIBITTAPI, int,  thr_name_set,  (const char    *name, int namelen), (ITT_FORMAT name, namelen), thr_name_set,  __itt_group_thread | __itt_group_legacy, "\"%s\", %d")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, int, thr_name_setA, (const char *name, int namelen),
+         (ITT_FORMAT name, namelen), thr_name_setA,
+         __itt_group_thread | __itt_group_legacy, "\"%s\", %d")
+ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen),
+         (ITT_FORMAT name, namelen), thr_name_setW,
+         __itt_group_thread | __itt_group_legacy, "\"%S\", %d")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int, thr_name_set, (const char *name, int namelen),
+         (ITT_FORMAT name, namelen), thr_name_set,
+         __itt_group_thread | __itt_group_legacy, "\"%s\", %d")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(LIBITTAPI, void, thr_ignore,   (void),                             (ITT_NO_PARAMS),            thr_ignore,    __itt_group_thread | __itt_group_legacy, "no args")
+ITT_STUBV(LIBITTAPI, void, thr_ignore, (void), (ITT_NO_PARAMS), thr_ignore,
+          __itt_group_thread | __itt_group_legacy, "no args")
 #endif /* __ITT_INTERNAL_BODY */
 
-ITT_STUBV(ITTAPI, void, enable_attach, (void), (ITT_NO_PARAMS), enable_attach, __itt_group_all, "no args")
+ITT_STUBV(ITTAPI, void, enable_attach, (void), (ITT_NO_PARAMS), enable_attach,
+          __itt_group_all, "no args")
 
-#else  /* __ITT_INTERNAL_INIT */
+#else /* __ITT_INTERNAL_INIT */
 
-ITT_STUBV(ITTAPI, void, detach, (void), (ITT_NO_PARAMS), detach, __itt_group_control | __itt_group_legacy, "no args")
-
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, sync_createA, (void *addr, const char    *objtype, const char    *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_createA, __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
-ITT_STUBV(ITTAPI, void, sync_createW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_createW, __itt_group_sync | __itt_group_fsync, "%p, \"%S\", \"%S\", %x")
-ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char    *name), (ITT_FORMAT addr, name), sync_renameA, __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
-ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name), (ITT_FORMAT addr, name), sync_renameW, __itt_group_sync | __itt_group_fsync, "%p, \"%S\"")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, sync_create,  (void *addr, const char    *objtype, const char    *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_create,  __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
-ITT_STUBV(ITTAPI, void, sync_rename,  (void *addr, const char    *name), (ITT_FORMAT addr, name), sync_rename,  __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, sync_destroy,    (void *addr), (ITT_FORMAT addr), sync_destroy,   __itt_group_sync | __itt_group_fsync, "%p")
-
-ITT_STUBV(ITTAPI, void, sync_prepare,    (void* addr), (ITT_FORMAT addr), sync_prepare,   __itt_group_sync,  "%p")
-ITT_STUBV(ITTAPI, void, sync_cancel,     (void *addr), (ITT_FORMAT addr), sync_cancel,    __itt_group_sync,  "%p")
-ITT_STUBV(ITTAPI, void, sync_acquired,   (void *addr), (ITT_FORMAT addr), sync_acquired,  __itt_group_sync,  "%p")
-ITT_STUBV(ITTAPI, void, sync_releasing,  (void* addr), (ITT_FORMAT addr), sync_releasing, __itt_group_sync,  "%p")
-
-ITT_STUBV(ITTAPI, void, suppress_push,       (unsigned int mask),                             (ITT_FORMAT mask), suppress_push,  __itt_group_suppress,  "%p")
-ITT_STUBV(ITTAPI, void, suppress_pop,        (void),                                          (ITT_NO_PARAMS),   suppress_pop,   __itt_group_suppress,  "no args")
-ITT_STUBV(ITTAPI, void, suppress_mark_range, (__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size),(ITT_FORMAT mode, mask, address, size), suppress_mark_range, __itt_group_suppress, "%d, %p, %p, %d")
-ITT_STUBV(ITTAPI, void, suppress_clear_range,(__itt_suppress_mode_t mode, unsigned int mask, void * address, size_t size),(ITT_FORMAT mode, mask, address, size), suppress_clear_range,__itt_group_suppress, "%d, %p, %p, %d")
-
-ITT_STUBV(ITTAPI, void, fsync_prepare,   (void* addr), (ITT_FORMAT addr), sync_prepare,   __itt_group_fsync, "%p")
-ITT_STUBV(ITTAPI, void, fsync_cancel,    (void *addr), (ITT_FORMAT addr), sync_cancel,    __itt_group_fsync, "%p")
-ITT_STUBV(ITTAPI, void, fsync_acquired,  (void *addr), (ITT_FORMAT addr), sync_acquired,  __itt_group_fsync, "%p")
-ITT_STUBV(ITTAPI, void, fsync_releasing, (void* addr), (ITT_FORMAT addr), sync_releasing, __itt_group_fsync, "%p")
-
-ITT_STUBV(ITTAPI, void, model_site_begin,          (__itt_model_site *site, __itt_model_site_instance *instance, const char *name), (ITT_FORMAT site, instance, name), model_site_begin, __itt_group_model, "%p, %p, \"%s\"")
-ITT_STUBV(ITTAPI, void, model_site_end,            (__itt_model_site *site, __itt_model_site_instance *instance),                   (ITT_FORMAT site, instance),       model_site_end,   __itt_group_model, "%p, %p")
-ITT_STUBV(ITTAPI, void, model_task_begin,          (__itt_model_task *task, __itt_model_task_instance *instance, const char *name), (ITT_FORMAT task, instance, name), model_task_begin, __itt_group_model, "%p, %p, \"%s\"")
-ITT_STUBV(ITTAPI, void, model_task_end,            (__itt_model_task *task, __itt_model_task_instance *instance),                   (ITT_FORMAT task, instance),       model_task_end,   __itt_group_model, "%p, %p")
-ITT_STUBV(ITTAPI, void, model_lock_acquire,        (void *lock), (ITT_FORMAT lock), model_lock_acquire, __itt_group_model, "%p")
-ITT_STUBV(ITTAPI, void, model_lock_release,        (void *lock), (ITT_FORMAT lock), model_lock_release, __itt_group_model, "%p")
-ITT_STUBV(ITTAPI, void, model_record_allocation,   (void *addr, size_t size), (ITT_FORMAT addr, size), model_record_allocation,   __itt_group_model, "%p, %d")
-ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr),              (ITT_FORMAT addr),       model_record_deallocation, __itt_group_model, "%p")
-ITT_STUBV(ITTAPI, void, model_induction_uses,      (void* addr, size_t size), (ITT_FORMAT addr, size), model_induction_uses,      __itt_group_model, "%p, %d")
-ITT_STUBV(ITTAPI, void, model_reduction_uses,      (void* addr, size_t size), (ITT_FORMAT addr, size), model_reduction_uses,      __itt_group_model, "%p, %d")
-ITT_STUBV(ITTAPI, void, model_observe_uses,        (void* addr, size_t size), (ITT_FORMAT addr, size), model_observe_uses,        __itt_group_model, "%p, %d")
-ITT_STUBV(ITTAPI, void, model_clear_uses,          (void* addr),              (ITT_FORMAT addr),       model_clear_uses,          __itt_group_model, "%p")
-
-#ifndef __ITT_INTERNAL_BODY
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, model_site_beginW,         (const wchar_t *name),     (ITT_FORMAT name),       model_site_beginW,         __itt_group_model, "\"%s\"")
-ITT_STUBV(ITTAPI, void, model_task_beginW,         (const wchar_t *name),     (ITT_FORMAT name),       model_task_beginW,         __itt_group_model, "\"%s\"")
-ITT_STUBV(ITTAPI, void, model_iteration_taskW,     (const wchar_t *name),     (ITT_FORMAT name),       model_iteration_taskW,     __itt_group_model, "\"%s\"")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, model_site_beginA,         (const char *name),        (ITT_FORMAT name),       model_site_beginA,         __itt_group_model, "\"%s\"")
-ITT_STUBV(ITTAPI, void, model_site_beginAL,        (const char *name, size_t len), (ITT_FORMAT name, len), model_site_beginAL,    __itt_group_model, "\"%s\", %d")
-ITT_STUBV(ITTAPI, void, model_task_beginA,         (const char *name),        (ITT_FORMAT name),       model_task_beginA,         __itt_group_model, "\"%s\"")
-ITT_STUBV(ITTAPI, void, model_task_beginAL,        (const char *name, size_t len), (ITT_FORMAT name, len), model_task_beginAL,    __itt_group_model, "\"%s\", %d")
-ITT_STUBV(ITTAPI, void, model_iteration_taskA,     (const char *name),        (ITT_FORMAT name),       model_iteration_taskA,     __itt_group_model, "\"%s\"")
-ITT_STUBV(ITTAPI, void, model_iteration_taskAL,    (const char *name, size_t len), (ITT_FORMAT name, len), model_iteration_taskAL, __itt_group_model, "\"%s\", %d")
-ITT_STUBV(ITTAPI, void, model_site_end_2,          (void),                    (ITT_NO_PARAMS),         model_site_end_2,          __itt_group_model, "no args")
-ITT_STUBV(ITTAPI, void, model_task_end_2,          (void),                    (ITT_NO_PARAMS),         model_task_end_2,          __itt_group_model, "no args")
-ITT_STUBV(ITTAPI, void, model_lock_acquire_2,      (void *lock),              (ITT_FORMAT lock),       model_lock_acquire_2,      __itt_group_model, "%p")
-ITT_STUBV(ITTAPI, void, model_lock_release_2,      (void *lock),              (ITT_FORMAT lock),       model_lock_release_2,      __itt_group_model, "%p")
-ITT_STUBV(ITTAPI, void, model_aggregate_task,      (size_t count),            (ITT_FORMAT count),      model_aggregate_task,      __itt_group_model, "%d")
-ITT_STUBV(ITTAPI, void, model_disable_push,        (__itt_model_disable x),   (ITT_FORMAT x),          model_disable_push,        __itt_group_model, "%p")
-ITT_STUBV(ITTAPI, void, model_disable_pop,         (void),                    (ITT_NO_PARAMS),         model_disable_pop,         __itt_group_model, "no args")
-#endif /* __ITT_INTERNAL_BODY */
+ITT_STUBV(ITTAPI, void, detach, (void), (ITT_NO_PARAMS), detach,
+          __itt_group_control | __itt_group_legacy, "no args")
 
-#ifndef __ITT_INTERNAL_BODY
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA, (const char    *name, const char    *domain), (ITT_FORMAT name, domain), heap_function_createA, __itt_group_heap, "\"%s\", \"%s\"")
-ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW, (const wchar_t *name, const wchar_t *domain), (ITT_FORMAT name, domain), heap_function_createW, __itt_group_heap, "\"%s\", \"%s\"")
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create,  (const char    *name, const char    *domain), (ITT_FORMAT name, domain), heap_function_create,  __itt_group_heap, "\"%s\", \"%s\"")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#endif /* __ITT_INTERNAL_BODY */
-ITT_STUBV(ITTAPI, void, heap_allocate_begin,   (__itt_heap_function h, size_t size, int initialized),             (ITT_FORMAT h, size, initialized),       heap_allocate_begin, __itt_group_heap, "%p, %lu, %d")
-ITT_STUBV(ITTAPI, void, heap_allocate_end,     (__itt_heap_function h, void** addr, size_t size, int initialized), (ITT_FORMAT h, addr, size, initialized), heap_allocate_end,   __itt_group_heap, "%p, %p, %lu, %d")
-ITT_STUBV(ITTAPI, void, heap_free_begin,       (__itt_heap_function h, void*  addr), (ITT_FORMAT h, addr), heap_free_begin, __itt_group_heap, "%p, %p")
-ITT_STUBV(ITTAPI, void, heap_free_end,         (__itt_heap_function h, void*  addr), (ITT_FORMAT h, addr), heap_free_end,   __itt_group_heap, "%p, %p")
-ITT_STUBV(ITTAPI, void, heap_reallocate_begin, (__itt_heap_function h, void*  addr, size_t new_size, int initialized),                  (ITT_FORMAT h, addr, new_size, initialized),           heap_reallocate_begin, __itt_group_heap, "%p, %p, %lu, %d")
-ITT_STUBV(ITTAPI, void, heap_reallocate_end,   (__itt_heap_function h, void*  addr, void** new_addr, size_t new_size, int initialized), (ITT_FORMAT h, addr, new_addr, new_size, initialized), heap_reallocate_end,   __itt_group_heap, "%p, %p, %p, %lu, %d")
-ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void), (ITT_NO_PARAMS), heap_internal_access_begin, __itt_group_heap, "no args")
-ITT_STUBV(ITTAPI, void, heap_internal_access_end,   (void), (ITT_NO_PARAMS), heap_internal_access_end,   __itt_group_heap, "no args")
-ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void), (ITT_NO_PARAMS), heap_record_memory_growth_begin, __itt_group_heap, "no args")
-ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end,   (void), (ITT_NO_PARAMS), heap_record_memory_growth_end,   __itt_group_heap, "no args")
-ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask),  (ITT_FORMAT reset_mask), heap_reset_detection, __itt_group_heap, "%u")
-ITT_STUBV(ITTAPI, void, heap_record,          (unsigned int record_mask), (ITT_FORMAT record_mask),  heap_record,        __itt_group_heap, "%u")
-
-ITT_STUBV(ITTAPI, void, id_create,  (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), id_create,  __itt_group_structure, "%p, %lu")
-ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id), id_destroy, __itt_group_structure, "%p, %lu")
-
-ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void), (ITT_NO_PARAMS), get_timestamp,  __itt_group_structure, "no args")
-
-ITT_STUBV(ITTAPI, void, region_begin, (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), region_begin, __itt_group_structure, "%p, %lu, %lu, %p")
-ITT_STUBV(ITTAPI, void, region_end,   (const __itt_domain *domain, __itt_id id),                                             (ITT_FORMAT domain, id),               region_end,   __itt_group_structure, "%p, %lu")
-
-#ifndef __ITT_INTERNAL_BODY
-ITT_STUBV(ITTAPI, void, frame_begin_v3,  (const __itt_domain *domain, __itt_id *id),                                             (ITT_FORMAT domain, id),             frame_begin_v3,  __itt_group_structure, "%p, %p")
-ITT_STUBV(ITTAPI, void, frame_end_v3,    (const __itt_domain *domain, __itt_id *id),                                             (ITT_FORMAT domain, id),             frame_end_v3,    __itt_group_structure, "%p, %p")
-ITT_STUBV(ITTAPI, void, frame_submit_v3, (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin, __itt_timestamp end), (ITT_FORMAT domain, id, begin, end), frame_submit_v3, __itt_group_structure, "%p, %p, %lu, %lu")
-#endif /* __ITT_INTERNAL_BODY */
-
-ITT_STUBV(ITTAPI, void, task_group,   (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_group,  __itt_group_structure, "%p, %lu, %lu, %p")
-
-ITT_STUBV(ITTAPI, void, task_begin,    (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name), (ITT_FORMAT domain, id, parent, name), task_begin,    __itt_group_structure, "%p, %lu, %lu, %p")
-ITT_STUBV(ITTAPI, void, task_begin_fn, (const __itt_domain *domain, __itt_id id, __itt_id parent, void* fn),                  (ITT_FORMAT domain, id, parent, fn),   task_begin_fn, __itt_group_structure, "%p, %lu, %lu, %p")
-ITT_STUBV(ITTAPI, void, task_end,      (const __itt_domain *domain),                                                          (ITT_FORMAT domain),                   task_end,      __itt_group_structure, "%p")
-
-ITT_STUBV(ITTAPI, void, counter_inc_v3,       (const __itt_domain *domain, __itt_string_handle *name),                           (ITT_FORMAT domain, name),        counter_inc_v3,       __itt_group_structure, "%p, %p")
-ITT_STUBV(ITTAPI, void, counter_inc_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_inc_delta_v3, __itt_group_structure, "%p, %p, %lu")
-ITT_STUBV(ITTAPI, void, counter_dec_v3,       (const __itt_domain *domain, __itt_string_handle *name),                           (ITT_FORMAT domain, name),        counter_dec_v3,       __itt_group_structure, "%p, %p")
-ITT_STUBV(ITTAPI, void, counter_dec_delta_v3, (const __itt_domain *domain, __itt_string_handle *name, unsigned long long value), (ITT_FORMAT domain, name, value), counter_dec_delta_v3, __itt_group_structure, "%p, %p, %lu")
-
-ITT_STUBV(ITTAPI, void, marker, (const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope), (ITT_FORMAT domain, id, name, scope), marker, __itt_group_structure, "%p, %lu, %p, %d")
-
-ITT_STUBV(ITTAPI, void, metadata_add,      (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data), (ITT_FORMAT domain, id, key, type, count, data), metadata_add, __itt_group_structure, "%p, %lu, %p, %d, %lu, %p")
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, metadata_str_addA, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char* data, size_t length),    (ITT_FORMAT domain, id, key, data, length), metadata_str_addA, __itt_group_structure, "%p, %lu, %p, %p, %lu")
-ITT_STUBV(ITTAPI, void, metadata_str_addW, (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t* data, size_t length), (ITT_FORMAT domain, id, key, data, length), metadata_str_addW, __itt_group_structure, "%p, %lu, %p, %p, %lu")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, metadata_str_add,  (const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char* data, size_t length),    (ITT_FORMAT domain, id, key, data, length), metadata_str_add,  __itt_group_structure, "%p, %lu, %p, %p, %lu")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-
-ITT_STUBV(ITTAPI, void, relation_add_to_current, (const __itt_domain *domain, __itt_relation relation, __itt_id tail),                (ITT_FORMAT domain, relation, tail),       relation_add_to_current, __itt_group_structure, "%p, %lu, %p")
-ITT_STUBV(ITTAPI, void, relation_add,            (const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, head, relation, tail), relation_add,            __itt_group_structure, "%p, %p, %lu, %p")
-
-#ifndef __ITT_INTERNAL_BODY
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char    *name, int namelen), (ITT_FORMAT name, namelen), event_createA, __itt_group_mark | __itt_group_legacy, "\"%s\", %d")
-ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen), (ITT_FORMAT name, namelen), event_createW, __itt_group_mark | __itt_group_legacy, "\"%S\", %d")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUB(LIBITTAPI, __itt_event, event_create,  (const char    *name, int namelen), (ITT_FORMAT name, namelen), event_create,  __itt_group_mark | __itt_group_legacy, "\"%s\", %d")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(LIBITTAPI, int,  event_start,          (__itt_event event),                (ITT_FORMAT event),         event_start,   __itt_group_mark | __itt_group_legacy, "%d")
-ITT_STUB(LIBITTAPI, int,  event_end,            (__itt_event event),                (ITT_FORMAT event),         event_end,     __itt_group_mark | __itt_group_legacy, "%d")
-#endif /* __ITT_INTERNAL_BODY */
-
-#ifndef __ITT_INTERNAL_BODY
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, sync_set_nameA, (void *addr, const char    *objtype, const char    *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameA, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", \"%s\", %x")
-ITT_STUBV(ITTAPI, void, sync_set_nameW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameW, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%S\", \"%S\", %x")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, sync_set_name,  (void *addr, const char    *objtype, const char    *objname, int attribute), (ITT_FORMAT addr, objtype, objname, attribute), sync_set_name,  __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "p, \"%s\", \"%s\", %x")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(LIBITTAPI, int, notify_sync_nameA, (void *p, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_nameA, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", %d, \"%s\", %d, %x")
-ITT_STUB(LIBITTAPI, int, notify_sync_nameW, (void *p, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_nameW, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%S\", %d, \"%S\", %d, %x")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUB(LIBITTAPI, int, notify_sync_name,  (void *p, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute), (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute), notify_sync_name,  __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p, \"%s\", %d, \"%s\", %d, %x")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-
-ITT_STUBV(LIBITTAPI, void, notify_sync_prepare,   (void *p), (ITT_FORMAT p), notify_sync_prepare,   __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
-ITT_STUBV(LIBITTAPI, void, notify_sync_cancel,    (void *p), (ITT_FORMAT p), notify_sync_cancel,    __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
-ITT_STUBV(LIBITTAPI, void, notify_sync_acquired,  (void *p), (ITT_FORMAT p), notify_sync_acquired,  __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
-ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *p), (ITT_FORMAT p), notify_sync_releasing, __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
-#endif /* __ITT_INTERNAL_BODY */
-
-ITT_STUBV(LIBITTAPI, void, memory_read,   (void *addr, size_t size), (ITT_FORMAT addr, size), memory_read,   __itt_group_legacy, "%p, %lu")
-ITT_STUBV(LIBITTAPI, void, memory_write,  (void *addr, size_t size), (ITT_FORMAT addr, size), memory_write,  __itt_group_legacy, "%p, %lu")
-ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size), (ITT_FORMAT addr, size), memory_update, __itt_group_legacy, "%p, %lu")
-
-ITT_STUB(LIBITTAPI, __itt_state_t,     state_get,    (void),                                    (ITT_NO_PARAMS),   state_get,    __itt_group_legacy, "no args")
-ITT_STUB(LIBITTAPI, __itt_state_t,     state_set,    (__itt_state_t s),                         (ITT_FORMAT s),    state_set,    __itt_group_legacy, "%d")
-ITT_STUB(LIBITTAPI, __itt_obj_state_t, obj_mode_set, (__itt_obj_prop_t p, __itt_obj_state_t s), (ITT_FORMAT p, s), obj_mode_set, __itt_group_legacy, "%d, %d")
-ITT_STUB(LIBITTAPI, __itt_thr_state_t, thr_mode_set, (__itt_thr_prop_t p, __itt_thr_state_t s), (ITT_FORMAT p, s), thr_mode_set, __itt_group_legacy, "%d, %d")
-
-#ifndef __ITT_INTERNAL_BODY
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char    *domain), (ITT_FORMAT domain), frame_createA, __itt_group_frame, "\"%s\"")
-ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain), (ITT_FORMAT domain), frame_createW, __itt_group_frame, "\"%s\"")
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_frame, frame_create,  (const char    *domain), (ITT_FORMAT domain), frame_create,  __itt_group_frame, "\"%s\"")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_createA,
+          (void *addr, const char *objtype, const char *objname, int attribute),
+          (ITT_FORMAT addr, objtype, objname, attribute), sync_createA,
+          __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
+ITT_STUBV(ITTAPI, void, sync_createW,
+          (void *addr, const wchar_t *objtype, const wchar_t *objname,
+           int attribute),
+          (ITT_FORMAT addr, objtype, objname, attribute), sync_createW,
+          __itt_group_sync | __itt_group_fsync, "%p, \"%S\", \"%S\", %x")
+ITT_STUBV(ITTAPI, void, sync_renameA, (void *addr, const char *name),
+          (ITT_FORMAT addr, name), sync_renameA,
+          __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
+ITT_STUBV(ITTAPI, void, sync_renameW, (void *addr, const wchar_t *name),
+          (ITT_FORMAT addr, name), sync_renameW,
+          __itt_group_sync | __itt_group_fsync, "%p, \"%S\"")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_create,
+          (void *addr, const char *objtype, const char *objname, int attribute),
+          (ITT_FORMAT addr, objtype, objname, attribute), sync_create,
+          __itt_group_sync | __itt_group_fsync, "%p, \"%s\", \"%s\", %x")
+ITT_STUBV(ITTAPI, void, sync_rename, (void *addr, const char *name),
+          (ITT_FORMAT addr, name), sync_rename,
+          __itt_group_sync | __itt_group_fsync, "%p, \"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_destroy, (void *addr), (ITT_FORMAT addr),
+          sync_destroy, __itt_group_sync | __itt_group_fsync, "%p")
+
+ITT_STUBV(ITTAPI, void, sync_prepare, (void *addr), (ITT_FORMAT addr),
+          sync_prepare, __itt_group_sync, "%p")
+ITT_STUBV(ITTAPI, void, sync_cancel, (void *addr), (ITT_FORMAT addr),
+          sync_cancel, __itt_group_sync, "%p")
+ITT_STUBV(ITTAPI, void, sync_acquired, (void *addr), (ITT_FORMAT addr),
+          sync_acquired, __itt_group_sync, "%p")
+ITT_STUBV(ITTAPI, void, sync_releasing, (void *addr), (ITT_FORMAT addr),
+          sync_releasing, __itt_group_sync, "%p")
+
+ITT_STUBV(ITTAPI, void, suppress_push, (unsigned int mask), (ITT_FORMAT mask),
+          suppress_push, __itt_group_suppress, "%p")
+ITT_STUBV(ITTAPI, void, suppress_pop, (void), (ITT_NO_PARAMS), suppress_pop,
+          __itt_group_suppress, "no args")
+ITT_STUBV(ITTAPI, void, suppress_mark_range,
+          (__itt_suppress_mode_t mode, unsigned int mask, void *address,
+           size_t size),
+          (ITT_FORMAT mode, mask, address, size), suppress_mark_range,
+          __itt_group_suppress, "%d, %p, %p, %d")
+ITT_STUBV(ITTAPI, void, suppress_clear_range,
+          (__itt_suppress_mode_t mode, unsigned int mask, void *address,
+           size_t size),
+          (ITT_FORMAT mode, mask, address, size), suppress_clear_range,
+          __itt_group_suppress, "%d, %p, %p, %d")
+
+ITT_STUBV(ITTAPI, void, fsync_prepare, (void *addr), (ITT_FORMAT addr),
+          sync_prepare, __itt_group_fsync, "%p")
+ITT_STUBV(ITTAPI, void, fsync_cancel, (void *addr), (ITT_FORMAT addr),
+          sync_cancel, __itt_group_fsync, "%p")
+ITT_STUBV(ITTAPI, void, fsync_acquired, (void *addr), (ITT_FORMAT addr),
+          sync_acquired, __itt_group_fsync, "%p")
+ITT_STUBV(ITTAPI, void, fsync_releasing, (void *addr), (ITT_FORMAT addr),
+          sync_releasing, __itt_group_fsync, "%p")
+
+ITT_STUBV(ITTAPI, void, model_site_begin,
+          (__itt_model_site * site, __itt_model_site_instance *instance,
+           const char *name),
+          (ITT_FORMAT site, instance, name), model_site_begin,
+          __itt_group_model, "%p, %p, \"%s\"")
+ITT_STUBV(ITTAPI, void, model_site_end,
+          (__itt_model_site * site, __itt_model_site_instance *instance),
+          (ITT_FORMAT site, instance), model_site_end, __itt_group_model,
+          "%p, %p")
+ITT_STUBV(ITTAPI, void, model_task_begin,
+          (__itt_model_task * task, __itt_model_task_instance *instance,
+           const char *name),
+          (ITT_FORMAT task, instance, name), model_task_begin,
+          __itt_group_model, "%p, %p, \"%s\"")
+ITT_STUBV(ITTAPI, void, model_task_end,
+          (__itt_model_task * task, __itt_model_task_instance *instance),
+          (ITT_FORMAT task, instance), model_task_end, __itt_group_model,
+          "%p, %p")
+ITT_STUBV(ITTAPI, void, model_lock_acquire, (void *lock), (ITT_FORMAT lock),
+          model_lock_acquire, __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_lock_release, (void *lock), (ITT_FORMAT lock),
+          model_lock_release, __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_record_allocation, (void *addr, size_t size),
+          (ITT_FORMAT addr, size), model_record_allocation, __itt_group_model,
+          "%p, %d")
+ITT_STUBV(ITTAPI, void, model_record_deallocation, (void *addr),
+          (ITT_FORMAT addr), model_record_deallocation, __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_induction_uses, (void *addr, size_t size),
+          (ITT_FORMAT addr, size), model_induction_uses, __itt_group_model,
+          "%p, %d")
+ITT_STUBV(ITTAPI, void, model_reduction_uses, (void *addr, size_t size),
+          (ITT_FORMAT addr, size), model_reduction_uses, __itt_group_model,
+          "%p, %d")
+ITT_STUBV(ITTAPI, void, model_observe_uses, (void *addr, size_t size),
+          (ITT_FORMAT addr, size), model_observe_uses, __itt_group_model,
+          "%p, %d")
+ITT_STUBV(ITTAPI, void, model_clear_uses, (void *addr), (ITT_FORMAT addr),
+          model_clear_uses, __itt_group_model, "%p")
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, model_site_beginW, (const wchar_t *name),
+          (ITT_FORMAT name), model_site_beginW, __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_task_beginW, (const wchar_t *name),
+          (ITT_FORMAT name), model_task_beginW, __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_iteration_taskW, (const wchar_t *name),
+          (ITT_FORMAT name), model_iteration_taskW, __itt_group_model, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, model_site_beginA, (const char *name),
+          (ITT_FORMAT name), model_site_beginA, __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_site_beginAL, (const char *name, size_t len),
+          (ITT_FORMAT name, len), model_site_beginAL, __itt_group_model,
+          "\"%s\", %d")
+ITT_STUBV(ITTAPI, void, model_task_beginA, (const char *name),
+          (ITT_FORMAT name), model_task_beginA, __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_task_beginAL, (const char *name, size_t len),
+          (ITT_FORMAT name, len), model_task_beginAL, __itt_group_model,
+          "\"%s\", %d")
+ITT_STUBV(ITTAPI, void, model_iteration_taskA, (const char *name),
+          (ITT_FORMAT name), model_iteration_taskA, __itt_group_model, "\"%s\"")
+ITT_STUBV(ITTAPI, void, model_iteration_taskAL, (const char *name, size_t len),
+          (ITT_FORMAT name, len), model_iteration_taskAL, __itt_group_model,
+          "\"%s\", %d")
+ITT_STUBV(ITTAPI, void, model_site_end_2, (void), (ITT_NO_PARAMS),
+          model_site_end_2, __itt_group_model, "no args")
+ITT_STUBV(ITTAPI, void, model_task_end_2, (void), (ITT_NO_PARAMS),
+          model_task_end_2, __itt_group_model, "no args")
+ITT_STUBV(ITTAPI, void, model_lock_acquire_2, (void *lock), (ITT_FORMAT lock),
+          model_lock_acquire_2, __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_lock_release_2, (void *lock), (ITT_FORMAT lock),
+          model_lock_release_2, __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_aggregate_task, (size_t count),
+          (ITT_FORMAT count), model_aggregate_task, __itt_group_model, "%d")
+ITT_STUBV(ITTAPI, void, model_disable_push, (__itt_model_disable x),
+          (ITT_FORMAT x), model_disable_push, __itt_group_model, "%p")
+ITT_STUBV(ITTAPI, void, model_disable_pop, (void), (ITT_NO_PARAMS),
+          model_disable_pop, __itt_group_model, "no args")
+#endif /* __ITT_INTERNAL_BODY */
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createA,
+         (const char *name, const char *domain), (ITT_FORMAT name, domain),
+         heap_function_createA, __itt_group_heap, "\"%s\", \"%s\"")
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_createW,
+         (const wchar_t *name, const wchar_t *domain),
+         (ITT_FORMAT name, domain), heap_function_createW, __itt_group_heap,
+         "\"%s\", \"%s\"")
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_heap_function, heap_function_create,
+         (const char *name, const char *domain), (ITT_FORMAT name, domain),
+         heap_function_create, __itt_group_heap, "\"%s\", \"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* __ITT_INTERNAL_BODY */
+ITT_STUBV(ITTAPI, void, heap_allocate_begin,
+          (__itt_heap_function h, size_t size, int initialized),
+          (ITT_FORMAT h, size, initialized), heap_allocate_begin,
+          __itt_group_heap, "%p, %lu, %d")
+ITT_STUBV(ITTAPI, void, heap_allocate_end,
+          (__itt_heap_function h, void **addr, size_t size, int initialized),
+          (ITT_FORMAT h, addr, size, initialized), heap_allocate_end,
+          __itt_group_heap, "%p, %p, %lu, %d")
+ITT_STUBV(ITTAPI, void, heap_free_begin, (__itt_heap_function h, void *addr),
+          (ITT_FORMAT h, addr), heap_free_begin, __itt_group_heap, "%p, %p")
+ITT_STUBV(ITTAPI, void, heap_free_end, (__itt_heap_function h, void *addr),
+          (ITT_FORMAT h, addr), heap_free_end, __itt_group_heap, "%p, %p")
+ITT_STUBV(ITTAPI, void, heap_reallocate_begin,
+          (__itt_heap_function h, void *addr, size_t new_size, int initialized),
+          (ITT_FORMAT h, addr, new_size, initialized), heap_reallocate_begin,
+          __itt_group_heap, "%p, %p, %lu, %d")
+ITT_STUBV(ITTAPI, void, heap_reallocate_end,
+          (__itt_heap_function h, void *addr, void **new_addr, size_t new_size,
+           int initialized),
+          (ITT_FORMAT h, addr, new_addr, new_size, initialized),
+          heap_reallocate_end, __itt_group_heap, "%p, %p, %p, %lu, %d")
+ITT_STUBV(ITTAPI, void, heap_internal_access_begin, (void), (ITT_NO_PARAMS),
+          heap_internal_access_begin, __itt_group_heap, "no args")
+ITT_STUBV(ITTAPI, void, heap_internal_access_end, (void), (ITT_NO_PARAMS),
+          heap_internal_access_end, __itt_group_heap, "no args")
+ITT_STUBV(ITTAPI, void, heap_record_memory_growth_begin, (void),
+          (ITT_NO_PARAMS), heap_record_memory_growth_begin, __itt_group_heap,
+          "no args")
+ITT_STUBV(ITTAPI, void, heap_record_memory_growth_end, (void), (ITT_NO_PARAMS),
+          heap_record_memory_growth_end, __itt_group_heap, "no args")
+ITT_STUBV(ITTAPI, void, heap_reset_detection, (unsigned int reset_mask),
+          (ITT_FORMAT reset_mask), heap_reset_detection, __itt_group_heap, "%u")
+ITT_STUBV(ITTAPI, void, heap_record, (unsigned int record_mask),
+          (ITT_FORMAT record_mask), heap_record, __itt_group_heap, "%u")
+
+ITT_STUBV(ITTAPI, void, id_create, (const __itt_domain *domain, __itt_id id),
+          (ITT_FORMAT domain, id), id_create, __itt_group_structure, "%p, %lu")
+ITT_STUBV(ITTAPI, void, id_destroy, (const __itt_domain *domain, __itt_id id),
+          (ITT_FORMAT domain, id), id_destroy, __itt_group_structure, "%p, %lu")
+
+ITT_STUB(ITTAPI, __itt_timestamp, get_timestamp, (void), (ITT_NO_PARAMS),
+         get_timestamp, __itt_group_structure, "no args")
+
+ITT_STUBV(ITTAPI, void, region_begin,
+          (const __itt_domain *domain, __itt_id id, __itt_id parent,
+           __itt_string_handle *name),
+          (ITT_FORMAT domain, id, parent, name), region_begin,
+          __itt_group_structure, "%p, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, region_end, (const __itt_domain *domain, __itt_id id),
+          (ITT_FORMAT domain, id), region_end, __itt_group_structure, "%p, %lu")
+
+#ifndef __ITT_INTERNAL_BODY
+ITT_STUBV(ITTAPI, void, frame_begin_v3,
+          (const __itt_domain *domain, __itt_id *id), (ITT_FORMAT domain, id),
+          frame_begin_v3, __itt_group_structure, "%p, %p")
+ITT_STUBV(ITTAPI, void, frame_end_v3,
+          (const __itt_domain *domain, __itt_id *id), (ITT_FORMAT domain, id),
+          frame_end_v3, __itt_group_structure, "%p, %p")
+ITT_STUBV(ITTAPI, void, frame_submit_v3,
+          (const __itt_domain *domain, __itt_id *id, __itt_timestamp begin,
+           __itt_timestamp end),
+          (ITT_FORMAT domain, id, begin, end), frame_submit_v3,
+          __itt_group_structure, "%p, %p, %lu, %lu")
+#endif /* __ITT_INTERNAL_BODY */
+
+ITT_STUBV(ITTAPI, void, task_group,
+          (const __itt_domain *domain, __itt_id id, __itt_id parent,
+           __itt_string_handle *name),
+          (ITT_FORMAT domain, id, parent, name), task_group,
+          __itt_group_structure, "%p, %lu, %lu, %p")
+
+ITT_STUBV(ITTAPI, void, task_begin,
+          (const __itt_domain *domain, __itt_id id, __itt_id parent,
+           __itt_string_handle *name),
+          (ITT_FORMAT domain, id, parent, name), task_begin,
+          __itt_group_structure, "%p, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_begin_fn,
+          (const __itt_domain *domain, __itt_id id, __itt_id parent, void *fn),
+          (ITT_FORMAT domain, id, parent, fn), task_begin_fn,
+          __itt_group_structure, "%p, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_end, (const __itt_domain *domain),
+          (ITT_FORMAT domain), task_end, __itt_group_structure, "%p")
+
+ITT_STUBV(ITTAPI, void, counter_inc_v3,
+          (const __itt_domain *domain, __itt_string_handle *name),
+          (ITT_FORMAT domain, name), counter_inc_v3, __itt_group_structure,
+          "%p, %p")
+ITT_STUBV(ITTAPI, void, counter_inc_delta_v3,
+          (const __itt_domain *domain, __itt_string_handle *name,
+           unsigned long long value),
+          (ITT_FORMAT domain, name, value), counter_inc_delta_v3,
+          __itt_group_structure, "%p, %p, %lu")
+ITT_STUBV(ITTAPI, void, counter_dec_v3,
+          (const __itt_domain *domain, __itt_string_handle *name),
+          (ITT_FORMAT domain, name), counter_dec_v3, __itt_group_structure,
+          "%p, %p")
+ITT_STUBV(ITTAPI, void, counter_dec_delta_v3,
+          (const __itt_domain *domain, __itt_string_handle *name,
+           unsigned long long value),
+          (ITT_FORMAT domain, name, value), counter_dec_delta_v3,
+          __itt_group_structure, "%p, %p, %lu")
+
+ITT_STUBV(ITTAPI, void, marker,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *name,
+           __itt_scope scope),
+          (ITT_FORMAT domain, id, name, scope), marker, __itt_group_structure,
+          "%p, %lu, %p, %d")
+
+ITT_STUBV(ITTAPI, void, metadata_add,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
+           __itt_metadata_type type, size_t count, void *data),
+          (ITT_FORMAT domain, id, key, type, count, data), metadata_add,
+          __itt_group_structure, "%p, %lu, %p, %d, %lu, %p")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, metadata_str_addA,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
+           const char *data, size_t length),
+          (ITT_FORMAT domain, id, key, data, length), metadata_str_addA,
+          __itt_group_structure, "%p, %lu, %p, %p, %lu")
+ITT_STUBV(ITTAPI, void, metadata_str_addW,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
+           const wchar_t *data, size_t length),
+          (ITT_FORMAT domain, id, key, data, length), metadata_str_addW,
+          __itt_group_structure, "%p, %lu, %p, %p, %lu")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, metadata_str_add,
+          (const __itt_domain *domain, __itt_id id, __itt_string_handle *key,
+           const char *data, size_t length),
+          (ITT_FORMAT domain, id, key, data, length), metadata_str_add,
+          __itt_group_structure, "%p, %lu, %p, %p, %lu")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+ITT_STUBV(ITTAPI, void, relation_add_to_current,
+          (const __itt_domain *domain, __itt_relation relation, __itt_id tail),
+          (ITT_FORMAT domain, relation, tail), relation_add_to_current,
+          __itt_group_structure, "%p, %lu, %p")
+ITT_STUBV(ITTAPI, void, relation_add,
+          (const __itt_domain *domain, __itt_id head, __itt_relation relation,
+           __itt_id tail),
+          (ITT_FORMAT domain, head, relation, tail), relation_add,
+          __itt_group_structure, "%p, %p, %lu, %p")
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen),
+         (ITT_FORMAT name, namelen), event_createA,
+         __itt_group_mark | __itt_group_legacy, "\"%s\", %d")
+ITT_STUB(LIBITTAPI, __itt_event, event_createW,
+         (const wchar_t *name, int namelen), (ITT_FORMAT name, namelen),
+         event_createW, __itt_group_mark | __itt_group_legacy, "\"%S\", %d")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen),
+         (ITT_FORMAT name, namelen), event_create,
+         __itt_group_mark | __itt_group_legacy, "\"%s\", %d")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event), (ITT_FORMAT event),
+         event_start, __itt_group_mark | __itt_group_legacy, "%d")
+ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event), (ITT_FORMAT event),
+         event_end, __itt_group_mark | __itt_group_legacy, "%d")
+#endif /* __ITT_INTERNAL_BODY */
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_set_nameA,
+          (void *addr, const char *objtype, const char *objname, int attribute),
+          (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameA,
+          __itt_group_sync | __itt_group_fsync | __itt_group_legacy,
+          "%p, \"%s\", \"%s\", %x")
+ITT_STUBV(ITTAPI, void, sync_set_nameW,
+          (void *addr, const wchar_t *objtype, const wchar_t *objname,
+           int attribute),
+          (ITT_FORMAT addr, objtype, objname, attribute), sync_set_nameW,
+          __itt_group_sync | __itt_group_fsync | __itt_group_legacy,
+          "%p, \"%S\", \"%S\", %x")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_set_name,
+          (void *addr, const char *objtype, const char *objname, int attribute),
+          (ITT_FORMAT addr, objtype, objname, attribute), sync_set_name,
+          __itt_group_sync | __itt_group_fsync | __itt_group_legacy,
+          "p, \"%s\", \"%s\", %x")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, int, notify_sync_nameA,
+         (void *p, const char *objtype, int typelen, const char *objname,
+          int namelen, int attribute),
+         (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute),
+         notify_sync_nameA,
+         __itt_group_sync | __itt_group_fsync | __itt_group_legacy,
+         "%p, \"%s\", %d, \"%s\", %d, %x")
+ITT_STUB(LIBITTAPI, int, notify_sync_nameW,
+         (void *p, const wchar_t *objtype, int typelen, const wchar_t *objname,
+          int namelen, int attribute),
+         (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute),
+         notify_sync_nameW,
+         __itt_group_sync | __itt_group_fsync | __itt_group_legacy,
+         "%p, \"%S\", %d, \"%S\", %d, %x")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int, notify_sync_name,
+         (void *p, const char *objtype, int typelen, const char *objname,
+          int namelen, int attribute),
+         (ITT_FORMAT p, objtype, typelen, objname, namelen, attribute),
+         notify_sync_name,
+         __itt_group_sync | __itt_group_fsync | __itt_group_legacy,
+         "%p, \"%s\", %d, \"%s\", %d, %x")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+
+ITT_STUBV(LIBITTAPI, void, notify_sync_prepare, (void *p), (ITT_FORMAT p),
+          notify_sync_prepare,
+          __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
+ITT_STUBV(LIBITTAPI, void, notify_sync_cancel, (void *p), (ITT_FORMAT p),
+          notify_sync_cancel,
+          __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
+ITT_STUBV(LIBITTAPI, void, notify_sync_acquired, (void *p), (ITT_FORMAT p),
+          notify_sync_acquired,
+          __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
+ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *p), (ITT_FORMAT p),
+          notify_sync_releasing,
+          __itt_group_sync | __itt_group_fsync | __itt_group_legacy, "%p")
+#endif /* __ITT_INTERNAL_BODY */
+
+ITT_STUBV(LIBITTAPI, void, memory_read, (void *addr, size_t size),
+          (ITT_FORMAT addr, size), memory_read, __itt_group_legacy, "%p, %lu")
+ITT_STUBV(LIBITTAPI, void, memory_write, (void *addr, size_t size),
+          (ITT_FORMAT addr, size), memory_write, __itt_group_legacy, "%p, %lu")
+ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size),
+          (ITT_FORMAT addr, size), memory_update, __itt_group_legacy, "%p, %lu")
+
+ITT_STUB(LIBITTAPI, __itt_state_t, state_get, (void), (ITT_NO_PARAMS),
+         state_get, __itt_group_legacy, "no args")
+ITT_STUB(LIBITTAPI, __itt_state_t, state_set, (__itt_state_t s), (ITT_FORMAT s),
+         state_set, __itt_group_legacy, "%d")
+ITT_STUB(LIBITTAPI, __itt_obj_state_t, obj_mode_set,
+         (__itt_obj_prop_t p, __itt_obj_state_t s), (ITT_FORMAT p, s),
+         obj_mode_set, __itt_group_legacy, "%d, %d")
+ITT_STUB(LIBITTAPI, __itt_thr_state_t, thr_mode_set,
+         (__itt_thr_prop_t p, __itt_thr_state_t s), (ITT_FORMAT p, s),
+         thr_mode_set, __itt_group_legacy, "%d, %d")
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char *domain),
+         (ITT_FORMAT domain), frame_createA, __itt_group_frame, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain),
+         (ITT_FORMAT domain), frame_createW, __itt_group_frame, "\"%s\"")
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_frame, frame_create, (const char *domain),
+         (ITT_FORMAT domain), frame_create, __itt_group_frame, "\"%s\"")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* __ITT_INTERNAL_BODY */
-ITT_STUBV(ITTAPI, void, frame_begin,         (__itt_frame frame),     (ITT_FORMAT frame),  frame_begin,   __itt_group_frame, "%p")
-ITT_STUBV(ITTAPI, void, frame_end,           (__itt_frame frame),     (ITT_FORMAT frame),  frame_end,     __itt_group_frame, "%p")
-
-ITT_STUBV(ITTAPI, void, counter_destroy,      (__itt_counter id),                                                                                  (ITT_FORMAT id),        counter_destroy,   __itt_group_counter, "%p")
-ITT_STUBV(ITTAPI, void, counter_inc,          (__itt_counter id),                                                                                  (ITT_FORMAT id),        counter_inc,       __itt_group_counter, "%p")
-ITT_STUBV(ITTAPI, void, counter_inc_delta,    (__itt_counter id, unsigned long long value),                                                        (ITT_FORMAT id, value), counter_inc_delta, __itt_group_counter, "%p, %lu")
-ITT_STUBV(ITTAPI, void, counter_dec,          (__itt_counter id),                                                                                  (ITT_FORMAT id),        counter_dec,       __itt_group_counter, "%p")
-ITT_STUBV(ITTAPI, void, counter_dec_delta,    (__itt_counter id, unsigned long long value),                                                        (ITT_FORMAT id, value), counter_dec_delta, __itt_group_counter, "%p, %lu")
-ITT_STUBV(ITTAPI, void, counter_set_value,    (__itt_counter id, void *value_ptr),                                                                 (ITT_FORMAT id, value_ptr),                          counter_set_value,    __itt_group_counter, "%p, %p")
-ITT_STUBV(ITTAPI, void, counter_set_value_ex, (__itt_counter id, __itt_clock_domain *clock_domain, unsigned long long timestamp, void *value_ptr), (ITT_FORMAT id, clock_domain, timestamp, value_ptr), counter_set_value_ex, __itt_group_counter, "%p, %p, %llu, %p")
-
-#ifndef __ITT_INTERNAL_BODY
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char    *name), (ITT_FORMAT name), mark_createA, __itt_group_mark, "\"%s\"")
-ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name), (ITT_FORMAT name), mark_createW, __itt_group_mark, "\"%S\"")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_mark_type, mark_create,  (const char    *name), (ITT_FORMAT name), mark_create,  __itt_group_mark, "\"%s\"")
+ITT_STUBV(ITTAPI, void, frame_begin, (__itt_frame frame), (ITT_FORMAT frame),
+          frame_begin, __itt_group_frame, "%p")
+ITT_STUBV(ITTAPI, void, frame_end, (__itt_frame frame), (ITT_FORMAT frame),
+          frame_end, __itt_group_frame, "%p")
+
+ITT_STUBV(ITTAPI, void, counter_destroy, (__itt_counter id), (ITT_FORMAT id),
+          counter_destroy, __itt_group_counter, "%p")
+ITT_STUBV(ITTAPI, void, counter_inc, (__itt_counter id), (ITT_FORMAT id),
+          counter_inc, __itt_group_counter, "%p")
+ITT_STUBV(ITTAPI, void, counter_inc_delta,
+          (__itt_counter id, unsigned long long value), (ITT_FORMAT id, value),
+          counter_inc_delta, __itt_group_counter, "%p, %lu")
+ITT_STUBV(ITTAPI, void, counter_dec, (__itt_counter id), (ITT_FORMAT id),
+          counter_dec, __itt_group_counter, "%p")
+ITT_STUBV(ITTAPI, void, counter_dec_delta,
+          (__itt_counter id, unsigned long long value), (ITT_FORMAT id, value),
+          counter_dec_delta, __itt_group_counter, "%p, %lu")
+ITT_STUBV(ITTAPI, void, counter_set_value, (__itt_counter id, void *value_ptr),
+          (ITT_FORMAT id, value_ptr), counter_set_value, __itt_group_counter,
+          "%p, %p")
+ITT_STUBV(ITTAPI, void, counter_set_value_ex,
+          (__itt_counter id, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, void *value_ptr),
+          (ITT_FORMAT id, clock_domain, timestamp, value_ptr),
+          counter_set_value_ex, __itt_group_counter, "%p, %p, %llu, %p")
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_mark_type, mark_createA, (const char *name),
+         (ITT_FORMAT name), mark_createA, __itt_group_mark, "\"%s\"")
+ITT_STUB(ITTAPI, __itt_mark_type, mark_createW, (const wchar_t *name),
+         (ITT_FORMAT name), mark_createW, __itt_group_mark, "\"%S\"")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_mark_type, mark_create, (const char *name),
+         (ITT_FORMAT name), mark_create, __itt_group_mark, "\"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#endif /* __ITT_INTERNAL_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, markA, (__itt_mark_type mt, const char *parameter),
+         (ITT_FORMAT mt, parameter), markA, __itt_group_mark, "%d, \"%s\"")
+ITT_STUB(ITTAPI, int, markW, (__itt_mark_type mt, const wchar_t *parameter),
+         (ITT_FORMAT mt, parameter), markW, __itt_group_mark, "%d, \"%S\"")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, mark, (__itt_mark_type mt, const char *parameter),
+         (ITT_FORMAT mt, parameter), mark, __itt_group_mark, "%d, \"%s\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, mark_off, (__itt_mark_type mt), (ITT_FORMAT mt), mark_off,
+         __itt_group_mark, "%d")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, mark_globalA, (__itt_mark_type mt, const char *parameter),
+         (ITT_FORMAT mt, parameter), mark_globalA, __itt_group_mark,
+         "%d, \"%s\"")
+ITT_STUB(ITTAPI, int, mark_globalW,
+         (__itt_mark_type mt, const wchar_t *parameter),
+         (ITT_FORMAT mt, parameter), mark_globalW, __itt_group_mark,
+         "%d, \"%S\"")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, mark_global, (__itt_mark_type mt, const char *parameter),
+         (ITT_FORMAT mt, parameter), mark_global, __itt_group_mark,
+         "%d, \"%S\"")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, mark_global_off, (__itt_mark_type mt), (ITT_FORMAT mt),
+         mark_global_off, __itt_group_mark, "%d")
+
+#ifndef __ITT_INTERNAL_BODY
+ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void), (ITT_NO_PARAMS),
+         stack_caller_create, __itt_group_stitch, "no args")
+#endif /* __ITT_INTERNAL_BODY */
+ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id),
+          (ITT_FORMAT id), stack_caller_destroy, __itt_group_stitch, "%p")
+ITT_STUBV(ITTAPI, void, stack_callee_enter, (__itt_caller id), (ITT_FORMAT id),
+          stack_callee_enter, __itt_group_stitch, "%p")
+ITT_STUBV(ITTAPI, void, stack_callee_leave, (__itt_caller id), (ITT_FORMAT id),
+          stack_callee_leave, __itt_group_stitch, "%p")
+
+ITT_STUB(ITTAPI, __itt_clock_domain *, clock_domain_create,
+         (__itt_get_clock_info_fn fn, void *fn_data), (ITT_FORMAT fn, fn_data),
+         clock_domain_create, __itt_group_structure, "%p, %p")
+ITT_STUBV(ITTAPI, void, clock_domain_reset, (void), (ITT_NO_PARAMS),
+          clock_domain_reset, __itt_group_structure, "no args")
+ITT_STUBV(ITTAPI, void, id_create_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id),
+          (ITT_FORMAT domain, clock_domain, timestamp, id), id_create_ex,
+          __itt_group_structure, "%p, %p, %lu, %lu")
+ITT_STUBV(ITTAPI, void, id_destroy_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id),
+          (ITT_FORMAT domain, clock_domain, timestamp, id), id_destroy_ex,
+          __itt_group_structure, "%p, %p, %lu, %lu")
+ITT_STUBV(ITTAPI, void, task_begin_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id, __itt_id parentid,
+           __itt_string_handle *name),
+          (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name),
+          task_begin_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_begin_fn_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id, __itt_id parentid,
+           void *fn),
+          (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, fn),
+          task_begin_fn_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_end_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp),
+          (ITT_FORMAT domain, clock_domain, timestamp), task_end_ex,
+          __itt_group_structure, "%p, %p, %lu")
+ITT_STUBV(ITTAPI, void, task_begin_overlapped,
+          (const __itt_domain *domain, __itt_id id, __itt_id parent,
+           __itt_string_handle *name),
+          (ITT_FORMAT domain, id, parent, name), task_begin_overlapped,
+          __itt_group_structure, "%p, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id, __itt_id parentid,
+           __itt_string_handle *name),
+          (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name),
+          task_begin_overlapped_ex, __itt_group_structure,
+          "%p, %p, %lu, %lu, %lu, %p")
+ITT_STUBV(ITTAPI, void, task_end_overlapped,
+          (const __itt_domain *domain, __itt_id id), (ITT_FORMAT domain, id),
+          task_end_overlapped, __itt_group_structure, "%p, %lu")
+ITT_STUBV(ITTAPI, void, task_end_overlapped_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id),
+          (ITT_FORMAT domain, clock_domain, timestamp, id),
+          task_end_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu")
+ITT_STUBV(ITTAPI, void, marker_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id id, __itt_string_handle *name,
+           __itt_scope scope),
+          (ITT_FORMAT domain, clock_domain, timestamp, id, name, scope),
+          marker_ex, __itt_group_structure, "%p, %p, %lu, %lu, %p, %d")
+ITT_STUBV(ITTAPI, void, metadata_add_with_scope,
+          (const __itt_domain *domain, __itt_scope scope,
+           __itt_string_handle *key, __itt_metadata_type type, size_t count,
+           void *data),
+          (ITT_FORMAT domain, scope, key, type, count, data),
+          metadata_add_with_scope, __itt_group_structure,
+          "%p, %d, %p, %d, %lu, %p")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA,
+          (const __itt_domain *domain, __itt_scope scope,
+           __itt_string_handle *key, const char *data, size_t length),
+          (ITT_FORMAT domain, scope, key, data, length),
+          metadata_str_add_with_scopeA, __itt_group_structure,
+          "%p, %d, %p, %p, %lu")
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW,
+          (const __itt_domain *domain, __itt_scope scope,
+           __itt_string_handle *key, const wchar_t *data, size_t length),
+          (ITT_FORMAT domain, scope, key, data, length),
+          metadata_str_add_with_scopeW, __itt_group_structure,
+          "%p, %d, %p, %p, %lu")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope,
+          (const __itt_domain *domain, __itt_scope scope,
+           __itt_string_handle *key, const char *data, size_t length),
+          (ITT_FORMAT domain, scope, key, data, length),
+          metadata_str_add_with_scope, __itt_group_structure,
+          "%p, %d, %p, %p, %lu")
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, relation_add_to_current_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_relation relation,
+           __itt_id tail),
+          (ITT_FORMAT domain, clock_domain, timestamp, relation, tail),
+          relation_add_to_current_ex, __itt_group_structure,
+          "%p, %p, %lu, %d, %lu")
+ITT_STUBV(ITTAPI, void, relation_add_ex,
+          (const __itt_domain *domain, __itt_clock_domain *clock_domain,
+           unsigned long long timestamp, __itt_id head, __itt_relation relation,
+           __itt_id tail),
+          (ITT_FORMAT domain, clock_domain, timestamp, head, relation, tail),
+          relation_add_ex, __itt_group_structure, "%p, %p, %lu, %lu, %d, %lu")
+ITT_STUB(ITTAPI, __itt_track_group *, track_group_create,
+         (__itt_string_handle * name, __itt_track_group_type track_group_type),
+         (ITT_FORMAT name, track_group_type), track_group_create,
+         __itt_group_structure, "%p, %d")
+ITT_STUB(ITTAPI, __itt_track *, track_create,
+         (__itt_track_group * track_group, __itt_string_handle *name,
+          __itt_track_type track_type),
+         (ITT_FORMAT track_group, name, track_type), track_create,
+         __itt_group_structure, "%p, %p, %d")
+ITT_STUBV(ITTAPI, void, set_track, (__itt_track * track), (ITT_FORMAT track),
+          set_track, __itt_group_structure, "%p")
+
+#ifndef __ITT_INTERNAL_BODY
+ITT_STUB(ITTAPI, const char *, api_version, (void), (ITT_NO_PARAMS),
+         api_version, __itt_group_all & ~__itt_group_legacy, "no args")
+#endif /* __ITT_INTERNAL_BODY */
+
+#ifndef __ITT_INTERNAL_BODY
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, int, av_saveA,
+         (void *data, int rank, const int *dimensions, int type,
+          const char *filePath, int columnOrder),
+         (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder),
+         av_saveA, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
+ITT_STUB(ITTAPI, int, av_saveW,
+         (void *data, int rank, const int *dimensions, int type,
+          const wchar_t *filePath, int columnOrder),
+         (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder),
+         av_saveW, __itt_group_arrays, "%p, %d, %p, %d, \"%S\", %d")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, int, av_save,
+         (void *data, int rank, const int *dimensions, int type,
+          const char *filePath, int columnOrder),
+         (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder),
+         av_save, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* __ITT_INTERNAL_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, int,  markA,        (__itt_mark_type mt, const char    *parameter), (ITT_FORMAT mt, parameter), markA, __itt_group_mark, "%d, \"%s\"")
-ITT_STUB(ITTAPI, int,  markW,        (__itt_mark_type mt, const wchar_t *parameter), (ITT_FORMAT mt, parameter), markW, __itt_group_mark, "%d, \"%S\"")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, int,  mark,         (__itt_mark_type mt, const char    *parameter), (ITT_FORMAT mt, parameter), mark,  __itt_group_mark, "%d, \"%s\"")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, int,  mark_off, (__itt_mark_type mt), (ITT_FORMAT mt), mark_off, __itt_group_mark, "%d")
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, int,  mark_globalA, (__itt_mark_type mt, const char    *parameter), (ITT_FORMAT mt, parameter), mark_globalA, __itt_group_mark, "%d, \"%s\"")
-ITT_STUB(ITTAPI, int,  mark_globalW, (__itt_mark_type mt, const wchar_t *parameter), (ITT_FORMAT mt, parameter), mark_globalW, __itt_group_mark, "%d, \"%S\"")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, int,  mark_global,  (__itt_mark_type mt, const char    *parameter), (ITT_FORMAT mt, parameter), mark_global,  __itt_group_mark, "%d, \"%S\"")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, int,  mark_global_off, (__itt_mark_type mt),                        (ITT_FORMAT mt),            mark_global_off, __itt_group_mark, "%d")
-
-#ifndef __ITT_INTERNAL_BODY
-ITT_STUB(ITTAPI, __itt_caller, stack_caller_create, (void), (ITT_NO_PARAMS), stack_caller_create,  __itt_group_stitch, "no args")
-#endif /* __ITT_INTERNAL_BODY */
-ITT_STUBV(ITTAPI, void, stack_caller_destroy, (__itt_caller id), (ITT_FORMAT id), stack_caller_destroy, __itt_group_stitch, "%p")
-ITT_STUBV(ITTAPI, void, stack_callee_enter,   (__itt_caller id), (ITT_FORMAT id), stack_callee_enter,   __itt_group_stitch, "%p")
-ITT_STUBV(ITTAPI, void, stack_callee_leave,   (__itt_caller id), (ITT_FORMAT id), stack_callee_leave,   __itt_group_stitch, "%p")
-
-ITT_STUB(ITTAPI,  __itt_clock_domain*, clock_domain_create, (__itt_get_clock_info_fn fn, void* fn_data), (ITT_FORMAT fn, fn_data), clock_domain_create, __itt_group_structure, "%p, %p")
-ITT_STUBV(ITTAPI, void,                clock_domain_reset,  (void),                                      (ITT_NO_PARAMS),          clock_domain_reset,  __itt_group_structure, "no args")
-ITT_STUBV(ITTAPI, void, id_create_ex,  (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), id_create_ex,  __itt_group_structure, "%p, %p, %lu, %lu")
-ITT_STUBV(ITTAPI, void, id_destroy_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id), (ITT_FORMAT domain, clock_domain, timestamp, id), id_destroy_ex, __itt_group_structure, "%p, %p, %lu, %lu")
-ITT_STUBV(ITTAPI, void, task_begin_ex,    (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name), task_begin_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
-ITT_STUBV(ITTAPI, void, task_begin_fn_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, void* fn),                  (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, fn), task_begin_fn_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
-ITT_STUBV(ITTAPI, void, task_end_ex,      (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp),                                                            (ITT_FORMAT domain, clock_domain, timestamp), task_end_ex, __itt_group_structure, "%p, %p, %lu")
-ITT_STUBV(ITTAPI, void, task_begin_overlapped,       (const __itt_domain *domain, __itt_id id, __itt_id parent, __itt_string_handle *name),                                                                   (ITT_FORMAT domain, id, parent, name), task_begin_overlapped, __itt_group_structure, "%p, %lu, %lu, %p")
-ITT_STUBV(ITTAPI, void, task_begin_overlapped_ex,    (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_id parentid, __itt_string_handle *name), (ITT_FORMAT domain, clock_domain, timestamp, id, parentid, name), task_begin_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu, %lu, %p")
-ITT_STUBV(ITTAPI, void, task_end_overlapped, (const __itt_domain *domain, __itt_id id),                                                                                                                       (ITT_FORMAT domain, id), task_end_overlapped, __itt_group_structure, "%p, %lu")
-ITT_STUBV(ITTAPI, void, task_end_overlapped_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id),                                                    (ITT_FORMAT domain, clock_domain, timestamp, id), task_end_overlapped_ex, __itt_group_structure, "%p, %p, %lu, %lu")
-ITT_STUBV(ITTAPI, void, marker_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id id, __itt_string_handle *name, __itt_scope scope), (ITT_FORMAT domain, clock_domain, timestamp, id, name, scope), marker_ex, __itt_group_structure, "%p, %p, %lu, %lu, %p, %d")
-ITT_STUBV(ITTAPI, void, metadata_add_with_scope, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data), (ITT_FORMAT domain, scope, key, type, count, data), metadata_add_with_scope, __itt_group_structure, "%p, %d, %p, %d, %lu, %p")
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeA, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length),    (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scopeA, __itt_group_structure, "%p, %d, %p, %p, %lu")
-ITT_STUBV(ITTAPI, void, metadata_str_add_with_scopeW, (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length), (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scopeW, __itt_group_structure, "%p, %d, %p, %p, %lu")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, metadata_str_add_with_scope,  (const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length),    (ITT_FORMAT domain, scope, key, data, length), metadata_str_add_with_scope,  __itt_group_structure, "%p, %d, %p, %p, %lu")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, relation_add_to_current_ex, (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_relation relation, __itt_id tail),                (ITT_FORMAT domain, clock_domain, timestamp, relation, tail),       relation_add_to_current_ex, __itt_group_structure, "%p, %p, %lu, %d, %lu")
-ITT_STUBV(ITTAPI, void, relation_add_ex,            (const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail), (ITT_FORMAT domain, clock_domain, timestamp, head, relation, tail), relation_add_ex,            __itt_group_structure, "%p, %p, %lu, %lu, %d, %lu")
-ITT_STUB(ITTAPI,  __itt_track_group*, track_group_create, (__itt_string_handle* name, __itt_track_group_type track_group_type),                    (ITT_FORMAT name, track_group_type),        track_group_create, __itt_group_structure, "%p, %d")
-ITT_STUB(ITTAPI,  __itt_track*,       track_create,       (__itt_track_group* track_group,__itt_string_handle* name, __itt_track_type track_type), (ITT_FORMAT track_group, name, track_type), track_create,       __itt_group_structure, "%p, %p, %d")
-ITT_STUBV(ITTAPI, void,               set_track,          (__itt_track *track),                                                                    (ITT_FORMAT track),                         set_track,          __itt_group_structure, "%p")
-
-#ifndef __ITT_INTERNAL_BODY
-ITT_STUB(ITTAPI, const char*, api_version, (void), (ITT_NO_PARAMS), api_version, __itt_group_all & ~__itt_group_legacy, "no args")
-#endif /* __ITT_INTERNAL_BODY */
 
 #ifndef __ITT_INTERNAL_BODY
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, int, av_saveA, (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_saveA, __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
-ITT_STUB(ITTAPI, int, av_saveW, (void *data, int rank, const int *dimensions, int type, const wchar_t *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_saveW, __itt_group_arrays, "%p, %d, %p, %d, \"%S\", %d")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, int, av_save,  (void *data, int rank, const int *dimensions, int type, const char *filePath, int columnOrder), (ITT_FORMAT data, rank, dimensions, type, filePath, columnOrder), av_save,  __itt_group_arrays, "%p, %d, %p, %d, \"%s\", %d")
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, module_loadA,
+          (void *start_addr, void *end_addr, const char *path),
+          (ITT_FORMAT start_addr, end_addr, path), module_loadA,
+          __itt_group_none, "%p, %p, %p")
+ITT_STUBV(ITTAPI, void, module_loadW,
+          (void *start_addr, void *end_addr, const wchar_t *path),
+          (ITT_FORMAT start_addr, end_addr, path), module_loadW,
+          __itt_group_none, "%p, %p, %p")
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, module_load,
+          (void *start_addr, void *end_addr, const char *path),
+          (ITT_FORMAT start_addr, end_addr, path), module_load,
+          __itt_group_none, "%p, %p, %p")
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* __ITT_INTERNAL_BODY */
 
-#ifndef __ITT_INTERNAL_BODY
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, module_loadA, (void *start_addr, void* end_addr, const char *path), (ITT_FORMAT start_addr, end_addr, path), module_loadA, __itt_group_none, "%p, %p, %p")
-ITT_STUBV(ITTAPI, void, module_loadW, (void *start_addr, void* end_addr, const wchar_t *path), (ITT_FORMAT start_addr, end_addr, path), module_loadW, __itt_group_none, "%p, %p, %p")
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, module_load, (void *start_addr, void *end_addr, const char *path), (ITT_FORMAT start_addr, end_addr, path), module_load, __itt_group_none, "%p, %p, %p")
-#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#endif /* __ITT_INTERNAL_BODY */
-
-
 #endif /* __ITT_INTERNAL_INIT */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_static.cpp

 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "kmp_config.h"
 #include "kmp_os.h"
 #include "ittnotify_config.h"
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #if defined(__MINGW32__)
 #include <limits.h>
 #else
 #define PATH_MAX 512
 #endif
 #else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
 #include <limits.h>
 #include <dlfcn.h>

 #include "legacy/ittnotify.h"
 
 #if KMP_MSVC_COMPAT
 #include "disable_warnings.h"
 #endif
 
 static const char api_version[] = API_VERSION "\0\n@(#) $Revision: 481659 $\n";
 
-#define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)
+#define _N_(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n)
 
-#if ITT_OS==ITT_OS_WIN
-static const char* ittnotify_lib_name = "libittnotify.dll";
-#elif ITT_OS==ITT_OS_LINUX || ITT_OS==ITT_OS_FREEBSD
-static const char* ittnotify_lib_name = "libittnotify.so";
-#elif ITT_OS==ITT_OS_MAC
-static const char* ittnotify_lib_name = "libittnotify.dylib";
+#if ITT_OS == ITT_OS_WIN
+static const char *ittnotify_lib_name = "libittnotify.dll";
+#elif ITT_OS == ITT_OS_LINUX || ITT_OS == ITT_OS_FREEBSD
+static const char *ittnotify_lib_name = "libittnotify.so";
+#elif ITT_OS == ITT_OS_MAC
+static const char *ittnotify_lib_name = "libittnotify.dylib";
 #else
 #error Unsupported or unknown OS.
 #endif
 
 #ifdef __ANDROID__
 #include <android/log.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <linux/limits.h>
 
 #ifdef ITT_ANDROID_LOG
-    #define ITT_ANDROID_LOG_TAG   "INTEL_VTUNE_USERAPI"
-    #define ITT_ANDROID_LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, ITT_ANDROID_LOG_TAG, __VA_ARGS__))
-    #define ITT_ANDROID_LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, ITT_ANDROID_LOG_TAG, __VA_ARGS__))
-    #define ITT_ANDROID_LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR,ITT_ANDROID_LOG_TAG, __VA_ARGS__))
-    #define ITT_ANDROID_LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG,ITT_ANDROID_LOG_TAG, __VA_ARGS__))
+#define ITT_ANDROID_LOG_TAG "INTEL_VTUNE_USERAPI"
+#define ITT_ANDROID_LOGI(...)                                                  \
+  ((void)__android_log_print(ANDROID_LOG_INFO, ITT_ANDROID_LOG_TAG,            \
+                             __VA_ARGS__))
+#define ITT_ANDROID_LOGW(...)                                                  \
+  ((void)__android_log_print(ANDROID_LOG_WARN, ITT_ANDROID_LOG_TAG,            \
+                             __VA_ARGS__))
+#define ITT_ANDROID_LOGE(...)                                                  \
+  ((void)__android_log_print(ANDROID_LOG_ERROR, ITT_ANDROID_LOG_TAG,           \
+                             __VA_ARGS__))
+#define ITT_ANDROID_LOGD(...)                                                  \
+  ((void)__android_log_print(ANDROID_LOG_DEBUG, ITT_ANDROID_LOG_TAG,           \
+                             __VA_ARGS__))
 #else
-    #define ITT_ANDROID_LOGI(...)
-    #define ITT_ANDROID_LOGW(...)
-    #define ITT_ANDROID_LOGE(...)
-    #define ITT_ANDROID_LOGD(...)
 #endif
 
 /* default location of userapi collector on Android */
-#define ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(x)  "/data/data/com.intel.vtune/perfrun/lib" \
-                                                #x "/runtime/libittnotify.so"
+#define ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(x)                                 \
+  "/data/data/com.intel.vtune/perfrun/lib" #x "/runtime/libittnotify.so"
 
-#if ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_ARM
-#define ANDROID_ITTNOTIFY_DEFAULT_PATH  ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(32)
+#if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM
+#define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(32)
 #else
-#define ANDROID_ITTNOTIFY_DEFAULT_PATH  ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(64)
+#define ANDROID_ITTNOTIFY_DEFAULT_PATH ANDROID_ITTNOTIFY_DEFAULT_PATH_MASK(64)
 #endif
 
 #endif
 
 #ifndef PATH_MAX
 #define PATH_MAX 4096
 #endif
 
-
 #ifndef LIB_VAR_NAME
-#if ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_ARM || ITT_ARCH==ITT_ARCH_MIPS
+#if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM ||                   \
+    ITT_ARCH == ITT_ARCH_MIPS
 #define LIB_VAR_NAME INTEL_LIBITTNOTIFY32
 #else
 #define LIB_VAR_NAME INTEL_LIBITTNOTIFY64
 #endif
 #endif /* LIB_VAR_NAME */
 
-#define ITT_MUTEX_INIT_AND_LOCK(p) {                                 \
-    if (PTHREAD_SYMBOLS)                                             \
-    {                                                                \
-        if (!p.mutex_initialized)                                    \
-        {                                                            \
-            if (__itt_interlocked_increment(&p.atomic_counter) == 1) \
-            {                                                        \
-                __itt_mutex_init(&p.mutex);                          \
-                p.mutex_initialized = 1;                             \
-            }                                                        \
-            else                                                     \
-                while (!p.mutex_initialized)                         \
-                    __itt_thread_yield();                            \
-        }                                                            \
-        __itt_mutex_lock(&p.mutex);                                  \
-    }                                                                \
+#define ITT_MUTEX_INIT_AND_LOCK(p)                                             \
+  {                                                                            \
+    if (PTHREAD_SYMBOLS) {                                                     \
+      if (!p.mutex_initialized) {                                              \
+        if (__itt_interlocked_increment(&p.atomic_counter) == 1) {             \
+          __itt_mutex_init(&p.mutex);                                          \
+          p.mutex_initialized = 1;                                             \
+        } else                                                                 \
+          while (!p.mutex_initialized)                                         \
+            __itt_thread_yield();                                              \
+      }                                                                        \
+      __itt_mutex_lock(&p.mutex);                                              \
+    }                                                                          \
   }
 
-typedef int (__itt_init_ittlib_t)(const char*, __itt_group_id);
+typedef int(__itt_init_ittlib_t)(const char *, __itt_group_id);
 
 /* this define used to control initialization function name. */
 #ifndef __itt_init_ittlib_name
-ITT_EXTERN_C int _N_(init_ittlib)(const char*, __itt_group_id);
-static __itt_init_ittlib_t* __itt_init_ittlib_ptr = _N_(init_ittlib);
+ITT_EXTERN_C int _N_(init_ittlib)(const char *, __itt_group_id);
+static __itt_init_ittlib_t *__itt_init_ittlib_ptr = _N_(init_ittlib);
 #define __itt_init_ittlib_name __itt_init_ittlib_ptr
 #endif /* __itt_init_ittlib_name */
 
-typedef void (__itt_fini_ittlib_t)(void);
+typedef void(__itt_fini_ittlib_t)(void);
 
 /* this define used to control finalization function name. */
 #ifndef __itt_fini_ittlib_name
 ITT_EXTERN_C void _N_(fini_ittlib)(void);
-static __itt_fini_ittlib_t* __itt_fini_ittlib_ptr = _N_(fini_ittlib);
+static __itt_fini_ittlib_t *__itt_fini_ittlib_ptr = _N_(fini_ittlib);
 #define __itt_fini_ittlib_name __itt_fini_ittlib_ptr
 #endif /* __itt_fini_ittlib_name */
 
 /* building pointers to imported funcs */
 #undef ITT_STUBV
 #undef ITT_STUB
-#define ITT_STUB(api,type,name,args,params,ptr,group,format)   \
-static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args;\
-typedef type api ITT_JOIN(_N_(name),_t) args;                  \
-ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END \
-static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args \
-{                                                              \
-    __itt_init_ittlib_name(NULL, __itt_group_all);             \
-    if (ITTNOTIFY_NAME(name) && ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init))) \
-        return ITTNOTIFY_NAME(name) params;                    \
-    else                                                       \
-        return (type)0;                                        \
+#define ITT_STUB(api, type, name, args, params, ptr, group, format)            \
+  static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args;             \
+  typedef type api ITT_JOIN(_N_(name), _t) args;                               \
+  ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) =          \
+      ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init));                              \
+  ITT_EXTERN_C_END                                                             \
+  static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args {            \
+    __itt_init_ittlib_name(NULL, __itt_group_all);                             \
+    if (ITTNOTIFY_NAME(name) &&                                                \
+        ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)))    \
+      return ITTNOTIFY_NAME(name) params;                                      \
+    else                                                                       \
+      return (type)0;                                                          \
   }
 
-#define ITT_STUBV(api,type,name,args,params,ptr,group,format)  \
-static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args;\
-typedef type api ITT_JOIN(_N_(name),_t) args;                  \
-ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END \
-static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args \
-{                                                              \
-    __itt_init_ittlib_name(NULL, __itt_group_all);             \
-    if (ITTNOTIFY_NAME(name) && ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init))) \
-        ITTNOTIFY_NAME(name) params;                           \
-    else                                                       \
-        return;                                                \
+#define ITT_STUBV(api, type, name, args, params, ptr, group, format)           \
+  static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args;             \
+  typedef type api ITT_JOIN(_N_(name), _t) args;                               \
+  ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) =          \
+      ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init));                              \
+  ITT_EXTERN_C_END                                                             \
+  static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args {            \
+    __itt_init_ittlib_name(NULL, __itt_group_all);                             \
+    if (ITTNOTIFY_NAME(name) &&                                                \
+        ITTNOTIFY_NAME(name) != ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)))    \
+      ITTNOTIFY_NAME(name) params;                                             \
+    else                                                                       \
+      return;                                                                  \
   }
 
 #undef __ITT_INTERNAL_INIT
 #include "ittnotify_static.h"
 
 #undef ITT_STUB
 #undef ITT_STUBV
-#define ITT_STUB(api,type,name,args,params,ptr,group,format)   \
-static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args;\
-typedef type api ITT_JOIN(_N_(name),_t) args;                  \
-ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END
+#define ITT_STUB(api, type, name, args, params, ptr, group, format)            \
+  static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args;             \
+  typedef type api ITT_JOIN(_N_(name), _t) args;                               \
+  ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) =          \
+      ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init));                              \
+  ITT_EXTERN_C_END
 
-#define ITT_STUBV(api,type,name,args,params,ptr,group,format)  \
-static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)) args;\
-typedef type api ITT_JOIN(_N_(name),_t) args;                  \
-ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name),_t)* ITTNOTIFY_NAME(name) = ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)); ITT_EXTERN_C_END
+#define ITT_STUBV(api, type, name, args, params, ptr, group, format)           \
+  static type api ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)) args;             \
+  typedef type api ITT_JOIN(_N_(name), _t) args;                               \
+  ITT_EXTERN_C_BEGIN ITT_JOIN(_N_(name), _t) * ITTNOTIFY_NAME(name) =          \
+      ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init));                              \
+  ITT_EXTERN_C_END
 
 #define __ITT_INTERNAL_INIT
 #include "ittnotify_static.h"
 #undef __ITT_INTERNAL_INIT
 
 ITT_GROUP_LIST(group_list);
 
 #pragma pack(push, 8)
 
-typedef struct ___itt_group_alias
-{
-    const char*    env_var;
-    __itt_group_id groups;
+typedef struct ___itt_group_alias {
+  const char *env_var;
 } __itt_group_alias;
 
 static __itt_group_alias group_alias[] = {
-    { "KMP_FOR_TPROFILE", (__itt_group_id)(__itt_group_control | __itt_group_thread | __itt_group_sync  | __itt_group_mark) },
-    { "KMP_FOR_TCHECK",   (__itt_group_id)(__itt_group_control | __itt_group_thread | __itt_group_sync  | __itt_group_fsync | __itt_group_mark | __itt_group_suppress) },
-    { NULL,               (__itt_group_none) },
-    { api_version,        (__itt_group_none) } /* !!! Just to avoid unused code elimination !!! */
+    {"KMP_FOR_TPROFILE",
+     (__itt_group_id)(__itt_group_control | __itt_group_thread |
+                      __itt_group_sync | __itt_group_mark)},
+    {"KMP_FOR_TCHECK",
+     (__itt_group_id)(__itt_group_control | __itt_group_thread |
+                      __itt_group_sync | __itt_group_fsync | __itt_group_mark |
+                      __itt_group_suppress)},
+    {NULL, (__itt_group_none)},
+    {api_version,
+     (__itt_group_none)} /* !!! Just to avoid unused code elimination !!! */
 };
 
 #pragma pack(pop)
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
 #pragma warning(push)
-#pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function pointer 'XXX' to data pointer 'void *' */
+#pragma warning(disable : 4054) /* warning C4054: 'type cast' : from function  \
+                                   pointer 'XXX' to data pointer 'void *' */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 static __itt_api_info api_list[] = {
 /* Define functions with static implementation */
 #undef ITT_STUB
 #undef ITT_STUBV
-#define ITT_STUB(api,type,name,args,params,nameindll,group,format) { ITT_TO_STR(ITT_JOIN(__itt_,nameindll)), (void**)(void*)&ITTNOTIFY_NAME(name), (void*)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)), (void*)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)), (__itt_group_id)(group)},
+#define ITT_STUB(api, type, name, args, params, nameindll, group, format)      \
+  {ITT_TO_STR(ITT_JOIN(__itt_, nameindll)),                                    \
+   (void **)(void *)&ITTNOTIFY_NAME(name),                                     \
+   (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)),                \
+   (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)),                \
+   (__itt_group_id)(group)},
 #define ITT_STUBV ITT_STUB
 #define __ITT_INTERNAL_INIT
 #include "ittnotify_static.h"
 #undef __ITT_INTERNAL_INIT
 /* Define functions without static implementation */
 #undef ITT_STUB
 #undef ITT_STUBV
-#define ITT_STUB(api,type,name,args,params,nameindll,group,format) {ITT_TO_STR(ITT_JOIN(__itt_,nameindll)), (void**)(void*)&ITTNOTIFY_NAME(name), (void*)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name),_init)), NULL, (__itt_group_id)(group)},
+#define ITT_STUB(api, type, name, args, params, nameindll, group, format)      \
+  {ITT_TO_STR(ITT_JOIN(__itt_, nameindll)),                                    \
+   (void **)(void *)&ITTNOTIFY_NAME(name),                                     \
+   (void *)(size_t)&ITT_VERSIONIZE(ITT_JOIN(_N_(name), _init)), NULL,          \
+   (__itt_group_id)(group)},
 #define ITT_STUBV ITT_STUB
 #include "ittnotify_static.h"
-    {NULL, NULL, NULL, NULL, __itt_group_none}
-};
+    {NULL, NULL, NULL, NULL, __itt_group_none}};
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
 #pragma warning(pop)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /* static part descriptor which handles. all notification api attributes. */
 __itt_global _N_(_ittapi_global) = {
-    ITT_MAGIC,                                     /* identification info */
-    ITT_MAJOR, ITT_MINOR, API_VERSION_BUILD,       /* version info */
-    0,                                             /* api_initialized */
-    0,                                             /* mutex_initialized */
-    0,                                             /* atomic_counter */
-    MUTEX_INITIALIZER,                             /* mutex */
-    NULL,                                          /* dynamic library handle */
-    NULL,                                          /* error_handler */
-    NULL,                                          /* dll_path_ptr */
-    (__itt_api_info*)&api_list,                    /* api_list_ptr */
-    NULL,                                          /* next __itt_global */
-    NULL,                                          /* thread_list */
-    NULL,                                          /* domain_list */
-    NULL,                                          /* string_list */
-    __itt_collection_normal,                       /* collection state */
-    NULL                                          /* counter_list */
+    ITT_MAGIC, /* identification info */
+    ITT_MAJOR,
+    ITT_MINOR,
+    API_VERSION_BUILD, /* version info */
+    0, /* api_initialized */
+    0, /* mutex_initialized */
+    0, /* atomic_counter */
+    MUTEX_INITIALIZER, /* mutex */
+    NULL, /* dynamic library handle */
+    NULL, /* error_handler */
+    NULL, /* dll_path_ptr */
+    (__itt_api_info *)&api_list, /* api_list_ptr */
+    NULL, /* next __itt_global */
+    NULL, /* thread_list */
+    NULL, /* domain_list */
+    NULL, /* string_list */
+    __itt_collection_normal, /* collection state */
+    NULL /* counter_list */
 };
 
-typedef void (__itt_api_init_t)(__itt_global*, __itt_group_id);
-typedef void (__itt_api_fini_t)(__itt_global*);
+typedef void(__itt_api_init_t)(__itt_global *, __itt_group_id);
+typedef void(__itt_api_fini_t)(__itt_global *);
 
 /* ========================================================================= */
 
 #ifdef ITT_NOTIFY_EXT_REPORT
 ITT_EXTERN_C void _N_(error_handler)(__itt_error_code, va_list args);
 #endif /* ITT_NOTIFY_EXT_REPORT */
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
 #pragma warning(push)
-#pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer 'void *' to function pointer 'XXX' */
+#pragma warning(                                                               \
+    disable : 4055) /* warning C4055: 'type cast' : from data pointer 'void *' \
+                       to function pointer 'XXX' */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-static void __itt_report_error(unsigned code_arg, ...)
-{
-    va_list args;
-    va_start(args, code_arg);
+static void __itt_report_error(unsigned code_arg, ...) {
 
-    // We use unsigned for the code argument and explicitly cast it here to the
-    // right enumerator because variadic functions are not compatible with
-    // default promotions.
-    __itt_error_code code = (__itt_error_code)code_arg;
 
-    if (_N_(_ittapi_global).error_handler != NULL)
-    {
-        __itt_error_handler_t* handler = (__itt_error_handler_t*)(size_t)_N_(_ittapi_global).error_handler;
-        handler(code, args);
-    }
+  if (_N_(_ittapi_global).error_handler != NULL) {
+    __itt_error_handler_t *handler =
+        (__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;
 #ifdef ITT_NOTIFY_EXT_REPORT
-    _N_(error_handler)(code, args);
 #endif /* ITT_NOTIFY_EXT_REPORT */
-    va_end(args);
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
 #pragma warning(pop)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW),_init))(const wchar_t* name)
-{
-    __itt_domain *h_tail = NULL, *h = NULL;
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+static __itt_domain *ITTAPI
+ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))(const wchar_t *name) {
 
-    if (name == NULL)
-    {
-        return NULL;
-    }
+  if (name == NULL) {
 
-    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
-    if (_N_(_ittapi_global).api_initialized)
-    {
-        if (ITTNOTIFY_NAME(domain_createW) && ITTNOTIFY_NAME(domain_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW),_init)))
-        {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(domain_createW)(name);
-        }
-    }
-    for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL; h_tail = h, h = h->next)
-    {
-        if (h->nameW != NULL && !wcscmp(h->nameW, name)) break;
-    }
-    if (h == NULL)
-    {
-        NEW_DOMAIN_W(&_N_(_ittapi_global),h,h_tail,name);
-    }
-    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-    return h;
+  if (_N_(_ittapi_global).api_initialized) {
+    if (ITTNOTIFY_NAME(domain_createW) &&
+        ITTNOTIFY_NAME(domain_createW) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW), _init))) {
+  for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->nameW != NULL && !wcscmp(h->nameW, name))
+      break;
+  if (h == NULL) {
+    NEW_DOMAIN_W(&_N_(_ittapi_global), h, h_tail, name);
+  if (PTHREAD_SYMBOLS)
+    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 }
 
-static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA),_init))(const char* name)
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),_init))(const char* name)
+static __itt_domain *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA),
+                                                    _init))(const char *name)
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+static __itt_domain *ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),
+                                                    _init))(const char *name)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 {
-    __itt_domain *h_tail = NULL, *h = NULL;
 
-    if (name == NULL)
-    {
-        return NULL;
-    }
+  if (name == NULL) {
 
-    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
-    if (_N_(_ittapi_global).api_initialized)
-    {
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-        if (ITTNOTIFY_NAME(domain_createA) && ITTNOTIFY_NAME(domain_createA) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA),_init)))
-        {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(domain_createA)(name);
-        }
+  if (_N_(_ittapi_global).api_initialized) {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+    if (ITTNOTIFY_NAME(domain_createA) &&
+        ITTNOTIFY_NAME(domain_createA) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createA), _init))) {
 #else
-        if (ITTNOTIFY_NAME(domain_create) && ITTNOTIFY_NAME(domain_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create),_init)))
-        {
-            if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(domain_create)(name);
-        }
+    if (ITTNOTIFY_NAME(domain_create) &&
+        ITTNOTIFY_NAME(domain_create) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(domain_create), _init))) {
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 #endif
-    }
-    for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL; h_tail = h, h = h->next)
-    {
-        if (h->nameA != NULL && !__itt_fstrcmp(h->nameA, name)) break;
-    }
-    if (h == NULL)
-    {
-        NEW_DOMAIN_A(&_N_(_ittapi_global),h,h_tail,name);
-    }
-    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-    return h;
+  for (h_tail = NULL, h = _N_(_ittapi_global).domain_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->nameA != NULL && !__itt_fstrcmp(h->nameA, name))
+      break;
+  if (h == NULL) {
+    NEW_DOMAIN_A(&_N_(_ittapi_global), h, h_tail, name);
+  if (PTHREAD_SYMBOLS)
+    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW),_init))(const wchar_t* name)
-{
-    __itt_string_handle *h_tail = NULL, *h = NULL;
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+static __itt_string_handle *ITTAPI ITT_VERSIONIZE(
+    ITT_JOIN(_N_(string_handle_createW), _init))(const wchar_t *name) {
 
-    if (name == NULL)
-    {
-        return NULL;
-    }
+  if (name == NULL) {
 
-    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
-    if (_N_(_ittapi_global).api_initialized)
-    {
-        if (ITTNOTIFY_NAME(string_handle_createW) && ITTNOTIFY_NAME(string_handle_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW),_init)))
-        {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(string_handle_createW)(name);
-        }
-    }
-    for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL; h_tail = h, h = h->next)
-    {
-        if (h->strW != NULL && !wcscmp(h->strW, name)) break;
-    }
-    if (h == NULL)
-    {
-        NEW_STRING_HANDLE_W(&_N_(_ittapi_global),h,h_tail,name);
-    }
-    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-    return h;
+  if (_N_(_ittapi_global).api_initialized) {
+    if (ITTNOTIFY_NAME(string_handle_createW) &&
+        ITTNOTIFY_NAME(string_handle_createW) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createW), _init))) {
+  for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->strW != NULL && !wcscmp(h->strW, name))
+      break;
+  if (h == NULL) {
+    NEW_STRING_HANDLE_W(&_N_(_ittapi_global), h, h_tail, name);
 }
 
-static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA),_init))(const char* name)
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create),_init))(const char* name)
+static __itt_string_handle *ITTAPI
+ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA), _init))(const char *name)
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+static __itt_string_handle *ITTAPI
+ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create), _init))(const char *name)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 {
-    __itt_string_handle *h_tail = NULL, *h = NULL;
 
-    if (name == NULL)
-    {
-        return NULL;
-    }
+  if (name == NULL) {
 
-    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
-    if (_N_(_ittapi_global).api_initialized)
-    {
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-        if (ITTNOTIFY_NAME(string_handle_createA) && ITTNOTIFY_NAME(string_handle_createA) != ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA),_init)))
-        {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(string_handle_createA)(name);
-        }
+  if (_N_(_ittapi_global).api_initialized) {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+    if (ITTNOTIFY_NAME(string_handle_createA) &&
+        ITTNOTIFY_NAME(string_handle_createA) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_createA), _init))) {
 #else
-        if (ITTNOTIFY_NAME(string_handle_create) && ITTNOTIFY_NAME(string_handle_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create),_init)))
-        {
-            if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(string_handle_create)(name);
-        }
+    if (ITTNOTIFY_NAME(string_handle_create) &&
+        ITTNOTIFY_NAME(string_handle_create) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(string_handle_create), _init))) {
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 #endif
-    }
-    for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL; h_tail = h, h = h->next)
-    {
-        if (h->strA != NULL && !__itt_fstrcmp(h->strA, name)) break;
-    }
-    if (h == NULL)
-    {
-        NEW_STRING_HANDLE_A(&_N_(_ittapi_global),h,h_tail,name);
-    }
-    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-    return h;
+  for (h_tail = NULL, h = _N_(_ittapi_global).string_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->strA != NULL && !__itt_fstrcmp(h->strA, name))
+      break;
+  if (h == NULL) {
+    NEW_STRING_HANDLE_A(&_N_(_ittapi_global), h, h_tail, name);
+  if (PTHREAD_SYMBOLS)
+    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW),_init))(const wchar_t *name, const wchar_t *domain)
-{
-    __itt_counter_info_t *h_tail = NULL, *h = NULL;
-    __itt_metadata_type type = __itt_metadata_u64;
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
+    _N_(counter_createW), _init))(const wchar_t *name, const wchar_t *domain) {
 
-    if (name == NULL)
-    {
-        return NULL;
-    }
+  if (name == NULL) {
 
-    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
-    if (_N_(_ittapi_global).api_initialized)
-    {
-        if (ITTNOTIFY_NAME(counter_createW) && ITTNOTIFY_NAME(counter_createW) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW),_init)))
-        {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(counter_createW)(name, domain);
-        }
-    }
-    for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next)
-    {
-        if (h->nameW != NULL  && h->type == type && !wcscmp(h->nameW, name) && ((h->domainW == NULL && domain == NULL) ||
-            (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain)))) break;
-
-    }
-    if (h == NULL)
-    {
-        NEW_COUNTER_W(&_N_(_ittapi_global),h,h_tail,name,domain,type);
-    }
-    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-    return (__itt_counter)h;
+  if (_N_(_ittapi_global).api_initialized) {
+    if (ITTNOTIFY_NAME(counter_createW) &&
+        ITTNOTIFY_NAME(counter_createW) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW), _init))) {
+  for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->nameW != NULL && h->type == type && !wcscmp(h->nameW, name) &&
+        ((h->domainW == NULL && domain == NULL) ||
+         (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))
+      break;
+  if (h == NULL) {
+    NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);
 }
 
-static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),_init))(const char *name, const char *domain)
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),_init))(const char *name, const char *domain)
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),
+                                                    _init))(const char *name,
+                                                            const char *domain)
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),
+                                                    _init))(const char *name,
+                                                            const char *domain)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 {
-    __itt_counter_info_t *h_tail = NULL, *h = NULL;
-    __itt_metadata_type type = __itt_metadata_u64;
 
-    if (name == NULL)
-    {
-        return NULL;
-    }
+  if (name == NULL) {
 
-    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
-    if (_N_(_ittapi_global).api_initialized)
-    {
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-        if (ITTNOTIFY_NAME(counter_createA) && ITTNOTIFY_NAME(counter_createA) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA),_init)))
-        {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(counter_createA)(name, domain);
-        }
+  if (_N_(_ittapi_global).api_initialized) {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+    if (ITTNOTIFY_NAME(counter_createA) &&
+        ITTNOTIFY_NAME(counter_createA) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createA), _init))) {
 #else
-        if (ITTNOTIFY_NAME(counter_create) && ITTNOTIFY_NAME(counter_create) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),_init)))
-        {
-            if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(counter_create)(name, domain);
-        }
+    if (ITTNOTIFY_NAME(counter_create) &&
+        ITTNOTIFY_NAME(counter_create) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create), _init))) {
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 #endif
-    }
-    for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next)
-    {
-        if (h->nameA != NULL  && h->type == type && !__itt_fstrcmp(h->nameA, name) && ((h->domainA == NULL && domain == NULL) ||
-            (h->domainA != NULL && domain != NULL && !__itt_fstrcmp(h->domainA, domain)))) break;
-    }
-    if (h == NULL)
-    {
-       NEW_COUNTER_A(&_N_(_ittapi_global),h,h_tail,name,domain,type);
-    }
-    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-    return (__itt_counter)h;
+  for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->nameA != NULL && h->type == type && !__itt_fstrcmp(h->nameA, name) &&
+        ((h->domainA == NULL && domain == NULL) ||
+         (h->domainA != NULL && domain != NULL &&
+          !__itt_fstrcmp(h->domainA, domain))))
+      break;
+  if (h == NULL) {
+    NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);
+  if (PTHREAD_SYMBOLS)
+    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),_init))(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)
-{
-    __itt_counter_info_t *h_tail = NULL, *h = NULL;
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),
+                                                    _init))(
+    const wchar_t *name, const wchar_t *domain, __itt_metadata_type type) {
 
-    if (name == NULL)
-    {
-        return NULL;
-    }
+  if (name == NULL) {
 
-    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
-    if (_N_(_ittapi_global).api_initialized)
-    {
-        if (ITTNOTIFY_NAME(counter_create_typedW) && ITTNOTIFY_NAME(counter_create_typedW) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW),_init)))
-        {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(counter_create_typedW)(name, domain, type);
-        }
-    }
-    for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next)
-    {
-        if (h->nameW != NULL  && h->type == type && !wcscmp(h->nameW, name) && ((h->domainW == NULL && domain == NULL) ||
-            (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain)))) break;
-
-    }
-    if (h == NULL)
-    {
-        NEW_COUNTER_W(&_N_(_ittapi_global),h,h_tail,name,domain,type);
-    }
-    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-    return (__itt_counter)h;
+  if (_N_(_ittapi_global).api_initialized) {
+    if (ITTNOTIFY_NAME(counter_create_typedW) &&
+        ITTNOTIFY_NAME(counter_create_typedW) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedW), _init))) {
+  for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->nameW != NULL && h->type == type && !wcscmp(h->nameW, name) &&
+        ((h->domainW == NULL && domain == NULL) ||
+         (h->domainW != NULL && domain != NULL && !wcscmp(h->domainW, domain))))
+      break;
+  if (h == NULL) {
+    NEW_COUNTER_W(&_N_(_ittapi_global), h, h_tail, name, domain, type);
 }
 
-static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA),_init))(const char *name, const char *domain, __itt_metadata_type type)
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed),_init))(const char *name, const char *domain, __itt_metadata_type type)
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
+    _N_(counter_create_typedA), _init))(const char *name, const char *domain,
+                                        __itt_metadata_type type)
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(
+    _N_(counter_create_typed), _init))(const char *name, const char *domain,
+                                       __itt_metadata_type type)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 {
-    __itt_counter_info_t *h_tail = NULL, *h = NULL;
 
-    if (name == NULL)
-    {
-        return NULL;
-    }
+  if (name == NULL) {
 
-    ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
-    if (_N_(_ittapi_global).api_initialized)
-    {
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-        if (ITTNOTIFY_NAME(counter_create_typedA) && ITTNOTIFY_NAME(counter_create_typedA) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA),_init)))
-        {
-            __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(counter_create_typedA)(name, domain, type);
-        }
+  if (_N_(_ittapi_global).api_initialized) {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+    if (ITTNOTIFY_NAME(counter_create_typedA) &&
+        ITTNOTIFY_NAME(counter_create_typedA) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typedA), _init))) {
 #else
-        if (ITTNOTIFY_NAME(counter_create_typed) && ITTNOTIFY_NAME(counter_create_typed) != ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed),_init)))
-        {
-            if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-            return ITTNOTIFY_NAME(counter_create_typed)(name, domain, type);
-        }
+    if (ITTNOTIFY_NAME(counter_create_typed) &&
+        ITTNOTIFY_NAME(counter_create_typed) !=
+            ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_typed), _init))) {
+      if (PTHREAD_SYMBOLS)
+        __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 #endif
-    }
-    for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL; h_tail = h, h = h->next)
-    {
-        if (h->nameA != NULL  && h->type == type && !__itt_fstrcmp(h->nameA, name) && ((h->domainA == NULL && domain == NULL) ||
-            (h->domainA != NULL && domain != NULL && !__itt_fstrcmp(h->domainA, domain)))) break;
-    }
-    if (h == NULL)
-    {
-       NEW_COUNTER_A(&_N_(_ittapi_global),h,h_tail,name,domain,type);
-    }
-    if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-    return (__itt_counter)h;
+  for (h_tail = NULL, h = _N_(_ittapi_global).counter_list; h != NULL;
+       h_tail = h, h = h->next) {
+    if (h->nameA != NULL && h->type == type && !__itt_fstrcmp(h->nameA, name) &&
+        ((h->domainA == NULL && domain == NULL) ||
+         (h->domainA != NULL && domain != NULL &&
+          !__itt_fstrcmp(h->domainA, domain))))
+      break;
+  if (h == NULL) {
+    NEW_COUNTER_A(&_N_(_ittapi_global), h, h_tail, name, domain, type);
+  if (PTHREAD_SYMBOLS)
+    __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 }
 
 /* -------------------------------------------------------------------------- */
 
-static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(pause),_init))(void)
-{
-    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
-    {
-        __itt_init_ittlib_name(NULL, __itt_group_all);
-    }
-    if (ITTNOTIFY_NAME(pause) && ITTNOTIFY_NAME(pause) != ITT_VERSIONIZE(ITT_JOIN(_N_(pause),_init)))
-    {
-        ITTNOTIFY_NAME(pause)();
-    }
-    else
-    {
-        _N_(_ittapi_global).state = __itt_collection_paused;
-    }
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(pause), _init))(void) {
+  if (!_N_(_ittapi_global).api_initialized &&
+      _N_(_ittapi_global).thread_list == NULL) {
+  if (ITTNOTIFY_NAME(pause) &&
+      ITTNOTIFY_NAME(pause) != ITT_VERSIONIZE(ITT_JOIN(_N_(pause), _init))) {
+  } else {
 }
 
-static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(resume),_init))(void)
-{
-    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
-    {
-        __itt_init_ittlib_name(NULL, __itt_group_all);
-    }
-    if (ITTNOTIFY_NAME(resume) && ITTNOTIFY_NAME(resume) != ITT_VERSIONIZE(ITT_JOIN(_N_(resume),_init)))
-    {
-        ITTNOTIFY_NAME(resume)();
-    }
-    else
-    {
-        _N_(_ittapi_global).state = __itt_collection_normal;
-    }
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(resume), _init))(void) {
+  if (!_N_(_ittapi_global).api_initialized &&
+      _N_(_ittapi_global).thread_list == NULL) {
+  if (ITTNOTIFY_NAME(resume) &&
+      ITTNOTIFY_NAME(resume) != ITT_VERSIONIZE(ITT_JOIN(_N_(resume), _init))) {
+  } else {
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),_init))(const wchar_t* name)
-{
-    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
-    {
-        __itt_init_ittlib_name(NULL, __itt_group_all);
-    }
-    if (ITTNOTIFY_NAME(thread_set_nameW) && ITTNOTIFY_NAME(thread_set_nameW) != ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),_init)))
-    {
-        ITTNOTIFY_NAME(thread_set_nameW)(name);
-    }
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),
+                                           _init))(const wchar_t *name) {
+  if (!_N_(_ittapi_global).api_initialized &&
+      _N_(_ittapi_global).thread_list == NULL) {
+  if (ITTNOTIFY_NAME(thread_set_nameW) &&
+      ITTNOTIFY_NAME(thread_set_nameW) !=
+          ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW), _init))) {
 }
 
-static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setW),_init))(const wchar_t* name, int namelen)
-{
-    (void)namelen;
-    ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW),_init))(name);
-    return 0;
+static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setW),
+                                          _init))(const wchar_t *name,
+                                                  int namelen) {
+  ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameW), _init))(name);
 }
 
-static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),_init))(const char* name)
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),_init))(const char* name)
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),
+                                           _init))(const char *name)
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),
+                                           _init))(const char *name)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 {
-    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
-    {
-        __itt_init_ittlib_name(NULL, __itt_group_all);
-    }
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-    if (ITTNOTIFY_NAME(thread_set_nameA) && ITTNOTIFY_NAME(thread_set_nameA) != ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),_init)))
-    {
-        ITTNOTIFY_NAME(thread_set_nameA)(name);
-    }
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-    if (ITTNOTIFY_NAME(thread_set_name) && ITTNOTIFY_NAME(thread_set_name) != ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),_init)))
-    {
-        ITTNOTIFY_NAME(thread_set_name)(name);
-    }
+  if (!_N_(_ittapi_global).api_initialized &&
+      _N_(_ittapi_global).thread_list == NULL) {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+  if (ITTNOTIFY_NAME(thread_set_nameA) &&
+      ITTNOTIFY_NAME(thread_set_nameA) !=
+          ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA), _init))) {
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+  if (ITTNOTIFY_NAME(thread_set_name) &&
+      ITTNOTIFY_NAME(thread_set_name) !=
+          ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name), _init))) {
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setA),_init))(const char* name, int namelen)
-{
-    (void)namelen;
-    ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA),_init))(name);
-    return 0;
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_setA),
+                                          _init))(const char *name,
+                                                  int namelen) {
+  ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_nameA), _init))(name);
 }
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_set),_init))(const char* name, int namelen)
-{
-    (void)namelen;
-    ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name),_init))(name);
-    return 0;
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+static int ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_name_set),
+                                          _init))(const char *name,
+                                                  int namelen) {
+  ITT_VERSIONIZE(ITT_JOIN(_N_(thread_set_name), _init))(name);
 }
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore),_init))(void)
-{
-    if (!_N_(_ittapi_global).api_initialized && _N_(_ittapi_global).thread_list == NULL)
-    {
-        __itt_init_ittlib_name(NULL, __itt_group_all);
-    }
-    if (ITTNOTIFY_NAME(thread_ignore) && ITTNOTIFY_NAME(thread_ignore) != ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore),_init)))
-    {
-        ITTNOTIFY_NAME(thread_ignore)();
-    }
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))(void) {
+  if (!_N_(_ittapi_global).api_initialized &&
+      _N_(_ittapi_global).thread_list == NULL) {
+  if (ITTNOTIFY_NAME(thread_ignore) &&
+      ITTNOTIFY_NAME(thread_ignore) !=
+          ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))) {
 }
 
-static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_ignore),_init))(void)
-{
-    ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore),_init))();
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(thr_ignore), _init))(void) {
+  ITT_VERSIONIZE(ITT_JOIN(_N_(thread_ignore), _init))();
 }
 
-static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(enable_attach),_init))(void)
-{
+static void ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(enable_attach), _init))(void) {
 #ifdef __ANDROID__
-    /*
-     * if LIB_VAR_NAME env variable were set before then stay previous value
-     * else set default path
-    */
-    setenv(ITT_TO_STR(LIB_VAR_NAME), ANDROID_ITTNOTIFY_DEFAULT_PATH, 0);
 #endif
 }
 
 /* -------------------------------------------------------------------------- */
 
-static const char* __itt_fsplit(const char* s, const char* sep, const char** out, int* len)
-{
-    int i;
-    int j;
+static const char *__itt_fsplit(const char *s, const char *sep,
+                                const char **out, int *len) {
 
-    if (!s || !sep || !out || !len)
-        return NULL;
 
-    for (i = 0; s[i]; i++)
-    {
-        int b = 0;
-        for (j = 0; sep[j]; j++)
-            if (s[i] == sep[j])
-            {
-                b = 1;
-                break;
-            }
-        if (!b)
-            break;
-    }
+  for (i = 0; s[i]; i++) {
+      if (s[i] == sep[j]) {
 
-    if (!s[i])
-        return NULL;
 
-    *len = 0;
-    *out = &s[i];
 
-    for (; s[i]; i++, (*len)++)
-    {
-        int b = 0;
-        for (j = 0; sep[j]; j++)
-            if (s[i] == sep[j])
-            {
-                b = 1;
-                break;
-            }
-        if (b)
-            break;
-    }
+  for (; s[i]; i++, (*len)++) {
+      if (s[i] == sep[j]) {
 
-    for (; s[i]; i++)
-    {
-        int b = 0;
-        for (j = 0; sep[j]; j++)
-            if (s[i] == sep[j])
-            {
-                b = 1;
-                break;
-            }
-        if (!b)
-            break;
-    }
+  for (; s[i]; i++) {
+      if (s[i] == sep[j]) {
 
-    return &s[i];
 }
 
 /* This function return value of env variable that placed into static buffer.
  * !!! The same static buffer is used for subsequent calls. !!!
  * This was done to avoid dynamic allocation for few calls.
  * Actually we need this function only four times.
  */
-static const char* __itt_get_env_var(const char* name)
-{
+static const char *__itt_get_env_var(const char *name) {
 #define MAX_ENV_VALUE_SIZE 4086
-    static char  env_buff[MAX_ENV_VALUE_SIZE];
-    static char* env_value = (char*)env_buff;
+  static char env_buff[MAX_ENV_VALUE_SIZE];
+  static char *env_value = (char *)env_buff;
 
-    if (name != NULL)
-    {
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-        size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff);
-        DWORD rc = GetEnvironmentVariableA(name, env_value, (DWORD)max_len);
-        if (rc >= max_len)
-            __itt_report_error(__itt_error_env_too_long, name, (size_t)rc - 1, (size_t)(max_len - 1));
-        else if (rc > 0)
-        {
-            const char* ret = (const char*)env_value;
-            env_value += rc + 1;
-            return ret;
-        }
-        else
-        {
-            /* If environment variable is empty, GetEnvironmentVariables()
-             * returns zero (number of characters (not including terminating null),
-             * and GetLastError() returns ERROR_SUCCESS. */
-            DWORD err = GetLastError();
-            if (err == ERROR_SUCCESS)
-                return env_value;
+  if (name != NULL) {
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+      __itt_report_error(__itt_error_env_too_long, name, (size_t)rc - 1,
+                         (size_t)(max_len - 1));
+    else if (rc > 0) {
+      const char *ret = (const char *)env_value;
+    } else {
 
-            if (err != ERROR_ENVVAR_NOT_FOUND)
-                __itt_report_error(__itt_error_cant_read_env, name, (int)err);
-        }
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-        char* env = getenv(name);
-        if (env != NULL)
-        {
-            size_t len = __itt_fstrnlen(env, MAX_ENV_VALUE_SIZE);
-            size_t max_len = MAX_ENV_VALUE_SIZE - (size_t)(env_value - env_buff);
-            if (len < max_len)
-            {
-                const char* ret = (const char*)env_value;
-                __itt_fstrcpyn(env_value, max_len, env, len + 1);
-                env_value += len + 1;
-                return ret;
-            } else
-                __itt_report_error(__itt_error_env_too_long, name, (size_t)len, (size_t)(max_len - 1));
-        }
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+    char *env = getenv(name);
+    if (env != NULL) {
+      if (len < max_len) {
+        const char *ret = (const char *)env_value;
+        __itt_report_error(__itt_error_env_too_long, name, (size_t)len,
+                           (size_t)(max_len - 1));
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-    }
-    return NULL;
 }
 
-static const char* __itt_get_lib_name(void)
-{
-    const char* lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));
+static const char *__itt_get_lib_name(void) {
+  const char *lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));
 
 #ifdef __ANDROID__
-    if (lib_name == NULL)
-    {
+  if (lib_name == NULL) {
 
-#if ITT_ARCH==ITT_ARCH_IA32 || ITT_ARCH==ITT_ARCH_ARM
-        const char* const marker_filename = "com.intel.itt.collector_lib_32";
+#if ITT_ARCH == ITT_ARCH_IA32 || ITT_ARCH == ITT_ARCH_ARM
+    const char *const marker_filename = "com.intel.itt.collector_lib_32";
 #else
-        const char* const marker_filename = "com.intel.itt.collector_lib_64";
+    const char *const marker_filename = "com.intel.itt.collector_lib_64";
 #endif
 
-        char system_wide_marker_filename[PATH_MAX] = {0};
-        int itt_marker_file_fd = -1;
-        ssize_t res = 0;
 
-        res = snprintf(system_wide_marker_filename, PATH_MAX - 1, "%s%s", "/data/local/tmp/", marker_filename);
-        if (res < 0)
-        {
-            ITT_ANDROID_LOGE("Unable to concatenate marker file string.");
-            return lib_name;
-        }
-        itt_marker_file_fd = open(system_wide_marker_filename, O_RDONLY);
+    res = snprintf(system_wide_marker_filename, PATH_MAX - 1, "%s%s",
+                   "/data/local/tmp/", marker_filename);
+    if (res < 0) {
 
-        if (itt_marker_file_fd == -1)
-        {
-            const pid_t my_pid = getpid();
-            char cmdline_path[PATH_MAX] = {0};
-            char package_name[PATH_MAX] = {0};
-            char app_sandbox_file[PATH_MAX] = {0};
-            int cmdline_fd = 0;
+    if (itt_marker_file_fd == -1) {
 
-            ITT_ANDROID_LOGI("Unable to open system-wide marker file.");
-            res = snprintf(cmdline_path, PATH_MAX - 1, "/proc/%d/cmdline", my_pid);
-            if (res < 0)
-            {
-                ITT_ANDROID_LOGE("Unable to get cmdline path string.");
-                return lib_name;
-            }
+      if (res < 0) {
 
-            ITT_ANDROID_LOGI("CMD file: %s\n", cmdline_path);
-            cmdline_fd = open(cmdline_path, O_RDONLY);
-            if (cmdline_fd == -1)
-            {
-                ITT_ANDROID_LOGE("Unable to open %s file!", cmdline_path);
-                return lib_name;
-            }
-            res = read(cmdline_fd, package_name, PATH_MAX - 1);
-            if (res == -1)
-            {
-                ITT_ANDROID_LOGE("Unable to read %s file!", cmdline_path);
-                res = close(cmdline_fd);
-                if (res == -1)
-                {
-                    ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);
-                }
-                return lib_name;
-            }
-            res = close(cmdline_fd);
-            if (res == -1)
-            {
-                ITT_ANDROID_LOGE("Unable to close %s file!", cmdline_path);
-                return lib_name;
-            }
-            ITT_ANDROID_LOGI("Package name: %s\n", package_name);
-            res = snprintf(app_sandbox_file, PATH_MAX - 1, "/data/data/%s/%s", package_name, marker_filename);
-            if (res < 0)
-            {
-                ITT_ANDROID_LOGE("Unable to concatenate marker file string.");
-                return lib_name;
-            }
+      if (cmdline_fd == -1) {
+      if (res == -1) {
+        if (res == -1) {
+      if (res == -1) {
+      res = snprintf(app_sandbox_file, PATH_MAX - 1, "/data/data/%s/%s",
+                     package_name, marker_filename);
+      if (res < 0) {
 
-            ITT_ANDROID_LOGI("Lib marker file name: %s\n", app_sandbox_file);
-            itt_marker_file_fd = open(app_sandbox_file, O_RDONLY);
-            if (itt_marker_file_fd == -1)
-            {
-                ITT_ANDROID_LOGE("Unable to open app marker file!");
-                return lib_name;
-            }
-        }
+      if (itt_marker_file_fd == -1) {
 
-        {
-            char itt_lib_name[PATH_MAX] = {0};
 
-            res = read(itt_marker_file_fd, itt_lib_name, PATH_MAX - 1);
-            if (res == -1)
-            {
-                ITT_ANDROID_LOGE("Unable to read %s file!", itt_marker_file_fd);
-                res = close(itt_marker_file_fd);
-                if (res == -1)
-                {
-                    ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);
-                }
-                return lib_name;
-            }
-            ITT_ANDROID_LOGI("ITT Lib path: %s", itt_lib_name);
-            res = close(itt_marker_file_fd);
-            if (res == -1)
-            {
-                ITT_ANDROID_LOGE("Unable to close %s file!", itt_marker_file_fd);
-                return lib_name;
-            }
-            ITT_ANDROID_LOGI("Set env %s to %s", ITT_TO_STR(LIB_VAR_NAME), itt_lib_name);
-            res = setenv(ITT_TO_STR(LIB_VAR_NAME), itt_lib_name, 0);
-            if (res == -1)
-            {
-                ITT_ANDROID_LOGE("Unable to set env var!");
-                return lib_name;
-            }
-            lib_name = __itt_get_env_var(ITT_TO_STR(LIB_VAR_NAME));
-            ITT_ANDROID_LOGI("ITT Lib path from env: %s", lib_name);
-        }
-    }
+      if (res == -1) {
+        if (res == -1) {
+      if (res == -1) {
+      ITT_ANDROID_LOGI("Set env %s to %s", ITT_TO_STR(LIB_VAR_NAME),
+                       itt_lib_name);
+      if (res == -1) {
 #endif
 
-    return lib_name;
 }
 
 /* Avoid clashes with std::min, reported by tbb team */
-#define __itt_min(a,b) (a) < (b) ? (a) : (b)
+#define __itt_min(a, b) (a) < (b) ? (a) : (b)
 
-static __itt_group_id __itt_get_groups(void)
-{
-    int i;
-    __itt_group_id res = __itt_group_none;
-    const char* var_name  = "INTEL_ITTNOTIFY_GROUPS";
-    const char* group_str = __itt_get_env_var(var_name);
+static __itt_group_id __itt_get_groups(void) {
+  const char *var_name = "INTEL_ITTNOTIFY_GROUPS";
+  const char *group_str = __itt_get_env_var(var_name);
 
-    if (group_str != NULL)
-    {
-        int len;
-        char gr[255];
-        const char* chunk;
-        while ((group_str = __itt_fsplit(group_str, ",; ", &chunk, &len)) != NULL)
-        {
-            int min_len = __itt_min(len, (int)(sizeof(gr) - 1));
-            __itt_fstrcpyn(gr, sizeof(gr) - 1, chunk,  min_len);
-            gr[min_len] = 0;
+  if (group_str != NULL) {
+    const char *chunk;
+    while ((group_str = __itt_fsplit(group_str, ",; ", &chunk, &len)) != NULL) {
+      __itt_fstrcpyn(gr, sizeof(gr) - 1, chunk, min_len);
 
-            for (i = 0; group_list[i].name != NULL; i++)
-            {
-                if (!__itt_fstrcmp(gr, group_list[i].name))
-                {
-                    res = (__itt_group_id)(res | group_list[i].id);
-                    break;
-                }
-            }
-        }
-        /* TODO: !!! Workaround for bug with warning for unknown group !!!
-         * Should be fixed in new initialization scheme.
-         * Now the following groups should be set always. */
-        for (i = 0; group_list[i].id != __itt_group_none; i++)
-            if (group_list[i].id != __itt_group_all &&
-                group_list[i].id > __itt_group_splitter_min &&
-                group_list[i].id < __itt_group_splitter_max)
-                res = (__itt_group_id)(res | group_list[i].id);
-        return res;
-    }
-    else
-    {
-        for (i = 0; group_alias[i].env_var != NULL; i++)
-            if (__itt_get_env_var(group_alias[i].env_var) != NULL)
-                return group_alias[i].groups;
-    }
+      for (i = 0; group_list[i].name != NULL; i++) {
+        if (!__itt_fstrcmp(gr, group_list[i].name)) {
+  } else {
 
-    return res;
 }
 
 #undef __itt_min
 
-static int __itt_lib_version(lib_t lib)
-{
-    if (lib == NULL)
-        return 0;
-    if (__itt_get_proc(lib, "__itt_api_init"))
-        return 2;
-    if (__itt_get_proc(lib, "__itt_api_version"))
-        return 1;
-    return 0;
+static int __itt_lib_version(lib_t lib) {
 }
 
 /* It's not used right now! Comment it out to avoid warnings.
 static void __itt_reinit_all_pointers(void)
 {
     int i;
     // Fill all pointers with initial stubs
     for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
-        *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].init_func;
+        *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
+_N_(_ittapi_global).api_list_ptr[i].init_func;
 }
 */
 
-static void __itt_nullify_all_pointers(void)
-{
-    int i;
-    /* Nullify all pointers except domain_create, string_handle_create  and counter_create */
-    for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
-        *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func;
+static void __itt_nullify_all_pointers(void) {
+  /* Nullify all pointers except domain_create, string_handle_create  and
+   * counter_create */
+    *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
+        _N_(_ittapi_global).api_list_ptr[i].null_func;
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
 #pragma warning(push)
-#pragma warning(disable: 4054) /* warning C4054: 'type cast' : from function pointer 'XXX' to data pointer 'void *' */
-#pragma warning(disable: 4055) /* warning C4055: 'type cast' : from data pointer 'void *' to function pointer 'XXX' */
+#pragma warning(disable : 4054) /* warning C4054: 'type cast' : from function  \
+                                   pointer 'XXX' to data pointer 'void *' */
+#pragma warning(                                                               \
+    disable : 4055) /* warning C4055: 'type cast' : from data pointer 'void *' \
+                       to function pointer 'XXX' */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
-ITT_EXTERN_C void _N_(fini_ittlib)(void)
-{
-    __itt_api_fini_t* __itt_api_fini_ptr = NULL;
-    static volatile TIDT current_thread = 0;
+ITT_EXTERN_C void _N_(fini_ittlib)(void) {
+  __itt_api_fini_t *__itt_api_fini_ptr = NULL;
 
-    if (_N_(_ittapi_global).api_initialized)
-    {
-        ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
-        if (_N_(_ittapi_global).api_initialized)
-        {
-            if (current_thread == 0)
-            {
-                if (PTHREAD_SYMBOLS) current_thread = __itt_thread_id();
-                if (_N_(_ittapi_global).lib != NULL)
-                {
-                    __itt_api_fini_ptr = (__itt_api_fini_t*)(size_t)__itt_get_proc(_N_(_ittapi_global).lib, "__itt_api_fini");
-                }
-                if (__itt_api_fini_ptr)
-                {
-                    __itt_api_fini_ptr(&_N_(_ittapi_global));
-                }
+  if (_N_(_ittapi_global).api_initialized) {
+    if (_N_(_ittapi_global).api_initialized) {
+      if (current_thread == 0) {
+        if (PTHREAD_SYMBOLS)
+          current_thread = __itt_thread_id();
+        if (_N_(_ittapi_global).lib != NULL) {
+          __itt_api_fini_ptr = (__itt_api_fini_t *)(size_t)__itt_get_proc(
+              _N_(_ittapi_global).lib, "__itt_api_fini");
+        if (__itt_api_fini_ptr) {
 
-                __itt_nullify_all_pointers();
 
         /* TODO: !!! not safe !!! don't support unload so far.
          *             if (_N_(_ittapi_global).lib != NULL)
          *                 __itt_unload_lib(_N_(_ittapi_global).lib);
          *             _N_(_ittapi_global).lib = NULL;
          */
-                _N_(_ittapi_global).api_initialized = 0;
-                current_thread = 0;
-            }
-        }
-        if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
-    }
+    if (PTHREAD_SYMBOLS)
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 }
 
-ITT_EXTERN_C int _N_(init_ittlib)(const char* lib_name, __itt_group_id init_groups)
-{
-    int i;
-    __itt_group_id groups;
+ITT_EXTERN_C int _N_(init_ittlib)(const char *lib_name,
+                                  __itt_group_id init_groups) {
 #ifdef ITT_COMPLETE_GROUP
-    __itt_group_id zero_group = __itt_group_none;
 #endif /* ITT_COMPLETE_GROUP */
-    static volatile TIDT current_thread = 0;
 
-    if (!_N_(_ittapi_global).api_initialized)
-    {
+  if (!_N_(_ittapi_global).api_initialized) {
 #ifndef ITT_SIMPLE_INIT
-        ITT_MUTEX_INIT_AND_LOCK(_N_(_ittapi_global));
 #endif /* ITT_SIMPLE_INIT */
 
-        if (!_N_(_ittapi_global).api_initialized)
-        {
-            if (current_thread == 0)
-            {
-                if (PTHREAD_SYMBOLS) current_thread = __itt_thread_id();
-                if (lib_name == NULL)
-                {
-                    lib_name = __itt_get_lib_name();
-                }
-                groups = __itt_get_groups();
-                if (DL_SYMBOLS && (groups != __itt_group_none || lib_name != NULL))
-                {
-                    _N_(_ittapi_global).lib = __itt_load_lib((lib_name == NULL) ? ittnotify_lib_name : lib_name);
+    if (!_N_(_ittapi_global).api_initialized) {
+      if (current_thread == 0) {
+        if (PTHREAD_SYMBOLS)
+          current_thread = __itt_thread_id();
+        if (lib_name == NULL) {
+        if (DL_SYMBOLS && (groups != __itt_group_none || lib_name != NULL)) {
+          _N_(_ittapi_global).lib = __itt_load_lib(
+              (lib_name == NULL) ? ittnotify_lib_name : lib_name);
 
-                    if (_N_(_ittapi_global).lib != NULL)
-                    {
-                        __itt_api_init_t* __itt_api_init_ptr;
-                        int lib_version = __itt_lib_version(_N_(_ittapi_global).lib);
+          if (_N_(_ittapi_global).lib != NULL) {
+            __itt_api_init_t *__itt_api_init_ptr;
 
-                        switch (lib_version) {
-                        case 0:
-                            groups = __itt_group_legacy;
-                            KMP_FALLTHROUGH();
-                        case 1:
-                            /* Fill all pointers from dynamic library */
-                            for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
-                            {
-                                if (_N_(_ittapi_global).api_list_ptr[i].group & groups & init_groups)
-                                {
-                                    *_N_(_ittapi_global).api_list_ptr[i].func_ptr = (void*)__itt_get_proc(_N_(_ittapi_global).lib, _N_(_ittapi_global).api_list_ptr[i].name);
-                                    if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr == NULL)
-                                    {
-                                        /* Restore pointers for function with static implementation */
-                                        *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func;
-                                        __itt_report_error(__itt_error_no_symbol, lib_name, _N_(_ittapi_global).api_list_ptr[i].name);
+              for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL;
+                   i++) {
+                if (_N_(_ittapi_global).api_list_ptr[i].group & groups &
+                    init_groups) {
+                  *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
+                      (void *)__itt_get_proc(
+                          _N_(_ittapi_global).lib,
+                          _N_(_ittapi_global).api_list_ptr[i].name);
+                  if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr == NULL) {
+                    /* Restore pointers for function with static implementation
+                     */
+                    *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
+                        _N_(_ittapi_global).api_list_ptr[i].null_func;
+                    __itt_report_error(
+                        __itt_error_no_symbol, lib_name,
+                        _N_(_ittapi_global).api_list_ptr[i].name);
 #ifdef ITT_COMPLETE_GROUP
-                                        zero_group = (__itt_group_id)(zero_group | _N_(_ittapi_global).api_list_ptr[i].group);
+                    zero_group =
+                        (__itt_group_id)(zero_group | _N_(_ittapi_global)
+                                                          .api_list_ptr[i]
+                                                          .group);
 #endif /* ITT_COMPLETE_GROUP */
-                                    }
-                                }
-                                else
-                                    *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func;
-                            }
+                } else
+                  *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
+                      _N_(_ittapi_global).api_list_ptr[i].null_func;
 
-                            if (groups == __itt_group_legacy)
-                            {
-                                /* Compatibility with legacy tools */
-                                ITTNOTIFY_NAME(thread_ignore)  = ITTNOTIFY_NAME(thr_ignore);
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-                                ITTNOTIFY_NAME(sync_createA)   = ITTNOTIFY_NAME(sync_set_nameA);
-                                ITTNOTIFY_NAME(sync_createW)   = ITTNOTIFY_NAME(sync_set_nameW);
-#else  /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
-                                ITTNOTIFY_NAME(sync_create)    = ITTNOTIFY_NAME(sync_set_name);
+              if (groups == __itt_group_legacy) {
+                ITTNOTIFY_NAME(thread_ignore) = ITTNOTIFY_NAME(thr_ignore);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+                ITTNOTIFY_NAME(sync_createA) = ITTNOTIFY_NAME(sync_set_nameA);
+                ITTNOTIFY_NAME(sync_createW) = ITTNOTIFY_NAME(sync_set_nameW);
+#else /* ITT_PLATFORM!=ITT_PLATFORM_WIN */
+                ITTNOTIFY_NAME(sync_create) = ITTNOTIFY_NAME(sync_set_name);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-                                ITTNOTIFY_NAME(sync_prepare)   = ITTNOTIFY_NAME(notify_sync_prepare);
-                                ITTNOTIFY_NAME(sync_cancel)    = ITTNOTIFY_NAME(notify_sync_cancel);
-                                ITTNOTIFY_NAME(sync_acquired)  = ITTNOTIFY_NAME(notify_sync_acquired);
-                                ITTNOTIFY_NAME(sync_releasing) = ITTNOTIFY_NAME(notify_sync_releasing);
-                            }
+                ITTNOTIFY_NAME(sync_prepare) =
+                    ITTNOTIFY_NAME(notify_sync_prepare);
+                ITTNOTIFY_NAME(sync_cancel) =
+                    ITTNOTIFY_NAME(notify_sync_cancel);
+                ITTNOTIFY_NAME(sync_acquired) =
+                    ITTNOTIFY_NAME(notify_sync_acquired);
+                ITTNOTIFY_NAME(sync_releasing) =
+                    ITTNOTIFY_NAME(notify_sync_releasing);
 
 #ifdef ITT_COMPLETE_GROUP
-                            for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
-                                if (_N_(_ittapi_global).api_list_ptr[i].group & zero_group)
-                                    *_N_(_ittapi_global).api_list_ptr[i].func_ptr = _N_(_ittapi_global).api_list_ptr[i].null_func;
+                  *_N_(_ittapi_global).api_list_ptr[i].func_ptr =
+                      _N_(_ittapi_global).api_list_ptr[i].null_func;
 #endif /* ITT_COMPLETE_GROUP */
-                            break;
-                        case 2:
-                            __itt_api_init_ptr = (__itt_api_init_t*)(size_t)__itt_get_proc(_N_(_ittapi_global).lib, "__itt_api_init");
-                            if (__itt_api_init_ptr)
-                                __itt_api_init_ptr(&_N_(_ittapi_global), init_groups);
-                            break;
-                        }
-                    }
-                    else
-                    {
-                        __itt_nullify_all_pointers();
+              __itt_api_init_ptr = (__itt_api_init_t *)(size_t)__itt_get_proc(
+                  _N_(_ittapi_global).lib, "__itt_api_init");
+          } else {
 
-                        __itt_report_error(__itt_error_no_module, lib_name,
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
                                __itt_system_error()
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
                                dlerror()
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-                        );
-                    }
-                }
-                else
-                {
-                    __itt_nullify_all_pointers();
-                }
-                _N_(_ittapi_global).api_initialized = 1;
-                current_thread = 0;
-                /* !!! Just to avoid unused code elimination !!! */
-                if (__itt_fini_ittlib_ptr == _N_(fini_ittlib)) current_thread = 0;
-            }
-        }
+        } else {
+        if (__itt_fini_ittlib_ptr == _N_(fini_ittlib))
+          current_thread = 0;
 
 #ifndef ITT_SIMPLE_INIT
-        if (PTHREAD_SYMBOLS) __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
+    if (PTHREAD_SYMBOLS)
+      __itt_mutex_unlock(&_N_(_ittapi_global).mutex);
 #endif /* ITT_SIMPLE_INIT */
-    }
 
-    /* Evaluating if any function ptr is non empty and it's in init_groups */
-    for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++)
-    {
-        if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr != _N_(_ittapi_global).api_list_ptr[i].null_func &&
-            _N_(_ittapi_global).api_list_ptr[i].group & init_groups)
-        {
-            return 1;
-        }
-    }
-    return 0;
+  for (i = 0; _N_(_ittapi_global).api_list_ptr[i].name != NULL; i++) {
+    if (*_N_(_ittapi_global).api_list_ptr[i].func_ptr !=
+            _N_(_ittapi_global).api_list_ptr[i].null_func &&
+        _N_(_ittapi_global).api_list_ptr[i].group & init_groups) {
 }
 
-ITT_EXTERN_C __itt_error_handler_t* _N_(set_error_handler)(__itt_error_handler_t* handler)
-{
-    __itt_error_handler_t* prev = (__itt_error_handler_t*)(size_t)_N_(_ittapi_global).error_handler;
-    _N_(_ittapi_global).error_handler = (void*)(size_t)handler;
-    return prev;
+ITT_EXTERN_C __itt_error_handler_t *
+_N_(set_error_handler)(__itt_error_handler_t *handler) {
+  __itt_error_handler_t *prev =
+      (__itt_error_handler_t *)(size_t)_N_(_ittapi_global).error_handler;
+  _N_(_ittapi_global).error_handler = (void *)(size_t)handler;
 }
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
+#if ITT_PLATFORM == ITT_PLATFORM_WIN && KMP_MSVC_COMPAT
 #pragma warning(pop)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */

openmp/runtime/src/thirdparty/ittnotify/ittnotify_types.h

 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef _ITTNOTIFY_TYPES_H_
 #define _ITTNOTIFY_TYPES_H_
 
-typedef enum ___itt_group_id
-{
-    __itt_group_none      = 0,
-    __itt_group_legacy    = 1<<0,
-    __itt_group_control   = 1<<1,
-    __itt_group_thread    = 1<<2,
-    __itt_group_mark      = 1<<3,
-    __itt_group_sync      = 1<<4,
-    __itt_group_fsync     = 1<<5,
-    __itt_group_jit       = 1<<6,
-    __itt_group_model     = 1<<7,
-    __itt_group_splitter_min = 1<<7,
-    __itt_group_counter   = 1<<8,
-    __itt_group_frame     = 1<<9,
-    __itt_group_stitch    = 1<<10,
-    __itt_group_heap      = 1<<11,
-    __itt_group_splitter_max = 1<<12,
-    __itt_group_structure = 1<<12,
-    __itt_group_suppress = 1<<13,
-    __itt_group_arrays    = 1<<14,
-    __itt_group_all       = -1
+typedef enum ___itt_group_id {
+  __itt_group_none = 0,
+  __itt_group_legacy = 1 << 0,
+  __itt_group_control = 1 << 1,
+  __itt_group_thread = 1 << 2,
+  __itt_group_mark = 1 << 3,
+  __itt_group_sync = 1 << 4,
+  __itt_group_fsync = 1 << 5,
+  __itt_group_jit = 1 << 6,
+  __itt_group_model = 1 << 7,
+  __itt_group_splitter_min = 1 << 7,
+  __itt_group_counter = 1 << 8,
+  __itt_group_frame = 1 << 9,
+  __itt_group_stitch = 1 << 10,
+  __itt_group_heap = 1 << 11,
+  __itt_group_splitter_max = 1 << 12,
+  __itt_group_structure = 1 << 12,
+  __itt_group_suppress = 1 << 13,
+  __itt_group_arrays = 1 << 14,
+  __itt_group_all = -1
 } __itt_group_id;
 
 #pragma pack(push, 8)
 
-typedef struct ___itt_group_list
-{
-    __itt_group_id id;
-    const char*    name;
+typedef struct ___itt_group_list {
+  const char *name;
 } __itt_group_list;
 
 #pragma pack(pop)
 
-#define ITT_GROUP_LIST(varname) \
-    static __itt_group_list varname[] = {       \
-        { __itt_group_all,       "all"       }, \
-        { __itt_group_control,   "control"   }, \
-        { __itt_group_thread,    "thread"    }, \
-        { __itt_group_mark,      "mark"      }, \
-        { __itt_group_sync,      "sync"      }, \
-        { __itt_group_fsync,     "fsync"     }, \
-        { __itt_group_jit,       "jit"       }, \
-        { __itt_group_model,     "model"     }, \
-        { __itt_group_counter,   "counter"   }, \
-        { __itt_group_frame,     "frame"     }, \
-        { __itt_group_stitch,    "stitch"    }, \
-        { __itt_group_heap,      "heap"      }, \
-        { __itt_group_structure, "structure" }, \
-        { __itt_group_suppress,  "suppress"  }, \
-        { __itt_group_arrays,    "arrays"    }, \
-        { __itt_group_none,      NULL        }  \
-    }
+#define ITT_GROUP_LIST(varname)                                                \
+  static __itt_group_list varname[] = {{__itt_group_all, "all"},               \
+                                       {__itt_group_control, "control"},       \
+                                       {__itt_group_thread, "thread"},         \
+                                       {__itt_group_mark, "mark"},             \
+                                       {__itt_group_sync, "sync"},             \
+                                       {__itt_group_fsync, "fsync"},           \
+                                       {__itt_group_jit, "jit"},               \
+                                       {__itt_group_model, "model"},           \
+                                       {__itt_group_counter, "counter"},       \
+                                       {__itt_group_frame, "frame"},           \
+                                       {__itt_group_stitch, "stitch"},         \
+                                       {__itt_group_heap, "heap"},             \
+                                       {__itt_group_structure, "structure"},   \
+                                       {__itt_group_suppress, "suppress"},     \
+                                       {__itt_group_arrays, "arrays"},         \
+                                       {__itt_group_none, NULL}}
 
 #endif /* _ITTNOTIFY_TYPES_H_ */

openmp/runtime/src/thirdparty/ittnotify/legacy/ittnotify.h

 
 /**
  * @file
  * @brief Legacy User API functions and types
  */
 
 /** @cond exclude_from_documentation */
 #ifndef ITT_OS_WIN
-#  define ITT_OS_WIN   1
+#define ITT_OS_WIN 1
 #endif /* ITT_OS_WIN */
 
 #ifndef ITT_OS_LINUX
-#  define ITT_OS_LINUX 2
+#define ITT_OS_LINUX 2
 #endif /* ITT_OS_LINUX */
 
 #ifndef ITT_OS_MAC
-#  define ITT_OS_MAC   3
+#define ITT_OS_MAC 3
 #endif /* ITT_OS_MAC */
 
 #ifndef ITT_OS_FREEBSD
-#  define ITT_OS_FREEBSD   4
+#define ITT_OS_FREEBSD 4
 #endif /* ITT_OS_FREEBSD */
 
 #ifndef ITT_OS
-#  if defined WIN32 || defined _WIN32
-#    define ITT_OS ITT_OS_WIN
-#  elif defined( __APPLE__ ) && defined( __MACH__ )
-#    define ITT_OS ITT_OS_MAC
-#  elif defined( __FreeBSD__ )
-#    define ITT_OS ITT_OS_FREEBSD
-#  else
-#    define ITT_OS ITT_OS_LINUX
-#  endif
+#if defined WIN32 || defined _WIN32
+#define ITT_OS ITT_OS_WIN
+#elif defined(__APPLE__) && defined(__MACH__)
+#define ITT_OS ITT_OS_MAC
+#elif defined(__FreeBSD__)
+#define ITT_OS ITT_OS_FREEBSD
+#else
+#define ITT_OS ITT_OS_LINUX
+#endif
 #endif /* ITT_OS */
 
 #ifndef ITT_PLATFORM_WIN
-#  define ITT_PLATFORM_WIN 1
+#define ITT_PLATFORM_WIN 1
 #endif /* ITT_PLATFORM_WIN */
 
 #ifndef ITT_PLATFORM_POSIX
-#  define ITT_PLATFORM_POSIX 2
+#define ITT_PLATFORM_POSIX 2
 #endif /* ITT_PLATFORM_POSIX */
 
 #ifndef ITT_PLATFORM_MAC
-#  define ITT_PLATFORM_MAC 3
+#define ITT_PLATFORM_MAC 3
 #endif /* ITT_PLATFORM_MAC */
 
 #ifndef ITT_PLATFORM_FREEBSD
-#  define ITT_PLATFORM_FREEBSD 4
+#define ITT_PLATFORM_FREEBSD 4
 #endif /* ITT_PLATFORM_FREEBSD */
 
 #ifndef ITT_PLATFORM
-#  if ITT_OS==ITT_OS_WIN
-#    define ITT_PLATFORM ITT_PLATFORM_WIN
-#  elif ITT_OS==ITT_OS_MAC
-#    define ITT_PLATFORM ITT_PLATFORM_MAC
-#  elif ITT_OS==ITT_OS_FREEBSD
-#    define ITT_PLATFORM ITT_PLATFORM_FREEBSD
-#  else
-#    define ITT_PLATFORM ITT_PLATFORM_POSIX
-#  endif
+#if ITT_OS == ITT_OS_WIN
+#define ITT_PLATFORM ITT_PLATFORM_WIN
+#elif ITT_OS == ITT_OS_MAC
+#define ITT_PLATFORM ITT_PLATFORM_MAC
+#elif ITT_OS == ITT_OS_FREEBSD
+#define ITT_PLATFORM ITT_PLATFORM_FREEBSD
+#else
+#define ITT_PLATFORM ITT_PLATFORM_POSIX
+#endif
 #endif /* ITT_PLATFORM */
 
 #if defined(_UNICODE) && !defined(UNICODE)
 #define UNICODE
 #endif
 
 #include <stddef.h>
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #include <tchar.h>
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #include <stdint.h>
 #if defined(UNICODE) || defined(_UNICODE)
 #include <wchar.h>
 #endif /* UNICODE || _UNICODE */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 #ifndef ITTAPI_CDECL
-#  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    define ITTAPI_CDECL __cdecl
-#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#    if defined _M_IX86 || defined __i386__
-#      define ITTAPI_CDECL __attribute__ ((cdecl))
-#    else  /* _M_IX86 || __i386__ */
-#      define ITTAPI_CDECL /* actual only on x86 platform */
-#    endif /* _M_IX86 || __i386__ */
-#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define ITTAPI_CDECL __cdecl
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if defined _M_IX86 || defined __i386__
+#define ITTAPI_CDECL __attribute__((cdecl))
+#else /* _M_IX86 || __i386__ */
+#define ITTAPI_CDECL /* actual only on x86 platform */
+#endif /* _M_IX86 || __i386__ */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* ITTAPI_CDECL */
 
 #ifndef STDCALL
-#  if ITT_PLATFORM==ITT_PLATFORM_WIN
-#    define STDCALL __stdcall
-#  else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#    if defined _M_IX86 || defined __i386__
-#      define STDCALL __attribute__ ((stdcall))
-#    else  /* _M_IX86 || __i386__ */
-#      define STDCALL /* supported only on x86 platform */
-#    endif /* _M_IX86 || __i386__ */
-#  endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define STDCALL __stdcall
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#if defined _M_IX86 || defined __i386__
+#define STDCALL __attribute__((stdcall))
+#else /* _M_IX86 || __i386__ */
+#define STDCALL /* supported only on x86 platform */
+#endif /* _M_IX86 || __i386__ */
+#endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* STDCALL */
 
-#define ITTAPI    ITTAPI_CDECL
+#define ITTAPI ITTAPI_CDECL
 #define LIBITTAPI ITTAPI_CDECL
 
 /* TODO: Temporary for compatibility! */
-#define ITTAPI_CALL    ITTAPI_CDECL
+#define ITTAPI_CALL ITTAPI_CDECL
 #define LIBITTAPI_CALL ITTAPI_CDECL
 
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 /* use __forceinline (VC++ specific) */
-#define ITT_INLINE           __forceinline
+#define ITT_INLINE __forceinline
 #define ITT_INLINE_ATTRIBUTE /* nothing */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 /*
  * Generally, functions are not inlined unless optimization is specified.
  * For functions declared inline, this attribute inlines the function even
  * if no optimization level was specified.
  */
 #ifdef __STRICT_ANSI__
-#define ITT_INLINE           static
+#define ITT_INLINE static
 #define ITT_INLINE_ATTRIBUTE __attribute__((unused))
-#else  /* __STRICT_ANSI__ */
-#define ITT_INLINE           static inline
+#else /* __STRICT_ANSI__ */
+#define ITT_INLINE static inline
 #define ITT_INLINE_ATTRIBUTE __attribute__((always_inline, unused))
 #endif /* __STRICT_ANSI__ */
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 /** @endcond */
 
 /** @cond exclude_from_documentation */
 /* Helper macro for joining tokens */
-#define ITT_JOIN_AUX(p,n) p##n
-#define ITT_JOIN(p,n)     ITT_JOIN_AUX(p,n)
+#define ITT_JOIN_AUX(p, n) p##n
+#define ITT_JOIN(p, n) ITT_JOIN_AUX(p, n)
 
 #ifdef ITT_MAJOR
 #undef ITT_MAJOR
 #endif
 #ifdef ITT_MINOR
 #undef ITT_MINOR
 #endif
-#define ITT_MAJOR     3
-#define ITT_MINOR     0
+#define ITT_MAJOR 3
+#define ITT_MINOR 0
 
 /* Standard versioning of a token with major and minor version numbers */
-#define ITT_VERSIONIZE(x)    \
-    ITT_JOIN(x,              \
-    ITT_JOIN(_,              \
-    ITT_JOIN(ITT_MAJOR,      \
-    ITT_JOIN(_, ITT_MINOR))))
+#define ITT_VERSIONIZE(x)                                                      \
+  ITT_JOIN(x, ITT_JOIN(_, ITT_JOIN(ITT_MAJOR, ITT_JOIN(_, ITT_MINOR))))
 
 #ifndef INTEL_ITTNOTIFY_PREFIX
-#  define INTEL_ITTNOTIFY_PREFIX __itt_
+#define INTEL_ITTNOTIFY_PREFIX __itt_
 #endif /* INTEL_ITTNOTIFY_PREFIX */
 #ifndef INTEL_ITTNOTIFY_POSTFIX
-#  define INTEL_ITTNOTIFY_POSTFIX _ptr_
+#define INTEL_ITTNOTIFY_POSTFIX _ptr_
 #endif /* INTEL_ITTNOTIFY_POSTFIX */
 
-#define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX,n)
-#define ITTNOTIFY_NAME(n)     ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n,INTEL_ITTNOTIFY_POSTFIX)))
+#define ITTNOTIFY_NAME_AUX(n) ITT_JOIN(INTEL_ITTNOTIFY_PREFIX, n)
+#define ITTNOTIFY_NAME(n)                                                      \
+  ITT_VERSIONIZE(ITTNOTIFY_NAME_AUX(ITT_JOIN(n, INTEL_ITTNOTIFY_POSTFIX)))
 
 #define ITTNOTIFY_VOID(n) (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)
-#define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)
+#define ITTNOTIFY_DATA(n) (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)
 
-#define ITTNOTIFY_VOID_D0(n,d)       (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d)
-#define ITTNOTIFY_VOID_D1(n,d,x)     (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x)
-#define ITTNOTIFY_VOID_D2(n,d,x,y)   (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y)
-#define ITTNOTIFY_VOID_D3(n,d,x,y,z) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z)
-#define ITTNOTIFY_VOID_D4(n,d,x,y,z,a)     (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
-#define ITTNOTIFY_VOID_D5(n,d,x,y,z,a,b)   (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
-#define ITTNOTIFY_VOID_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? (void)0 : (!ITTNOTIFY_NAME(n)) ? (void)0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
-#define ITTNOTIFY_DATA_D0(n,d)       (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d)
-#define ITTNOTIFY_DATA_D1(n,d,x)     (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x)
-#define ITTNOTIFY_DATA_D2(n,d,x,y)   (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y)
-#define ITTNOTIFY_DATA_D3(n,d,x,y,z) (!(d)->flags) ?       0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z)
-#define ITTNOTIFY_DATA_D4(n,d,x,y,z,a)     (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z,a)
-#define ITTNOTIFY_DATA_D5(n,d,x,y,z,a,b)   (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b)
-#define ITTNOTIFY_DATA_D6(n,d,x,y,z,a,b,c) (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ?       0 : ITTNOTIFY_NAME(n)(d,x,y,z,a,b,c)
+#define ITTNOTIFY_VOID_D0(n, d)                                                \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d)
+#define ITTNOTIFY_VOID_D1(n, d, x)                                             \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x)
+#define ITTNOTIFY_VOID_D2(n, d, x, y)                                          \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y)
+#define ITTNOTIFY_VOID_D3(n, d, x, y, z)                                       \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z)
+#define ITTNOTIFY_VOID_D4(n, d, x, y, z, a)                                    \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a)
+#define ITTNOTIFY_VOID_D5(n, d, x, y, z, a, b)                                 \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a, b)
+#define ITTNOTIFY_VOID_D6(n, d, x, y, z, a, b, c)                              \
+  (!(d)->flags)          ? (void)0                                             \
+  : (!ITTNOTIFY_NAME(n)) ? (void)0                                             \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c)
+#define ITTNOTIFY_DATA_D0(n, d)                                                \
+  (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d)
+#define ITTNOTIFY_DATA_D1(n, d, x)                                             \
+  (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x)
+#define ITTNOTIFY_DATA_D2(n, d, x, y)                                          \
+  (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y)
+#define ITTNOTIFY_DATA_D3(n, d, x, y, z)                                       \
+  (!(d)->flags) ? 0 : (!ITTNOTIFY_NAME(n)) ? 0 : ITTNOTIFY_NAME(n)(d, x, y, z)
+#define ITTNOTIFY_DATA_D4(n, d, x, y, z, a)                                    \
+  (!(d)->flags)          ? 0                                                   \
+  : (!ITTNOTIFY_NAME(n)) ? 0                                                   \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a)
+#define ITTNOTIFY_DATA_D5(n, d, x, y, z, a, b)                                 \
+  (!(d)->flags)          ? 0                                                   \
+  : (!ITTNOTIFY_NAME(n)) ? 0                                                   \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a, b)
+#define ITTNOTIFY_DATA_D6(n, d, x, y, z, a, b, c)                              \
+  (!(d)->flags)          ? 0                                                   \
+  : (!ITTNOTIFY_NAME(n)) ? 0                                                   \
+                         : ITTNOTIFY_NAME(n)(d, x, y, z, a, b, c)
 
 #ifdef ITT_STUB
 #undef ITT_STUB
 #endif
 #ifdef ITT_STUBV
 #undef ITT_STUBV
 #endif
-#define ITT_STUBV(api,type,name,args)                             \
-    typedef type (api* ITT_JOIN(ITTNOTIFY_NAME(name),_t)) args;   \
-    extern ITT_JOIN(ITTNOTIFY_NAME(name),_t) ITTNOTIFY_NAME(name);
+#define ITT_STUBV(api, type, name, args)                                       \
+  typedef type(api *ITT_JOIN(ITTNOTIFY_NAME(name), _t)) args;                  \
+  extern ITT_JOIN(ITTNOTIFY_NAME(name), _t) ITTNOTIFY_NAME(name);
 #define ITT_STUB ITT_STUBV
 /** @endcond */
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
 /**
  * @defgroup legacy Legacy API
  * @{
  * @}
  */
 
 /**
  * @defgroup legacy_control Collection Control
  * @ingroup legacy
- * General behavior: application continues to run, but no profiling information is being collected
+ * General behavior: application continues to run, but no profiling information
+ * is being collected
  *
- * Pausing occurs not only for the current thread but for all process as well as spawned processes
+ * Pausing occurs not only for the current thread but for all process as well as
+ * spawned processes
  * - Intel(R) Parallel Inspector and Intel(R) Inspector XE:
  *   - Does not analyze or report errors that involve memory access.
  *   - Other errors are reported as usual. Pausing data collection in
  *     Intel(R) Parallel Inspector and Intel(R) Inspector XE
  *     only pauses tracing and analyzing memory access.
  *     It does not pause tracing or analyzing threading APIs.
  *   .
  * - Intel(R) Parallel Amplifier and Intel(R) VTune(TM) Amplifier XE:

 /** @brief Resume collection */
 void ITTAPI __itt_resume(void);
 /** @brief Detach collection */
 void ITTAPI __itt_detach(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUBV(ITTAPI, void, pause,   (void))
-ITT_STUBV(ITTAPI, void, resume,  (void))
-ITT_STUBV(ITTAPI, void, detach,  (void))
-#define __itt_pause      ITTNOTIFY_VOID(pause)
-#define __itt_pause_ptr  ITTNOTIFY_NAME(pause)
-#define __itt_resume     ITTNOTIFY_VOID(resume)
+ITT_STUBV(ITTAPI, void, pause, (void))
+ITT_STUBV(ITTAPI, void, resume, (void))
+ITT_STUBV(ITTAPI, void, detach, (void))
+#define __itt_pause ITTNOTIFY_VOID(pause)
+#define __itt_pause_ptr ITTNOTIFY_NAME(pause)
+#define __itt_resume ITTNOTIFY_VOID(resume)
 #define __itt_resume_ptr ITTNOTIFY_NAME(resume)
-#define __itt_detach     ITTNOTIFY_VOID(detach)
+#define __itt_detach ITTNOTIFY_VOID(detach)
 #define __itt_detach_ptr ITTNOTIFY_NAME(detach)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_pause()
-#define __itt_pause_ptr  0
+#define __itt_pause_ptr 0
 #define __itt_resume()
 #define __itt_resume_ptr 0
 #define __itt_detach()
 #define __itt_detach_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#define __itt_pause_ptr  0
+#else /* INTEL_NO_MACRO_BODY */
+#define __itt_pause_ptr 0
 #define __itt_resume_ptr 0
 #define __itt_detach_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 #endif /* _ITTNOTIFY_H_ */
 /** @} legacy_control group */
 
 /**
  * @defgroup legacy_threads Threads
  * @ingroup legacy
  * Threads group
  * @warning Legacy API
  * @{
  */
 /**
  * @deprecated Legacy API
  * @brief Set name to be associated with thread in analysis GUI.
- * @return __itt_err upon failure (name or namelen being null,name and namelen mismatched)
+ * @return __itt_err upon failure (name or namelen being null,name and namelen
+ * mismatched)
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-int LIBITTAPI __itt_thr_name_setA(const char    *name, int namelen);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+int LIBITTAPI __itt_thr_name_setA(const char *name, int namelen);
 int LIBITTAPI __itt_thr_name_setW(const wchar_t *name, int namelen);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_thr_name_set     __itt_thr_name_setW
-#  define __itt_thr_name_set_ptr __itt_thr_name_setW_ptr
+#define __itt_thr_name_set __itt_thr_name_setW
+#define __itt_thr_name_set_ptr __itt_thr_name_setW_ptr
 #else
-#  define __itt_thr_name_set     __itt_thr_name_setA
-#  define __itt_thr_name_set_ptr __itt_thr_name_setA_ptr
+#define __itt_thr_name_set __itt_thr_name_setA
+#define __itt_thr_name_set_ptr __itt_thr_name_setA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 int LIBITTAPI __itt_thr_name_set(const char *name, int namelen);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(LIBITTAPI, int, thr_name_setA, (const char    *name, int namelen))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, int, thr_name_setA, (const char *name, int namelen))
 ITT_STUB(LIBITTAPI, int, thr_name_setW, (const wchar_t *name, int namelen))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(LIBITTAPI, int, thr_name_set,  (const char    *name, int namelen))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int, thr_name_set, (const char *name, int namelen))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_thr_name_setA     ITTNOTIFY_DATA(thr_name_setA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_thr_name_setA ITTNOTIFY_DATA(thr_name_setA)
 #define __itt_thr_name_setA_ptr ITTNOTIFY_NAME(thr_name_setA)
-#define __itt_thr_name_setW     ITTNOTIFY_DATA(thr_name_setW)
+#define __itt_thr_name_setW ITTNOTIFY_DATA(thr_name_setW)
 #define __itt_thr_name_setW_ptr ITTNOTIFY_NAME(thr_name_setW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_thr_name_set     ITTNOTIFY_DATA(thr_name_set)
+#define __itt_thr_name_set ITTNOTIFY_DATA(thr_name_set)
 #define __itt_thr_name_set_ptr ITTNOTIFY_NAME(thr_name_set)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_thr_name_setA(name, namelen)
 #define __itt_thr_name_setA_ptr 0
 #define __itt_thr_name_setW(name, namelen)
 #define __itt_thr_name_setW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_thr_name_set(name, namelen)
 #define __itt_thr_name_set_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_thr_name_setA_ptr 0
 #define __itt_thr_name_setW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_thr_name_set_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
- * @brief Mark current thread as ignored from this point on, for the duration of its existence.
+ * @brief Mark current thread as ignored from this point on, for the duration of
+ * its existence.
  */
 void LIBITTAPI __itt_thr_ignore(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(LIBITTAPI, void, thr_ignore, (void))
-#define __itt_thr_ignore     ITTNOTIFY_VOID(thr_ignore)
+#define __itt_thr_ignore ITTNOTIFY_VOID(thr_ignore)
 #define __itt_thr_ignore_ptr ITTNOTIFY_NAME(thr_ignore)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_thr_ignore()
 #define __itt_thr_ignore_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_thr_ignore_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} legacy_threads group */
 
 /**
  * @defgroup legacy_sync Synchronization
  * @ingroup legacy
  * Synchronization group
  * @warning Legacy API
  * @{
  */
 /**
  * @hideinitializer
  * @brief possible value of attribute argument for sync object type
  */
 #define __itt_attr_barrier 1
 
 /**
  * @hideinitializer
  * @brief possible value of attribute argument for sync object type
  */
-#define __itt_attr_mutex   2
+#define __itt_attr_mutex 2
 
 /**
  * @deprecated Legacy API
  * @brief Assign a name to a sync object using char or Unicode string
- * @param[in] addr    - pointer to the sync object. You should use a real pointer to your object
- *                      to make sure that the values don't clash with other object addresses
- * @param[in] objtype - null-terminated object type string. If NULL is passed, the object will
- *                      be assumed to be of generic "User Synchronization" type
- * @param[in] objname - null-terminated object name string. If NULL, no name will be assigned
- *                      to the object -- you can use the __itt_sync_rename call later to assign
- *                      the name
- * @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values which defines the
- *                      exact semantics of how prepare/acquired/releasing calls work.
- */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-void ITTAPI __itt_sync_set_nameA(void *addr, const char    *objtype, const char    *objname, int attribute);
-void ITTAPI __itt_sync_set_nameW(void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute);
+ * @param[in] addr    - pointer to the sync object. You should use a real
+ * pointer to your object to make sure that the values don't clash with other
+ * object addresses
+ * @param[in] objtype - null-terminated object type string. If NULL is passed,
+ * the object will be assumed to be of generic "User Synchronization" type
+ * @param[in] objname - null-terminated object name string. If NULL, no name
+ * will be assigned to the object -- you can use the __itt_sync_rename call
+ * later to assign the name
+ * @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values
+ * which defines the exact semantics of how prepare/acquired/releasing calls
+ * work.
+ */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+void ITTAPI __itt_sync_set_nameA(void *addr, const char *objtype,
+                                 const char *objname, int attribute);
+void ITTAPI __itt_sync_set_nameW(void *addr, const wchar_t *objtype,
+                                 const wchar_t *objname, int attribute);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_sync_set_name     __itt_sync_set_nameW
-#  define __itt_sync_set_name_ptr __itt_sync_set_nameW_ptr
+#define __itt_sync_set_name __itt_sync_set_nameW
+#define __itt_sync_set_name_ptr __itt_sync_set_nameW_ptr
 #else /* UNICODE */
-#  define __itt_sync_set_name     __itt_sync_set_nameA
-#  define __itt_sync_set_name_ptr __itt_sync_set_nameA_ptr
+#define __itt_sync_set_name __itt_sync_set_nameA
+#define __itt_sync_set_name_ptr __itt_sync_set_nameA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-void ITTAPI __itt_sync_set_name(void *addr, const char* objtype, const char* objname, int attribute);
+void ITTAPI __itt_sync_set_name(void *addr, const char *objtype,
+                                const char *objname, int attribute);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUBV(ITTAPI, void, sync_set_nameA, (void *addr, const char    *objtype, const char    *objname, int attribute))
-ITT_STUBV(ITTAPI, void, sync_set_nameW, (void *addr, const wchar_t *objtype, const wchar_t *objname, int attribute))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUBV(ITTAPI, void, sync_set_name,  (void *addr, const char    *objtype, const char    *objname, int attribute))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUBV(ITTAPI, void, sync_set_nameA,
+          (void *addr, const char *objtype, const char *objname, int attribute))
+ITT_STUBV(ITTAPI, void, sync_set_nameW,
+          (void *addr, const wchar_t *objtype, const wchar_t *objname,
+           int attribute))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUBV(ITTAPI, void, sync_set_name,
+          (void *addr, const char *objtype, const char *objname, int attribute))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_sync_set_nameA     ITTNOTIFY_VOID(sync_set_nameA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_sync_set_nameA ITTNOTIFY_VOID(sync_set_nameA)
 #define __itt_sync_set_nameA_ptr ITTNOTIFY_NAME(sync_set_nameA)
-#define __itt_sync_set_nameW     ITTNOTIFY_VOID(sync_set_nameW)
+#define __itt_sync_set_nameW ITTNOTIFY_VOID(sync_set_nameW)
 #define __itt_sync_set_nameW_ptr ITTNOTIFY_NAME(sync_set_nameW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_sync_set_name     ITTNOTIFY_VOID(sync_set_name)
+#define __itt_sync_set_name ITTNOTIFY_VOID(sync_set_name)
 #define __itt_sync_set_name_ptr ITTNOTIFY_NAME(sync_set_name)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_sync_set_nameA(addr, objtype, objname, attribute)
 #define __itt_sync_set_nameA_ptr 0
 #define __itt_sync_set_nameW(addr, objtype, objname, attribute)
 #define __itt_sync_set_nameW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_sync_set_name(addr, objtype, objname, attribute)
 #define __itt_sync_set_name_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_sync_set_nameA_ptr 0
 #define __itt_sync_set_nameW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_sync_set_name_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief Assign a name and type to a sync object using char or Unicode string
- * @param[in] addr -      pointer to the sync object. You should use a real pointer to your object
- *                        to make sure that the values don't clash with other object addresses
- * @param[in] objtype -   null-terminated object type string. If NULL is passed, the object will
- *                        be assumed to be of generic "User Synchronization" type
- * @param[in] objname -   null-terminated object name string. If NULL, no name will be assigned
- *                        to the object -- you can use the __itt_sync_rename call later to assign
- *                        the name
- * @param[in] typelen, namelen -   a length of string for appropriate objtype and objname parameter
- * @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values which defines the
- *                        exact semantics of how prepare/acquired/releasing calls work.
- * @return __itt_err upon failure (name or namelen being null,name and namelen mismatched)
- */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-int LIBITTAPI __itt_notify_sync_nameA(void *addr, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute);
-int LIBITTAPI __itt_notify_sync_nameW(void *addr, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute);
+ * @param[in] addr -      pointer to the sync object. You should use a real
+ * pointer to your object to make sure that the values don't clash with other
+ * object addresses
+ * @param[in] objtype -   null-terminated object type string. If NULL is passed,
+ * the object will be assumed to be of generic "User Synchronization" type
+ * @param[in] objname -   null-terminated object name string. If NULL, no name
+ * will be assigned to the object -- you can use the __itt_sync_rename call
+ * later to assign the name
+ * @param[in] typelen, namelen -   a length of string for appropriate objtype
+ * and objname parameter
+ * @param[in] attribute - one of [#__itt_attr_barrier, #__itt_attr_mutex] values
+ * which defines the exact semantics of how prepare/acquired/releasing calls
+ * work.
+ * @return __itt_err upon failure (name or namelen being null,name and namelen
+ * mismatched)
+ */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+int LIBITTAPI __itt_notify_sync_nameA(void *addr, const char *objtype,
+                                      int typelen, const char *objname,
+                                      int namelen, int attribute);
+int LIBITTAPI __itt_notify_sync_nameW(void *addr, const wchar_t *objtype,
+                                      int typelen, const wchar_t *objname,
+                                      int namelen, int attribute);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_notify_sync_name __itt_notify_sync_nameW
+#define __itt_notify_sync_name __itt_notify_sync_nameW
 #else
-#  define __itt_notify_sync_name __itt_notify_sync_nameA
+#define __itt_notify_sync_name __itt_notify_sync_nameA
 #endif
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-int LIBITTAPI __itt_notify_sync_name(void *addr, const char *objtype, int typelen, const char *objname, int namelen, int attribute);
+int LIBITTAPI __itt_notify_sync_name(void *addr, const char *objtype,
+                                     int typelen, const char *objname,
+                                     int namelen, int attribute);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(LIBITTAPI, int, notify_sync_nameA, (void *addr, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute))
-ITT_STUB(LIBITTAPI, int, notify_sync_nameW, (void *addr, const wchar_t *objtype, int typelen, const wchar_t *objname, int namelen, int attribute))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(LIBITTAPI, int, notify_sync_name,  (void *addr, const char    *objtype, int typelen, const char    *objname, int namelen, int attribute))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, int, notify_sync_nameA,
+         (void *addr, const char *objtype, int typelen, const char *objname,
+          int namelen, int attribute))
+ITT_STUB(LIBITTAPI, int, notify_sync_nameW,
+         (void *addr, const wchar_t *objtype, int typelen,
+          const wchar_t *objname, int namelen, int attribute))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, int, notify_sync_name,
+         (void *addr, const char *objtype, int typelen, const char *objname,
+          int namelen, int attribute))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_notify_sync_nameA     ITTNOTIFY_DATA(notify_sync_nameA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_notify_sync_nameA ITTNOTIFY_DATA(notify_sync_nameA)
 #define __itt_notify_sync_nameA_ptr ITTNOTIFY_NAME(notify_sync_nameA)
-#define __itt_notify_sync_nameW     ITTNOTIFY_DATA(notify_sync_nameW)
+#define __itt_notify_sync_nameW ITTNOTIFY_DATA(notify_sync_nameW)
 #define __itt_notify_sync_nameW_ptr ITTNOTIFY_NAME(notify_sync_nameW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_notify_sync_name     ITTNOTIFY_DATA(notify_sync_name)
+#define __itt_notify_sync_name ITTNOTIFY_DATA(notify_sync_name)
 #define __itt_notify_sync_name_ptr ITTNOTIFY_NAME(notify_sync_name)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_notify_sync_nameA(addr, objtype, typelen, objname, namelen, attribute)
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_notify_sync_nameA(addr, objtype, typelen, objname, namelen,      \
+                                attribute)
 #define __itt_notify_sync_nameA_ptr 0
-#define __itt_notify_sync_nameW(addr, objtype, typelen, objname, namelen, attribute)
+#define __itt_notify_sync_nameW(addr, objtype, typelen, objname, namelen,      \
+                                attribute)
 #define __itt_notify_sync_nameW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_notify_sync_name(addr, objtype, typelen, objname, namelen, attribute)
+#define __itt_notify_sync_name(addr, objtype, typelen, objname, namelen,       \
+                               attribute)
 #define __itt_notify_sync_name_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_notify_sync_nameA_ptr 0
 #define __itt_notify_sync_nameW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_notify_sync_name_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief Enter spin loop on user-defined sync object
  */
-void LIBITTAPI __itt_notify_sync_prepare(void* addr);
+void LIBITTAPI __itt_notify_sync_prepare(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(LIBITTAPI, void, notify_sync_prepare, (void *addr))
-#define __itt_notify_sync_prepare     ITTNOTIFY_VOID(notify_sync_prepare)
+#define __itt_notify_sync_prepare ITTNOTIFY_VOID(notify_sync_prepare)
 #define __itt_notify_sync_prepare_ptr ITTNOTIFY_NAME(notify_sync_prepare)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_notify_sync_prepare(addr)
 #define __itt_notify_sync_prepare_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_notify_sync_prepare_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief Quit spin loop without acquiring spin object
  */
 void LIBITTAPI __itt_notify_sync_cancel(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(LIBITTAPI, void, notify_sync_cancel, (void *addr))
-#define __itt_notify_sync_cancel     ITTNOTIFY_VOID(notify_sync_cancel)
+#define __itt_notify_sync_cancel ITTNOTIFY_VOID(notify_sync_cancel)
 #define __itt_notify_sync_cancel_ptr ITTNOTIFY_NAME(notify_sync_cancel)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_notify_sync_cancel(addr)
 #define __itt_notify_sync_cancel_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_notify_sync_cancel_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief Successful spin loop completion (sync object acquired)
  */
 void LIBITTAPI __itt_notify_sync_acquired(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(LIBITTAPI, void, notify_sync_acquired, (void *addr))
-#define __itt_notify_sync_acquired     ITTNOTIFY_VOID(notify_sync_acquired)
+#define __itt_notify_sync_acquired ITTNOTIFY_VOID(notify_sync_acquired)
 #define __itt_notify_sync_acquired_ptr ITTNOTIFY_NAME(notify_sync_acquired)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_notify_sync_acquired(addr)
 #define __itt_notify_sync_acquired_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_notify_sync_acquired_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
- * @brief Start sync object releasing code. Is called before the lock release call.
+ * @brief Start sync object releasing code. Is called before the lock release
+ * call.
  */
-void LIBITTAPI __itt_notify_sync_releasing(void* addr);
+void LIBITTAPI __itt_notify_sync_releasing(void *addr);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(LIBITTAPI, void, notify_sync_releasing, (void *addr))
-#define __itt_notify_sync_releasing     ITTNOTIFY_VOID(notify_sync_releasing)
+#define __itt_notify_sync_releasing ITTNOTIFY_VOID(notify_sync_releasing)
 #define __itt_notify_sync_releasing_ptr ITTNOTIFY_NAME(notify_sync_releasing)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_notify_sync_releasing(addr)
 #define __itt_notify_sync_releasing_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_notify_sync_releasing_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} legacy_sync group */
 
 #ifndef _ITTNOTIFY_H_
 /**
  * @defgroup legacy_events Events
  * @ingroup legacy
  * Events group
  * @{
  */
 
 /** @brief user event type */
 typedef int __itt_event;
 
 /**
  * @brief Create an event notification
- * @note name or namelen being null/name and namelen not matching, user event feature not enabled
+ * @note name or namelen being null/name and namelen not matching, user event
+ * feature not enabled
  * @return non-zero event identifier upon success and __itt_err otherwise
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_event LIBITTAPI __itt_event_createA(const char    *name, int namelen);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_event LIBITTAPI __itt_event_createA(const char *name, int namelen);
 __itt_event LIBITTAPI __itt_event_createW(const wchar_t *name, int namelen);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_event_create     __itt_event_createW
-#  define __itt_event_create_ptr __itt_event_createW_ptr
+#define __itt_event_create __itt_event_createW
+#define __itt_event_create_ptr __itt_event_createW_ptr
 #else
-#  define __itt_event_create     __itt_event_createA
-#  define __itt_event_create_ptr __itt_event_createA_ptr
+#define __itt_event_create __itt_event_createA
+#define __itt_event_create_ptr __itt_event_createA_ptr
 #endif /* UNICODE */
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 __itt_event LIBITTAPI __itt_event_create(const char *name, int namelen);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char    *name, int namelen))
-ITT_STUB(LIBITTAPI, __itt_event, event_createW, (const wchar_t *name, int namelen))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(LIBITTAPI, __itt_event, event_create,  (const char *name, int namelen))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(LIBITTAPI, __itt_event, event_createA, (const char *name, int namelen))
+ITT_STUB(LIBITTAPI, __itt_event, event_createW,
+         (const wchar_t *name, int namelen))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(LIBITTAPI, __itt_event, event_create, (const char *name, int namelen))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_event_createA     ITTNOTIFY_DATA(event_createA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_event_createA ITTNOTIFY_DATA(event_createA)
 #define __itt_event_createA_ptr ITTNOTIFY_NAME(event_createA)
-#define __itt_event_createW     ITTNOTIFY_DATA(event_createW)
+#define __itt_event_createW ITTNOTIFY_DATA(event_createW)
 #define __itt_event_createW_ptr ITTNOTIFY_NAME(event_createW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_event_create      ITTNOTIFY_DATA(event_create)
-#define __itt_event_create_ptr  ITTNOTIFY_NAME(event_create)
+#define __itt_event_create ITTNOTIFY_DATA(event_create)
+#define __itt_event_create_ptr ITTNOTIFY_NAME(event_create)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_event_createA(name, namelen) (__itt_event)0
 #define __itt_event_createA_ptr 0
 #define __itt_event_createW(name, namelen) (__itt_event)0
 #define __itt_event_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_event_create(name, namelen)  (__itt_event)0
-#define __itt_event_create_ptr  0
+#define __itt_event_create(name, namelen) (__itt_event)0
+#define __itt_event_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_event_createA_ptr 0
 #define __itt_event_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_event_create_ptr  0
+#define __itt_event_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record an event occurrence.
- * @return __itt_err upon failure (invalid event id/user event feature not enabled)
+ * @return __itt_err upon failure (invalid event id/user event feature not
+ * enabled)
  */
 int LIBITTAPI __itt_event_start(__itt_event event);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(LIBITTAPI, int, event_start, (__itt_event event))
-#define __itt_event_start     ITTNOTIFY_DATA(event_start)
+#define __itt_event_start ITTNOTIFY_DATA(event_start)
 #define __itt_event_start_ptr ITTNOTIFY_NAME(event_start)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_event_start(event) (int)0
 #define __itt_event_start_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_event_start_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @brief Record an event end occurrence.
  * @note It is optional if events do not have durations.
- * @return __itt_err upon failure (invalid event id/user event feature not enabled)
+ * @return __itt_err upon failure (invalid event id/user event feature not
+ * enabled)
  */
 int LIBITTAPI __itt_event_end(__itt_event event);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(LIBITTAPI, int, event_end, (__itt_event event))
-#define __itt_event_end     ITTNOTIFY_DATA(event_end)
+#define __itt_event_end ITTNOTIFY_DATA(event_end)
 #define __itt_event_end_ptr ITTNOTIFY_NAME(event_end)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_event_end(event) (int)0
 #define __itt_event_end_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_event_end_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} legacy_events group */
 #endif /* _ITTNOTIFY_H_ */
 
 /**
  * @defgroup legacy_memory Memory Accesses
  * @ingroup legacy
  */
 
 /**
  * @deprecated Legacy API
  * @brief Inform the tool of memory accesses on reading
  */
 void LIBITTAPI __itt_memory_read(void *addr, size_t size);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(LIBITTAPI, void, memory_read, (void *addr, size_t size))
-#define __itt_memory_read     ITTNOTIFY_VOID(memory_read)
+#define __itt_memory_read ITTNOTIFY_VOID(memory_read)
 #define __itt_memory_read_ptr ITTNOTIFY_NAME(memory_read)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_memory_read(addr, size)
 #define __itt_memory_read_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_memory_read_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief Inform the tool of memory accesses on writing
  */
 void LIBITTAPI __itt_memory_write(void *addr, size_t size);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(LIBITTAPI, void, memory_write, (void *addr, size_t size))
-#define __itt_memory_write     ITTNOTIFY_VOID(memory_write)
+#define __itt_memory_write ITTNOTIFY_VOID(memory_write)
 #define __itt_memory_write_ptr ITTNOTIFY_NAME(memory_write)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_memory_write(addr, size)
 #define __itt_memory_write_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_memory_write_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief Inform the tool of memory accesses on updating
  */
 void LIBITTAPI __itt_memory_update(void *address, size_t size);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(LIBITTAPI, void, memory_update, (void *addr, size_t size))
-#define __itt_memory_update     ITTNOTIFY_VOID(memory_update)
+#define __itt_memory_update ITTNOTIFY_VOID(memory_update)
 #define __itt_memory_update_ptr ITTNOTIFY_NAME(memory_update)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_memory_update(addr, size)
 #define __itt_memory_update_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_memory_update_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} legacy_memory group */
 
 /**
  * @defgroup legacy_state Thread and Object States
  * @ingroup legacy
  */
 
 /** @brief state type */
 typedef int __itt_state_t;
 
 /** @cond exclude_from_documentation */
 typedef enum __itt_obj_state {
-    __itt_obj_state_err = 0,
-    __itt_obj_state_clr = 1,
-    __itt_obj_state_set = 2,
-    __itt_obj_state_use = 3
 } __itt_obj_state_t;
 
 typedef enum __itt_thr_state {
-    __itt_thr_state_err = 0,
-    __itt_thr_state_clr = 1,
-    __itt_thr_state_set = 2
 } __itt_thr_state_t;
 
 typedef enum __itt_obj_prop {
-    __itt_obj_prop_watch    = 1,
-    __itt_obj_prop_ignore   = 2,
-    __itt_obj_prop_sharable = 3
+  __itt_obj_prop_watch = 1,
+  __itt_obj_prop_ignore = 2,
 } __itt_obj_prop_t;
 
-typedef enum __itt_thr_prop {
-    __itt_thr_prop_quiet = 1
-} __itt_thr_prop_t;
+typedef enum __itt_thr_prop { __itt_thr_prop_quiet = 1 } __itt_thr_prop_t;
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief managing thread and object states
  */
 __itt_state_t LIBITTAPI __itt_state_get(void);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(ITTAPI, __itt_state_t, state_get, (void))
-#define __itt_state_get     ITTNOTIFY_DATA(state_get)
+#define __itt_state_get ITTNOTIFY_DATA(state_get)
 #define __itt_state_get_ptr ITTNOTIFY_NAME(state_get)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_state_get(void) (__itt_state_t)0
 #define __itt_state_get_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_state_get_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief managing thread and object states
  */
 __itt_state_t LIBITTAPI __itt_state_set(__itt_state_t s);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUB(ITTAPI, __itt_state_t, state_set, (__itt_state_t s))
-#define __itt_state_set     ITTNOTIFY_DATA(state_set)
+#define __itt_state_set ITTNOTIFY_DATA(state_set)
 #define __itt_state_set_ptr ITTNOTIFY_NAME(state_set)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_state_set(s) (__itt_state_t)0
 #define __itt_state_set_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_state_set_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief managing thread and object modes
  */
-__itt_thr_state_t LIBITTAPI __itt_thr_mode_set(__itt_thr_prop_t p, __itt_thr_state_t s);
+__itt_thr_state_t LIBITTAPI __itt_thr_mode_set(__itt_thr_prop_t p,
+                                               __itt_thr_state_t s);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUB(ITTAPI, __itt_thr_state_t, thr_mode_set, (__itt_thr_prop_t p, __itt_thr_state_t s))
-#define __itt_thr_mode_set     ITTNOTIFY_DATA(thr_mode_set)
+ITT_STUB(ITTAPI, __itt_thr_state_t, thr_mode_set,
+         (__itt_thr_prop_t p, __itt_thr_state_t s))
+#define __itt_thr_mode_set ITTNOTIFY_DATA(thr_mode_set)
 #define __itt_thr_mode_set_ptr ITTNOTIFY_NAME(thr_mode_set)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_thr_mode_set(p, s) (__itt_thr_state_t)0
 #define __itt_thr_mode_set_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_thr_mode_set_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @deprecated Legacy API
  * @brief managing thread and object modes
  */
-__itt_obj_state_t LIBITTAPI __itt_obj_mode_set(__itt_obj_prop_t p, __itt_obj_state_t s);
+__itt_obj_state_t LIBITTAPI __itt_obj_mode_set(__itt_obj_prop_t p,
+                                               __itt_obj_state_t s);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-ITT_STUB(ITTAPI, __itt_obj_state_t, obj_mode_set, (__itt_obj_prop_t p, __itt_obj_state_t s))
-#define __itt_obj_mode_set     ITTNOTIFY_DATA(obj_mode_set)
+ITT_STUB(ITTAPI, __itt_obj_state_t, obj_mode_set,
+         (__itt_obj_prop_t p, __itt_obj_state_t s))
+#define __itt_obj_mode_set ITTNOTIFY_DATA(obj_mode_set)
 #define __itt_obj_mode_set_ptr ITTNOTIFY_NAME(obj_mode_set)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_obj_mode_set(p, s) (__itt_obj_state_t)0
 #define __itt_obj_mode_set_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_obj_mode_set_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} legacy_state group */
 
 /**
  * @defgroup frames Frames
  * @ingroup legacy
  * Frames group
  * @{
  */
 /**
  * @brief opaque structure for frame identification
  */
 typedef struct __itt_frame_t *__itt_frame;
 
 /**
  * @brief Create a global frame with given domain
  */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-__itt_frame ITTAPI __itt_frame_createA(const char    *domain);
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+__itt_frame ITTAPI __itt_frame_createA(const char *domain);
 __itt_frame ITTAPI __itt_frame_createW(const wchar_t *domain);
 #if defined(UNICODE) || defined(_UNICODE)
-#  define __itt_frame_create     __itt_frame_createW
-#  define __itt_frame_create_ptr __itt_frame_createW_ptr
+#define __itt_frame_create __itt_frame_createW
+#define __itt_frame_create_ptr __itt_frame_createW_ptr
 #else /* UNICODE */
-#  define __itt_frame_create     __itt_frame_createA
-#  define __itt_frame_create_ptr __itt_frame_createA_ptr
+#define __itt_frame_create __itt_frame_createA
+#define __itt_frame_create_ptr __itt_frame_createA_ptr
 #endif /* UNICODE */
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 __itt_frame ITTAPI __itt_frame_create(const char *domain);
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char    *domain))
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+ITT_STUB(ITTAPI, __itt_frame, frame_createA, (const char *domain))
 ITT_STUB(ITTAPI, __itt_frame, frame_createW, (const wchar_t *domain))
-#else  /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-ITT_STUB(ITTAPI, __itt_frame, frame_create,  (const char *domain))
+#else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
+ITT_STUB(ITTAPI, __itt_frame, frame_create, (const char *domain))
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
-#define __itt_frame_createA     ITTNOTIFY_DATA(frame_createA)
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
+#define __itt_frame_createA ITTNOTIFY_DATA(frame_createA)
 #define __itt_frame_createA_ptr ITTNOTIFY_NAME(frame_createA)
-#define __itt_frame_createW     ITTNOTIFY_DATA(frame_createW)
+#define __itt_frame_createW ITTNOTIFY_DATA(frame_createW)
 #define __itt_frame_createW_ptr ITTNOTIFY_NAME(frame_createW)
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_frame_create     ITTNOTIFY_DATA(frame_create)
+#define __itt_frame_create ITTNOTIFY_DATA(frame_create)
 #define __itt_frame_create_ptr ITTNOTIFY_NAME(frame_create)
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#else  /* INTEL_NO_ITTNOTIFY_API */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_ITTNOTIFY_API */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_frame_createA(domain)
 #define __itt_frame_createA_ptr 0
 #define __itt_frame_createW(domain)
 #define __itt_frame_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_frame_create(domain)
-#define __itt_frame_create_ptr  0
+#define __itt_frame_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
-#if ITT_PLATFORM==ITT_PLATFORM_WIN
+#else /* INTEL_NO_MACRO_BODY */
+#if ITT_PLATFORM == ITT_PLATFORM_WIN
 #define __itt_frame_createA_ptr 0
 #define __itt_frame_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
-#define __itt_frame_create_ptr  0
+#define __itt_frame_create_ptr 0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /** @brief Record a frame begin occurrence. */
 void ITTAPI __itt_frame_begin(__itt_frame frame);
 /** @brief Record a frame end occurrence. */
-void ITTAPI __itt_frame_end  (__itt_frame frame);
+void ITTAPI __itt_frame_end(__itt_frame frame);
 
 /** @cond exclude_from_documentation */
 #ifndef INTEL_NO_MACRO_BODY
 #ifndef INTEL_NO_ITTNOTIFY_API
 ITT_STUBV(ITTAPI, void, frame_begin, (__itt_frame frame))
-ITT_STUBV(ITTAPI, void, frame_end,   (__itt_frame frame))
-#define __itt_frame_begin     ITTNOTIFY_VOID(frame_begin)
+ITT_STUBV(ITTAPI, void, frame_end, (__itt_frame frame))
+#define __itt_frame_begin ITTNOTIFY_VOID(frame_begin)
 #define __itt_frame_begin_ptr ITTNOTIFY_NAME(frame_begin)
-#define __itt_frame_end       ITTNOTIFY_VOID(frame_end)
-#define __itt_frame_end_ptr   ITTNOTIFY_NAME(frame_end)
-#else  /* INTEL_NO_ITTNOTIFY_API */
+#define __itt_frame_end ITTNOTIFY_VOID(frame_end)
+#define __itt_frame_end_ptr ITTNOTIFY_NAME(frame_end)
+#else /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_frame_begin(frame)
 #define __itt_frame_begin_ptr 0
 #define __itt_frame_end(frame)
-#define __itt_frame_end_ptr   0
+#define __itt_frame_end_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
-#else  /* INTEL_NO_MACRO_BODY */
+#else /* INTEL_NO_MACRO_BODY */
 #define __itt_frame_begin_ptr 0
-#define __itt_frame_end_ptr   0
+#define __itt_frame_end_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 /** @} frames group */
 
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
 
 #endif /* _LEGACY_ITTNOTIFY_H_ */

openmp/runtime/src/z_Linux_util.cpp

void __kmp_affinity_bind_thread(int which) {
   __kmp_set_system_affinity(mask, TRUE);
   KMP_CPU_FREE_FROM_STACK(mask);
 }
 
 /* Determine if we can access affinity functionality on this version of
  * Linux* OS by checking __NR_sched_{get,set}affinity system calls, and set
  * __kmp_affin_mask_size to the appropriate value (0 means not capable). */
 void __kmp_affinity_determine_capable(const char *env_var) {
   // Check and see if the OS supports thread affinity.
 
 #if KMP_OS_LINUX
 #define KMP_CPU_SET_SIZE_LIMIT (1024 * 1024)
 #elif KMP_OS_FREEBSD
 #define KMP_CPU_SET_SIZE_LIMIT (sizeof(cpuset_t))
 #endif
 
-
 #if KMP_OS_LINUX
   // If Linux* OS:
   // If the syscall fails or returns a suggestion for the size,
   // then we don't have to search for an appropriate size.
   long gCode;
   long sCode;
   unsigned char *buf;
   buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT);
if (sCode < 0) {
         return;
       }
     }
   }
 #elif KMP_OS_FREEBSD
   long gCode;
   unsigned char *buf;
   buf = (unsigned char *)KMP_INTERNAL_MALLOC(KMP_CPU_SET_SIZE_LIMIT);
-  gCode = pthread_getaffinity_np(pthread_self(), KMP_CPU_SET_SIZE_LIMIT, reinterpret_cast<cpuset_t *>(buf));
+  gCode = pthread_getaffinity_np(pthread_self(), KMP_CPU_SET_SIZE_LIMIT,
+                                 reinterpret_cast<cpuset_t *>(buf));
   KA_TRACE(30, ("__kmp_affinity_determine_capable: "
                 "initial getaffinity call returned %d errno = %d\n",
                 gCode, errno));
   if (gCode == 0) {
     KMP_AFFINITY_ENABLE(KMP_CPU_SET_SIZE_LIMIT);
     KA_TRACE(10, ("__kmp_affinity_determine_capable: "
                   "affinity supported (mask size %d)\n",
-      (int)__kmp_affin_mask_size));
+                  (int)__kmp_affin_mask_size));
     KMP_INTERNAL_FREE(buf);
     return;
   }
 #endif
   // save uncaught error code
   // int error = errno;
   KMP_INTERNAL_FREE(buf);
   // restore uncaught error code, will be printed at the next KMP_WARNING below

 
 /* Set thread stack info according to values returned by pthread_getattr_np().
    If values are unreasonable, assume call failed and use incremental stack
    refinement method instead. Returns TRUE if the stack parameters could be
    determined exactly, FALSE if incremental refinement is necessary. */
 static kmp_int32 __kmp_set_stack_info(int gtid, kmp_info_t *th) {
   int stack_data;
 #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD ||     \
-        KMP_OS_HURD
   pthread_attr_t attr;
   int status;
   size_t size = 0;
   void *addr = 0;
 
   /* Always do incremental stack refinement for ubermaster threads since the
      initial thread stack range can be reduced by sibling thread creation so
      pthread_attr_getstack may cause thread gtid aliasing */
#endif
 
   if (size != 0 && addr != 0) { // was stack parameter determination successful?
     /* Store the correct base and size */
     TCW_PTR(th->th.th_info.ds.ds_stackbase, (((char *)addr) + size));
     TCW_PTR(th->th.th_info.ds.ds_stacksize, size);
     TCW_4(th->th.th_info.ds.ds_stackgrow, FALSE);
     return TRUE;
   }
-#endif /* KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD ||
-              KMP_OS_HURD */
+#endif /* KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD  \
+          || KMP_OS_HURD */
   /* Use incremental refinement starting from initial conservative estimate */
   TCW_PTR(th->th.th_info.ds.ds_stacksize, 0);
   TCW_PTR(th->th.th_info.ds.ds_stackbase, &stack_data);
   TCW_4(th->th.th_info.ds.ds_stackgrow, TRUE);
   return FALSE;
 }
 
 static void *__kmp_launch_worker(void *thr) {
   int status, old_type, old_state;
 #ifdef KMP_BLOCK_SIGNALS
   sigset_t new_set, old_set;
 #endif /* KMP_BLOCK_SIGNALS */
   void *exit_val;
 #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD ||     \
-        KMP_OS_OPENBSD || KMP_OS_HURD
   void *volatile padding = 0;
 #endif
   int gtid;
 
   gtid = ((kmp_info_t *)thr)->th.th_info.ds.ds_gtid;
   __kmp_gtid_set_specific(gtid);
 #ifdef KMP_TDATA_GTID
   __kmp_gtid = gtid;

 #ifdef KMP_BLOCK_SIGNALS
   status = sigfillset(&new_set);
   KMP_CHECK_SYSFAIL_ERRNO("sigfillset", status);
   status = pthread_sigmask(SIG_BLOCK, &new_set, &old_set);
   KMP_CHECK_SYSFAIL("pthread_sigmask", status);
 #endif /* KMP_BLOCK_SIGNALS */
 
 #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD ||     \
-        KMP_OS_OPENBSD
   if (__kmp_stkoffset > 0 && gtid > 0) {
     padding = KMP_ALLOCA(gtid * __kmp_stkoffset);
   }
 #endif
 
   KMP_MB();
   __kmp_set_stack_info(gtid, (kmp_info_t *)thr);
 
/* Set stack size for this thread now.
      stacksize causes the thread to have an offset before the dummy alloca()
      takes place to create the offset.  Since we want the user to have a
      sufficient stacksize AND support a stack offset, we alloca() twice the
      offset so that the upcoming alloca() does not eliminate any premade offset,
      and also gives the user the stack space they requested for all threads */
   stack_size += gtid * __kmp_stkoffset * 2;
 
 #if defined(__ANDROID__) && __ANDROID_API__ < 19
-    // Round the stack size to a multiple of the page size. Older versions of
-    // Android (until KitKat) would fail pthread_attr_setstacksize with EINVAL
-    // if the stack size was not a multiple of the page size.
-    stack_size = (stack_size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
 #endif
 
   KA_TRACE(10, ("__kmp_create_worker: T#%d, default stacksize = %lu bytes, "
                 "__kmp_stksize = %lu bytes, final stacksize = %lu bytes\n",
                 gtid, KMP_DEFAULT_STKSIZE, __kmp_stksize, stack_size));
 
 #ifdef _POSIX_THREAD_ATTR_STACKSIZE
   status = pthread_attr_setstacksize(&thread_attr, stack_size);

 void __kmp_suspend_initialize_thread(kmp_info_t *th) {
   ANNOTATE_HAPPENS_AFTER(&th->th.th_suspend_init_count);
   int old_value = KMP_ATOMIC_LD_RLX(&th->th.th_suspend_init_count);
   int new_value = __kmp_fork_count + 1;
   // Return if already initialized
   if (old_value == new_value)
     return;
   // Wait, then return if being initialized
-  if (old_value == -1 ||
-      !__kmp_atomic_compare_store(&th->th.th_suspend_init_count, old_value,
-                                  -1)) {
+  if (old_value == -1 || !__kmp_atomic_compare_store(
+                             &th->th.th_suspend_init_count, old_value, -1)) {
     while (KMP_ATOMIC_LD_ACQ(&th->th.th_suspend_init_count) != new_value) {
       KMP_CPU_PAUSE();
     }
   } else {
     // Claim to be the initializer and do initializations
     int status;
     status = pthread_cond_init(&th->th.th_suspend_cv.c_cond,
                                &__kmp_suspend_cond_attr);
void __kmp_clear_system_time(void) {
   TIMEVAL_TO_TIMESPEC(&tval, &__kmp_sys_timer_data.start);
 }
 
 static int __kmp_get_xproc(void) {
 
   int r = 0;
 
 #if KMP_OS_LINUX || KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD ||     \
-        KMP_OS_OPENBSD || KMP_OS_HURD
 
   __kmp_type_convert(sysconf(_SC_NPROCESSORS_ONLN), &(r));
 
 #elif KMP_OS_DARWIN
 
   // Bug C77011 High "OpenMP Threads and number of active cores".
 
   // Find the number of available CPUs.

 #if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
   if (!__kmp_cpuinfo.initialized) {
     __kmp_query_cpuid(&__kmp_cpuinfo);
   }
 #endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
 
   __kmp_xproc = __kmp_get_xproc();
 
-#if ! KMP_32_BIT_ARCH
+#if !KMP_32_BIT_ARCH
   struct rlimit rlim;
   // read stack size of calling thread, save it as default for worker threads;
   // this should be done before reading environment variables
   status = getrlimit(RLIMIT_STACK, &rlim);
   if (status == 0) { // success?
     __kmp_stksize = rlim.rlim_cur;
     __kmp_check_stksize(&__kmp_stksize); // check value and adjust if needed
   }

 
 int __kmp_is_address_mapped(void *addr) {
 
   int found = 0;
   int rc;
 
 #if KMP_OS_LINUX || KMP_OS_HURD
 
-  /* On GNUish OSes, read the /proc/<pid>/maps pseudo-file to get all the address
-     ranges mapped into the address space. */
+  /* On GNUish OSes, read the /proc/<pid>/maps pseudo-file to get all the
+     address ranges mapped into the address space. */
 
   char *name = __kmp_str_format("/proc/%d/maps", getpid());
   FILE *file = NULL;
 
   file = fopen(name, "r");
   KMP_ASSERT(file != NULL);
 
   for (;;) {
#if KMP_OS_LINUX || KMP_OS_HURD
   fclose(file);
   KMP_INTERNAL_FREE(name);
 #elif KMP_OS_FREEBSD
   char *buf;
   size_t lstsz;
   int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_VMMAP, getpid()};
   rc = sysctl(mib, 4, NULL, &lstsz, NULL, 0);
   if (rc < 0)
-     return 0;
   // We pass from number of vm entry's semantic
   // to size of whole entry map list.
   lstsz = lstsz * 4 / 3;
   buf = reinterpret_cast<char *>(kmpc_malloc(lstsz));
   rc = sysctl(mib, 4, buf, &lstsz, NULL, 0);
   if (rc < 0) {
-     kmpc_free(buf);
-     return 0;
   }
 
   char *lw = buf;
   char *up = buf + lstsz;
 
   while (lw < up) {
-      struct kinfo_vmentry *cur = reinterpret_cast<struct kinfo_vmentry *>(lw);
-      size_t cursz = cur->kve_structsize;
-      if (cursz == 0)
-          break;
-      void *start = reinterpret_cast<void *>(cur->kve_start);
-      void *end = reinterpret_cast<void *>(cur->kve_end);
-      // Readable/Writable addresses within current map entry
-      if ((addr >= start) && (addr < end)) {
-          if ((cur->kve_protection & KVME_PROT_READ) != 0 &&
-              (cur->kve_protection & KVME_PROT_WRITE) != 0) {
-              found = 1;
-              break;
-          }
-      }
-      lw += cursz;
   }
   kmpc_free(buf);
 
 #elif KMP_OS_DARWIN
 
   /* On OS X*, /proc pseudo filesystem is not available. Try to read memory
      using vm interface. */
 
   int buffer;
   vm_size_t count;
   rc = vm_read_overwrite(
       mach_task_self(), // Task to read memory of.
       (vm_address_t)(addr), // Address to read from.
       1, // Number of bytes to be read.
       (vm_address_t)(&buffer), // Address of buffer to save read bytes in.
       &count // Address of var to save number of read bytes in.
-      );
   if (rc == 0) {
     // Memory successfully read.
     found = 1;
   }
 
 #elif KMP_OS_NETBSD
 
   int mib[5];

 // we really only need the case with 1 argument, because CLANG always build
 // a struct of pointers to shared variables referenced in the outlined function
 int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int tid, int argc,
                            void *p_argv[]
 #if OMPT_SUPPORT
                            ,
                            void **exit_frame_ptr
 #endif
-                           ) {
 #if OMPT_SUPPORT
   *exit_frame_ptr = OMPT_GET_FRAME_ADDRESS(0);
 #endif
 
   switch (argc) {
   default:
     fprintf(stderr, "Too many args to microtask: %d!\n", argc);
     fflush(stderr);

openmp/runtime/src/z_Windows_NT_util.cpp

 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_wait_release.h"
 
 /* This code is related to NtQuerySystemInformation() function. This function
    is used in the Load balance algorithm for OMP_DYNAMIC=true to find the
    number of running threads in the system. */
 
 #include <ntsecapi.h> // UNICODE_STRING
 #include <ntstatus.h>
 
 enum SYSTEM_INFORMATION_CLASS {
   SystemProcessInformation = 5
 }; // SYSTEM_INFORMATION_CLASS
 
 struct CLIENT_ID {
   HANDLE UniqueProcess;
if (__kmp_num_proc_groups > 1) {
     KMP_CPU_ZERO(mask);
     KMP_CPU_SET(proc, mask);
     __kmp_set_system_affinity(mask, TRUE);
     KMP_CPU_FREE_FROM_STACK(mask);
   }
 }
 
 void __kmp_affinity_determine_capable(const char *env_var) {
-// All versions of Windows* OS (since Win '95) support SetThreadAffinityMask().
+  // All versions of Windows* OS (since Win '95) support
+  // SetThreadAffinityMask().
 
 #if KMP_GROUP_AFFINITY
   KMP_AFFINITY_ENABLE(__kmp_num_proc_groups * sizeof(DWORD_PTR));
 #else
   KMP_AFFINITY_ENABLE(sizeof(DWORD_PTR));
 #endif
 
   KA_TRACE(10, ("__kmp_affinity_determine_capable: "

 
 /* Return the current time stamp in nsec */
 kmp_uint64 __kmp_now_nsec() {
   LARGE_INTEGER now;
   QueryPerformanceCounter(&now);
   return 1e9 * __kmp_win32_tick * now.QuadPart;
 }
 
-extern "C"
-void *__stdcall __kmp_launch_worker(void *arg) {
+extern "C" void *__stdcall __kmp_launch_worker(void *arg) {
   volatile void *stack_data;
   void *exit_val;
   void *padding = 0;
   kmp_info_t *this_thr = (kmp_info_t *)arg;
   int gtid;
 
   gtid = this_thr->th.th_info.ds.ds_gtid;
   __kmp_gtid_set_specific(gtid);

openmp/tools/archer/ompt-tsan.cpp

case ompt_scope_beginend:
 
     case ompt_sync_region_taskgroup:
       Data->TaskGroup = new Taskgroup(Data->TaskGroup);
       break;
 
     case ompt_sync_region_reduction:
       // should never be reached
       break;
-
     }
     if (endpoint == ompt_scope_begin)
       break;
     KMP_FALLTHROUGH();
   case ompt_scope_end:
     TsanFuncExit();
     switch (kind) {
     case ompt_sync_region_barrier_implementation:
case ompt_sync_region_taskgroup: {
       Data->TaskGroup = Parent;
       break;
     }
 
     case ompt_sync_region_reduction:
       // Should not occur according to OpenMP 5.1
       // Tested in OMPT tests
       break;
-
     }
     break;
   }
 }
 
 static void ompt_tsan_reduction(ompt_sync_region_t kind,
                                 ompt_scope_endpoint_t endpoint,
                                 ompt_data_t *parallel_data,

openmp/tools/multiplex/ompt-multiplex.h

 
 #ifndef OMPT_MULTIPLEX_H
 #define OMPT_MULTIPLEX_H
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
 #include <dlfcn.h>
+#include <errno.h>
 #include <execinfo.h>
 #include <inttypes.h>
 #include <omp-tools.h>
 #include <omp.h>
 #include <stdio.h>
 #include <string.h>
-#include <errno.h>
 
 static ompt_set_callback_t ompt_multiplex_set_callback;
 static ompt_get_task_info_t ompt_multiplex_get_task_info;
 static ompt_get_thread_data_t ompt_multiplex_get_thread_data;
 static ompt_get_parallel_info_t ompt_multiplex_get_parallel_info;
 
 // contains name of the environment var in which the tool path is specified
 #ifndef CLIENT_TOOL_LIBRARIES_VAR
 #error CLIENT_TOOL_LIBRARIES_VAR should be defined before including of ompt-multiplex.h
 #endif
 
 #if defined(CUSTOM_DELETE_DATA) && !defined(CUSTOM_GET_CLIENT_DATA)
 #error CUSTOM_GET_CLIENT_DATA must be set if CUSTOM_DELETE_DATA is set
 #endif
 
 #define OMPT_API_ROUTINE static
 

 
 ompt_start_tool_result_t *ompt_start_tool(unsigned int omp_version,
                                           const char *runtime_version) {
   // try loading client tool
   ompt_multiplex_client_fns = NULL;
   ompt_start_tool_result_t *(*client_start_tool)(unsigned int, const char *) =
       NULL;
 
   const char *tool_libs = getenv(CLIENT_TOOL_LIBRARIES_VAR);
   if (tool_libs) {
     // copy environement variable
     char *tool_libs_buffer = strdup(tool_libs);
     if (!tool_libs_buffer) {
       printf("strdup Error (%i)\n", errno);
       exit(-1);
     }
 
while (progress < strlen(tool_libs)) {
                 dlsym(h, "ompt_start_tool");
         if (client_start_tool &&
             (ompt_multiplex_client_fns =
                  (*client_start_tool)(omp_version, runtime_version))) {
           break;
         }
       } else {
         printf("Loading %s from %s failed with: %s\n",
                tool_libs_buffer + progress, CLIENT_TOOL_LIBRARIES_VAR,
                dlerror());
       }
       progress = tmp_progress + 1;
     }
     free(tool_libs_buffer);
   }
   // load own tool
   ompt_multiplex_own_fns =