[OpenMP] NFC: Fix trivial typo

[jdoerfert]

LGTM.

openmp/CMakeLists.txt

 endif()
 
 option(OPENMP_ENABLE_OMPT_TOOLS "Enable building ompt based tools for OpenMP."
        ${ENABLE_OMPT_TOOLS})
 if (OPENMP_ENABLE_OMPT_TOOLS)
   add_subdirectory(tools)
 endif()
 
-# Now that we have seen all testuites, create the check-openmp target.
+# Now that we have seen all testsuites, create the check-openmp target.
 construct_check_openmp_target()

openmp/libomptarget/deviceRTLs/common/debug.h

 #else
 
 #define DON(_flag) (0)
 #define PRINT0(flag, str)
 #define PRINT(flag, str, _args...)
 
 #endif
 
-// for printing without worring about precision, pointers...
+// for printing without worrying about precision, pointers...
 #define P64(_x) ((unsigned long long)(_x))
 
 ////////////////////////////////////////////////////////////////////////////////
 // early defs for test
 ////////////////////////////////////////////////////////////////////////////////
 
 #define LT_SAFETY (LT_SET_SAFETY | LT_SET_INPUT | LT_SET_FUSSY)
 #define LT_INPUT (LT_SET_INPUT | LT_SET_FUSSY)

openmp/libomptarget/deviceRTLs/common/omptarget.h

INLINE omptarget_nvptx_WorkDescr &WorkDescr() {
     return workDescrForActiveParallel;
   }
   INLINE uint64_t *getLastprivateIterBuffer() { return &lastprivateIterBuffer; }
 
   // init
   INLINE void InitTeamDescr();
 
   INLINE __kmpc_data_sharing_slot *RootS(int wid, bool IsMasterThread) {
-    // If this is invoked by the master thread of the master warp then intialize
-    // it with a smaller slot.
+    // If this is invoked by the master thread of the master warp then
+    // initialize it with a smaller slot.
     if (IsMasterThread) {
       // Do not initialize this slot again if it has already been initalized.
       if (master_rootS[0].DataEnd == &master_rootS[0].Data[0] + DS_Slot_Size)
         return 0;
       // Initialize the pointer to the end of the slot given the size of the
       // data section. DataEnd is non-inclusive.
       master_rootS[0].DataEnd = &master_rootS[0].Data[0] + DS_Slot_Size;
       // We currently do not have a next slot.

openmp/libomptarget/deviceRTLs/common/omptargeti.h

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; // prefered chunking statik with chunk 1
+  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.threadId =
       GetThreadIdInBlock(); // get ids from cuda (only called for 1st level)
-  items.runtimeChunkSize = 1; // prefered chunking statik with chunk 1
+  items.runtimeChunkSize = 1; // preferred chunking statik with chunk 1
   prev = parentTaskDescr;
 }
 
 INLINE void omptarget_nvptx_TaskDescr::CopyData(
     omptarget_nvptx_TaskDescr *sourceTaskDescr) {
   items = sourceTaskDescr->items;
 }
 
INLINE void omptarget_nvptx_TaskDescr::CopyForExplicitTask(
   CopyParent(parentTaskDescr);
   items.flags = items.flags & ~TaskDescr_IsParConstr;
   ASSERT0(LT_FUSSY, IsTaskConstruct(), "expected task");
 }
 
 INLINE void omptarget_nvptx_TaskDescr::CopyToWorkDescr(
     omptarget_nvptx_TaskDescr *masterTaskDescr) {
   CopyParent(masterTaskDescr);
-  // overrwrite specific items;
+  // overwrite specific items;
   items.flags |=
       TaskDescr_InPar | TaskDescr_IsParConstr; // set flag to parallel
 }
 
 INLINE void omptarget_nvptx_TaskDescr::CopyFromWorkDescr(
     omptarget_nvptx_TaskDescr *workTaskDescr) {
   Copy(workTaskDescr);
   //
-  // overrwrite specific items;
+  // overwrite specific items;
   //
   // The threadID should be GetThreadIdInBlock() % GetMasterThreadID().
   // This is so that the serial master (first lane in the master warp)
   // gets a threadId of 0.
   // However, we know that this function is always called in a parallel
   // region where only workers are active.  The serial master thread
   // never enters this region.  When a parallel region is executed serially,
   // the threadId is set to 0 elsewhere and the kmpc_serialized_* functions

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

EXTERN int omp_in_parallel(void) {
   int rc = parallelLevel[GetWarpId()] > OMP_ACTIVE_PARALLEL_LEVEL ? 1 : 0;
   PRINT(LD_IO, "call omp_in_parallel() returns %d\n", rc);
   return rc;
 }
 
 EXTERN int omp_in_final(void) {
   // treat all tasks as final... Specs may expect runtime to keep
   // track more precisely if a task was actively set by users... This
-  // is not explicitely specified; will treat as if runtime can
+  // is not explicitly specified; will treat as if runtime can
   // actively decide to put a non-final task into a final one.
   int rc = 1;
   PRINT(LD_IO, "call omp_in_final() returns %d\n", rc);
   return rc;
 }
 
 EXTERN void omp_set_dynamic(int flag) {
   PRINT(LD_IO, "call omp_set_dynamic(%d) is ignored (no support)\n", flag);

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

INLINE static void dispatch_init(kmp_Ident *loc, int32_t threadId,
     ASSERT0(LT_FUSSY, threadId < tnum,
             "current thread is not needed here; error");
 
     /* Currently just ignore the monotonic and non-monotonic modifiers
      * (the compiler isn't producing them * yet anyway).
      * When it is we'll want to look at them somewhere here and use that
      * information to add to our schedule choice. We shouldn't need to pass
      * them on, they merely affect which schedule we can legally choose for
-     * various dynamic cases. (In paritcular, whether or not a stealing scheme
+     * various dynamic cases. (In particular, whether or not a stealing scheme
      * is legal).
      */
     schedule = SCHEDULE_WITHOUT_MODIFIERS(schedule);
 
     // Process schedule.
     if (tnum == 1 || tripCount <= 1 || OrderedSchedule(schedule)) {
       if (OrderedSchedule(schedule))
         __kmpc_barrier(loc, threadId);

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

EXTERN int32_t __kmpc_single(kmp_Ident *loc, int32_t global_tid) {
   // decide to implement single with master; master get the single
   return IsTeamMaster(global_tid);
 }
 
 EXTERN void __kmpc_end_single(kmp_Ident *loc, int32_t global_tid) {
   PRINT0(LD_IO, "call kmpc_end_single\n");
   // decide to implement single with master: master get the single
   ASSERT0(LT_FUSSY, IsTeamMaster(global_tid), "expected only master here");
-  // sync barrier is explicitely called... so that is not a problem
+  // sync barrier is explicitly called... so that is not a problem
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Flush
 ////////////////////////////////////////////////////////////////////////////////
 
 EXTERN void __kmpc_flush(kmp_Ident *loc) {
   PRINT0(LD_IO, "call kmpc_flush\n");

openmp/libomptarget/deviceRTLs/interface.h

 EXTERN int omp_get_initial_device(void);
 EXTERN int omp_get_max_task_priority(void);
 
 ////////////////////////////////////////////////////////////////////////////////
 // file below is swiped from kmpc host interface
 ////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////
-// kmp specifc types
+// kmp specific types
 ////////////////////////////////////////////////////////////////////////////////
 
 typedef enum kmp_sched_t {
   kmp_sched_static_chunk = 33,
   kmp_sched_static_nochunk = 34,
   kmp_sched_dynamic = 35,
   kmp_sched_guided = 36,
   kmp_sched_runtime = 37,

openmp/libomptarget/deviceRTLs/nvptx/docs/ReductionDesign.txt

3. ret = kmpc_nvptx_reduce_nowait(..., reduceData, shuffleReduceFn,
         while being data-structure agnostic about ReduceData.
 
         In particular, shuffleReduceFn is a function that takes the following
         inputs:
         a. local copy of ReduceData
         b. its lane_id
         c. the offset of the lane_id which hosts a remote ReduceData
                 relative to the current one
-        d. an algorithm version paramter determining which reduction
+        d. an algorithm version parameter determining which reduction
                 algorithm to use.
         This shuffleReduceFn retrieves the remote ReduceData through shuffle
         intrinsics and  reduces, using the algorithm specified by the 4th
         parameter, the local ReduceData and with the remote ReduceData element
         wise, and places the resultant values into the local ReduceData.
 
         Different reduction algorithms are implemented with different runtime
         functions, but they all make calls to this same shuffleReduceFn to

openmp/libomptarget/deviceRTLs/nvptx/test/parallel/level.c

#pragma omp parallel num_threads(NumThreads)
         check3[id] += omp_get_level() * 5 + omp_get_active_level();
 
         // Expected to return 0 and 1.
         int check4Inc = omp_get_ancestor_thread_num(0) + 5 * omp_get_team_size(0);
         // Expected to return the parent thread num.
         check4Inc += (omp_get_ancestor_thread_num(1) - id);
         // Expected to return the number of threads in the active parallel region.
         check4Inc += 3 * omp_get_team_size(1);
-        // Exptected to return 0 and 1.
+        // Expected to return 0 and 1.
         check4Inc += omp_get_ancestor_thread_num(2) + 3 * omp_get_team_size(2);
         // Expected to return -1, see above.
         check4Inc += omp_get_ancestor_thread_num(3) + omp_get_team_size(3);
 
         #pragma omp atomic
         check4[id] += check4Inc;
       }
     }

openmp/libomptarget/src/interface.cpp

 #include <cstdlib>
 #include <mutex>
 
 // Store target policy (disabled, mandatory, default)
 kmp_target_offload_kind_t TargetOffloadPolicy = tgt_default;
 std::mutex TargetOffloadMtx;
 
 ////////////////////////////////////////////////////////////////////////////////
-/// manage the success or failure of a target constuct
+/// manage the success or failure of a target construct
 
 static void HandleDefaultTargetOffload() {
   TargetOffloadMtx.lock();
   if (TargetOffloadPolicy == tgt_default) {
     if (omp_get_num_devices() > 0) {
       DP("Default TARGET OFFLOAD policy is now mandatory "
          "(devices were found)\n");
       TargetOffloadPolicy = tgt_mandatory;

openmp/runtime/cmake/LibompMicroTests.cmake

 #  - Fails if TEXTREL is in output of readelf -d libomp.so command
 #  - Program dependencies: readelf, grep, bourne shell
 #  - Available for Unix, Intel(R) MIC Architecture dynamic library builds. Not available otherwise.
 # (3) test-execstack
 #  - Tests if stack is executable
 #  - Fails if stack is executable. Should only be readable and writable. Not executable.
 #  - Program dependencies: perl, readelf
 #  - Available for Unix dynamic library builds. Not available otherwise.
-# (4) test-instr (Intel(R) MIC Architecutre only)
+# (4) test-instr (Intel(R) MIC Architecture only)
 #  - Tests Intel(R) MIC Architecture libraries for valid instruction set
 #  - Fails if finds invalid instruction for Intel(R) MIC Architecture (wasn't compiled with correct flags)
 #  - Program dependencies: perl, objdump
 #  - Available for Intel(R) MIC Architecture and i386 builds. Not available otherwise.
 # (5) test-deps
 #  - Tests newly created libomp for library dependencies
 #  - Fails if sees a dependence not listed in td_exp variable below
 #  - Program dependencies: perl, (unix)readelf, (mac)otool[64], (windows)link.exe

openmp/runtime/src/CMakeLists.txt

 # Windows specific build rules
 if(WIN32)
   configure_file(libomp.rc.var libomp.rc @ONLY)
 
   # Create .def and .rc file before compiling any sources
   add_custom_target(libomp-needed-windows-files DEPENDS ${LIBOMP_LIB_NAME}.def)
   add_dependencies(omp libomp-needed-windows-files)
   # z_Windows_NT-586_asm.asm requires definitions to be sent via command line
-  # It only needs the architecutre macro and OMPT_SUPPORT=0|1
+  # It only needs the architecture macro and OMPT_SUPPORT=0|1
   libomp_append(LIBOMP_MASM_DEFINITIONS "-D_M_IA32" IF_TRUE IA32)
   libomp_append(LIBOMP_MASM_DEFINITIONS "-D_M_AMD64" IF_TRUE INTEL64)
   libomp_append(LIBOMP_MASM_DEFINITIONS "-DOMPT_SUPPORT" IF_TRUE_1_0 LIBOMP_OMPT_SUPPORT)
   libomp_list_to_string("${LIBOMP_MASM_DEFINITIONS}" LIBOMP_MASM_DEFINITIONS)
   set_property(SOURCE z_Windows_NT-586_asm.asm APPEND_STRING PROPERTY COMPILE_FLAGS " ${LIBOMP_MASM_DEFINITIONS}")
   set_source_files_properties(thirdparty/ittnotify/ittnotify_static.cpp PROPERTIES COMPILE_DEFINITIONS "UNICODE")
 
   # Create Windows import library

openmp/runtime/src/i18n/en_US.txt

 OBSOLETE                     "%1$s: HT disabled; %2$d packages"
 BarriersInDifferentOrder     "Threads encountered barriers in different order. "
 FunctionError                "Function %1$s failed:"
 TopologyExtra                "%1$s: %2$s packages x %3$d cores/pkg x %4$d threads/core (%5$d total cores)"
 WrongMessageCatalog          "Incompatible message catalog \"%1$s\": Version \"%2$s\" found, version \"%3$s\" expected."
 StgIgnored                   "%1$s: ignored because %2$s has been defined"
                                  # %1, -- name of ignored variable, %2 -- name of variable with higher priority.
 OBSOLETE                     "%1$s: overrides %3$s specified before"
-                                 # %1, %2 -- name and value of the overriding variable, %3 -- name of overriden variable.
+                                 # %1, %2 -- name and value of the overriding variable, %3 -- name of overridden variable.
 AffTilesNoHWLOC              "%1$s: Tiles are only supported if KMP_TOPOLOGY_METHOD=hwloc, using granularity=package instead"
 AffTilesNoTiles              "%1$s: Tiles requested but were not detected on this HW, using granularity=package instead"
 TopologyExtraTile            "%1$s: %2$d packages x %3$d tiles/pkg x %4$d cores/tile x %5$d threads/core (%6$d total cores)"
 TopologyExtraNode            "%1$s: %2$d packages x %3$d nodes/pkg x %4$d cores/node x %5$d threads/core (%6$d total cores)"
 TopologyExtraNoTi            "%1$s: %2$d packages x %3$d nodes/pkg x %4$d tiles/node x %5$d cores/tile x %6$d threads/core (%7$d total cores)"
 OmptOutdatedWorkshare        "OMPT: Cannot determine workshare type; using the default (loop) instead. "
                              "This issue is fixed in an up-to-date compiler."
 OmpNoAllocator               "Allocator %1$s is not available, will use default allocator."

openmp/runtime/src/kmp.h

typedef struct KMP_ALIGN_CACHE kmp_base_info {
   /* TODO use these in more places as determined to be needed via profiling */
   int th_team_nproc; /* number of threads in a team */
   kmp_info_p *th_team_master; /* the team's master thread */
   int th_team_serialized; /* team is serialized */
   microtask_t th_teams_microtask; /* save entry address for teams construct */
   int th_teams_level; /* save initial level of teams construct */
 /* it is 0 on device but may be any on host */
 
-/* The blocktime info is copied from the team struct to the thread sruct */
-/* at the start of a barrier, and the values stored in the team are used */
-/* at points in the code where the team struct is no longer guaranteed   */
-/* to exist (from the POV of worker threads).                            */
+/* The blocktime info is copied from the team struct to the thread struct */
+/* at the start of a barrier, and the values stored in the team are used  */
+/* at points in the code where the team struct is no longer guaranteed    */
+/* to exist (from the POV of worker threads).                             */
 #if KMP_USE_MONITOR
   int th_team_bt_intervals;
   int th_team_bt_set;
 #else
   kmp_uint64 th_team_bt_intervals;
 #endif
 
 #if KMP_AFFINITY_SUPPORTED

openmp/runtime/src/kmp_affinity.cpp

if (__kmp_affinity_verbose) {
                  __kmp_nThreadsPerCore, __kmp_ncores);
     }
     KMP_CPU_FREE(oldMask);
     return 0;
   }
 
   int depth = 3;
   int levels[5] = {0, 1, 2, 3, 4}; // package, [node,] [tile,] core, thread
-  int labels[3] = {0}; // package [,node] [,tile] - head of lables array
+  int labels[3] = {0}; // package [,node] [,tile] - head of labels array
   if (__kmp_numa_detected)
     ++depth;
   if (__kmp_tile_depth)
     ++depth;
 
   // Allocate the data structure to be returned.
   AddrUnsPair *retval =
       (AddrUnsPair *)__kmp_allocate(sizeof(AddrUnsPair) * __kmp_avail_proc);
static int __kmp_affinity_create_hwloc_map(AddrUnsPair **address2os,
 
   if (__kmp_affinity_type == affinity_none) {
     __kmp_free(retval);
     KMP_CPU_FREE(oldMask);
     return 0;
   }
 
   int depth_full = depth; // number of levels before compressing
-  // Find any levels with radiix 1, and remove them from the map
+  // Find any levels with radix 1, and remove them from the map
   // (except for the package level).
   depth = __kmp_affinity_remove_radix_one_levels(retval, nActiveThreads, depth,
                                                  levels);
   KMP_DEBUG_ASSERT(__kmp_affinity_gran != affinity_gran_default);
   if (__kmp_affinity_gran_levels < 0) {
     // Set the granularity level based on what levels are modeled
     // in the machine topology map.
     __kmp_affinity_gran_levels = 0; // lowest level (e.g. fine)
if (__kmp_affinity_type == affinity_none) {
     KMP_CPU_SET_ITERATE(i, __kmp_affin_fullMask) {
       if (!KMP_CPU_ISSET(i, __kmp_affin_fullMask))
         continue;
       __kmp_pu_os_idx[avail_ct++] = i; // suppose indices are flat
     }
     return 0;
   }
 
-  // Contruct the data structure to be returned.
+  // Construct the data structure to be returned.
   *address2os =
       (AddrUnsPair *)__kmp_allocate(sizeof(**address2os) * __kmp_avail_proc);
   int avail_ct = 0;
   int i;
   KMP_CPU_SET_ITERATE(i, __kmp_affin_fullMask) {
     // Skip this proc if it is not included in the machine model.
     if (!KMP_CPU_ISSET(i, __kmp_affin_fullMask)) {
       continue;
static int __kmp_affinity_create_proc_group_map(AddrUnsPair **address2os,
 
   // If we aren't affinity capable, then return now.
   // The flat mapping will be used.
   if (!KMP_AFFINITY_CAPABLE()) {
     // FIXME set *msg_id
     return -1;
   }
 
-  // Contruct the data structure to be returned.
+  // Construct the data structure to be returned.
   *address2os =
       (AddrUnsPair *)__kmp_allocate(sizeof(**address2os) * __kmp_avail_proc);
   KMP_DEBUG_ASSERT(__kmp_pu_os_idx == NULL);
   __kmp_pu_os_idx = (int *)__kmp_allocate(sizeof(int) * __kmp_avail_proc);
   int avail_ct = 0;
   int i;
   KMP_CPU_SET_ITERATE(i, __kmp_affin_fullMask) {
     // Skip this proc if it is not included in the machine model.
if (__kmp_affinity_type == affinity_none) {
     __kmp_free(maxCt);
     __kmp_free(counts);
     __kmp_free(totals);
     __kmp_free(retval);
     KMP_CPU_FREE(oldMask);
     return 0;
   }
 
-  // Find any levels with radiix 1, and remove them from the map
+  // Find any levels with radix 1, and remove them from the map
   // (except for the package level).
   int new_depth = 0;
   for (level = 0; level < depth; level++) {
     if ((maxCt[level] == 1) && (level != pkgLevel)) {
       continue;
     }
     new_depth++;
   }
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 paricular topology discovery method is to be
+// 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));
#endif
   }
 
   KMP_CPU_FREE_ARRAY(osId2Mask, maxIndex + 1);
   machine_hierarchy.init(address2os, __kmp_avail_proc);
 }
 #undef KMP_EXIT_AFF_NONE
 
 void __kmp_affinity_initialize(void) {
-  // Much of the code above was written assumming that if a machine was not
+  // Much of the code above was written assuming that if a machine was not
   // affinity capable, then __kmp_affinity_type == affinity_none.  We now
   // explicitly represent this as __kmp_affinity_type == affinity_disabled.
   // There are too many checks for __kmp_affinity_type == affinity_none
   // in this code.  Instead of trying to change them all, check if
   // __kmp_affinity_type == affinity_disabled, and if so, slam it with
   // affinity_none, call the real initialization routine, then restore
   // __kmp_affinity_type to affinity_disabled.
   int disabled = (__kmp_affinity_type == affinity_disabled);
void __kmp_affinity_set_init_mask(int gtid, int isa_root) {
 
   kmp_info_t *th = (kmp_info_t *)TCR_SYNC_PTR(__kmp_threads[gtid]);
   if (th->th.th_affin_mask == NULL) {
     KMP_CPU_ALLOC(th->th.th_affin_mask);
   } else {
     KMP_CPU_ZERO(th->th.th_affin_mask);
   }
 
-  // Copy the thread mask to the kmp_info_t strucuture. If
+  // Copy the thread mask to the kmp_info_t structure. If
   // __kmp_affinity_type == affinity_none, copy the "full" mask, i.e. one that
   // has all of the OS proc ids set, or if __kmp_affinity_respect_mask is set,
   // then the full mask is the same as the mask of the initialization thread.
   kmp_affin_mask_t *mask;
   int i;
 
   if (KMP_AFFINITY_NON_PROC_BIND) {
     if ((__kmp_affinity_type == affinity_none) ||
void __kmp_affinity_set_place(int gtid) {
   if (th->th.th_first_place <= th->th.th_last_place) {
     KMP_ASSERT((th->th.th_new_place >= th->th.th_first_place) &&
                (th->th.th_new_place <= th->th.th_last_place));
   } else {
     KMP_ASSERT((th->th.th_new_place <= th->th.th_first_place) ||
                (th->th.th_new_place >= th->th.th_last_place));
   }
 
-  // Copy the thread mask to the kmp_info_t strucuture,
+  // Copy the thread mask to the kmp_info_t structure,
   // and set this thread's affinity.
   kmp_affin_mask_t *mask =
       KMP_CPU_INDEX(__kmp_affinity_masks, th->th.th_new_place);
   KMP_CPU_COPY(th->th.th_affin_mask, mask);
   th->th.th_current_place = th->th.th_new_place;
 
   if (__kmp_affinity_verbose) {
     char buf[KMP_AFFIN_MASK_PRINT_LEN];

openmp/runtime/src/kmp_alloc.cpp

#endif /* BufStats */
 
   bget_mode_t mode; /* what allocation mode to use? */
 
   bufsize exp_incr; /* Expansion block size */
   bufsize pool_len; /* 0: no bpool calls have been made
                        -1: not all pool blocks are the same size
                        >0: (common) block size for all bpool calls made so far
                     */
-  bfhead_t *last_pool; /* Last pool owned by this thread (delay dealocation) */
+  bfhead_t *last_pool; /* Last pool owned by this thread (delay deallocation) */
 } thr_data_t;
 
 /*  Minimum allocation quantum: */
 #define QLSize (sizeof(qlinks_t))
 #define SizeQ ((SizeQuant > QLSize) ? SizeQuant : QLSize)
 #define MaxSize                                                                \
   (bufsize)(                                                                   \
       ~(((bufsize)(1) << (sizeof(bufsize) * CHAR_BIT - 1)) | (SizeQuant - 1)))
-// Maximun for the requested size.
+// Maximum for the requested size.
 
 /* End sentinel: value placed in bsize field of dummy block delimiting
    end of pool block.  The most negative number which will  fit  in  a
    bufsize, defined in a way that the compiler will accept. */
 
 #define ESent                                                                  \
   ((bufsize)(-(((((bufsize)1) << ((int)sizeof(bufsize) * 8 - 2)) - 1) * 2) - 2))
 
#endif
   }
 
   /* No buffer available with requested size free. */
 
   /* Don't give up yet -- look in the reserve supply. */
   if (thr->acqfcn != 0) {
     if (size > (bufsize)(thr->exp_incr - sizeof(bhead_t))) {
       /* Request is too large to fit in a single expansion block.
-         Try to satisy it by a direct buffer acquisition. */
+         Try to satisfy it by a direct buffer acquisition. */
       bdhead_t *bdh;
 
       size += sizeof(bdhead_t) - sizeof(bhead_t);
 
       KE_TRACE(10, ("%%%%%% MALLOC( %d )\n", (int)size));
 
       /* richryan */
       bdh = BDH((*thr->acqfcn)((bufsize)size));
if (head == NULL) {
           dsc->size_allocated + 1; // new size in case we add current task
       if (q_th == alloc_thr && q_sz <= KMP_FREE_LIST_LIMIT) {
         // we can add current task to "other" list, no sync needed
         *((void **)ptr) = head;
         descr->size_allocated = q_sz;
         this_thr->th.th_free_lists[index].th_free_list_other = ptr;
       } else {
         // either queue blocks owner is changing or size limit exceeded
-        // return old queue to allocating thread (q_th) synchroneously,
+        // return old queue to allocating thread (q_th) synchronously,
         // and start new list for alloc_thr's tasks
         void *old_ptr;
         void *tail = head;
         void *next = *((void **)head);
         while (next != NULL) {
           KMP_DEBUG_ASSERT(
               // queue size should decrease by 1 each step through the list
               ((kmp_mem_descr_t *)((char *)next - sizeof(kmp_mem_descr_t)))

openmp/runtime/src/kmp_csupport.cpp

 If the runtime has ony been entered at the outermost level from a
 single (necessarily non-OpenMP<sup>*</sup>) thread, then the thread number is
 that which would be returned by omp_get_thread_num() in the outermost
 active parallel construct. (Or zero if there is no active parallel
 construct, since the master thread is necessarily thread zero).
 
 If multiple non-OpenMP threads all enter an OpenMP construct then this
 will be a unique thread identifier among all the threads created by
-the OpenMP runtime (but the value cannote be defined in terms of
+the OpenMP runtime (but the value cannot be defined in terms of
 OpenMP thread ids returned by omp_get_thread_num()).
 */
 kmp_int32 __kmpc_global_thread_num(ident_t *loc) {
   kmp_int32 gtid = __kmp_entry_gtid();
 
   KC_TRACE(10, ("__kmpc_global_thread_num: T#%d\n", gtid));
 
   return gtid;

openmp/runtime/src/kmp_dispatch.cpp

if (traits_t<T>::type_size > 4) {
           __kmp_acquire_lock(lck, gtid);
           limit = victim->u.p.ub; // keep initial ub
           if (victim->u.p.count >= limit ||
               (remaining = limit - victim->u.p.count) < 2) {
             __kmp_release_lock(lck, gtid);
             pr->u.p.parm4 = (victimIdx + 1) % nproc; // next victim
             continue; // not enough chunks to steal
           }
-          // stealing succeded, reduce victim's ub by 1/4 of undone chunks or
+          // stealing succeeded, reduce victim's ub by 1/4 of undone chunks or
           // by 1
           if (remaining > 3) {
             // steal 1/4 of remaining
             KMP_COUNT_DEVELOPER_VALUE(FOR_static_steal_stolen, remaining >> 2);
             init = (victim->u.p.ub -= (remaining >> 2));
           } else {
             // steal 1 chunk of 2 or 3 remaining
             KMP_COUNT_DEVELOPER_VALUE(FOR_static_steal_stolen, 1);
if (traits_t<T>::type_size > 4) {
               vnew.p.ub -= 1; // steal 1 chunk of 2 or 3 remaining
             }
             KMP_DEBUG_ASSERT((vnew.p.ub - 1) * (UT)chunk <= trip);
             // TODO: Should this be acquire or release?
             if (KMP_COMPARE_AND_STORE_ACQ64(
                     (volatile kmp_int64 *)&victim->u.p.count,
                     *VOLATILE_CAST(kmp_int64 *) & vold.b,
                     *VOLATILE_CAST(kmp_int64 *) & vnew.b)) {
-              // stealing succedded
+              // stealing succeeded
               KMP_COUNT_DEVELOPER_VALUE(FOR_static_steal_stolen,
                                         vold.p.ub - vnew.p.ub);
               status = 1;
               while_index = 0;
               // now update own count and ub
               init = vnew.p.ub;
               vold.p.count = init + 1;
 #if KMP_ARCH_X86
               KMP_XCHG_FIXED64((volatile kmp_int64 *)(&pr->u.p.count), vold.b);
 #else
               *(volatile kmp_int64 *)(&pr->u.p.count) = vold.b;
 #endif
               break;
             } // if (check CAS result)
-            KMP_CPU_PAUSE(); // CAS failed, repeate attempt
+            KMP_CPU_PAUSE(); // CAS failed, repeatedly attempt
           } // while (try to steal from particular victim)
         } // while (search for victim)
       } // if (try to find victim and steal)
     } // if (4-byte induction variable)
     if (!status) {
       *p_lb = 0;
       *p_ub = 0;
       if (p_st != NULL)
while (1) {
       remaining = trip - init;
       if (remaining <= 0) { // AC: need to compare with 0 first
         // nothing to do, don't try atomic op
         status = 0;
         break;
       }
       if ((T)remaining <
           pr->u.p.parm2) { // compare with K*nproc*(chunk+1), K=2 by default
-        // use dynamic-style shcedule
+        // use dynamic-style schedule
         // atomically increment iterations, get old value
         init = test_then_add<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
                                  (ST)chunkspec);
         remaining = trip - init;
         if (remaining <= 0) {
           status = 0; // all iterations got by other threads
         } else {
           // got some iterations to work on
while (1) {
       remaining = trip - init;
       if (remaining <= 0) { // AC: need to compare with 0 first
         status = 0; // nothing to do, don't try atomic op
         break;
       }
       KMP_DEBUG_ASSERT(init % chunk == 0);
       // compare with K*nproc*(chunk+1), K=2 by default
       if ((T)remaining < pr->u.p.parm2) {
-        // use dynamic-style shcedule
+        // use dynamic-style schedule
         // atomically increment iterations, get old value
         init = test_then_add<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
                                  (ST)chunk);
         remaining = trip - init;
         if (remaining <= 0) {
           status = 0; // all iterations got by other threads
         } else {
           // got some iterations to work on
#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 runtme schedule is static. (Which points out a
+  // 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);
 
   int status;
   dispatch_private_info_template<T> *pr;
   kmp_info_t *th = __kmp_threads[gtid];
   kmp_team_t *team = th->th.th_team;
 
   KMP_DEBUG_ASSERT(p_lb && p_ub && p_st); // AC: these cannot be NULL
   KD_TRACE(
       1000,
       ("__kmp_dispatch_next: T#%d called p_lb:%p p_ub:%p p_st:%p p_last: %p\n",
        gtid, p_lb, p_ub, p_st, p_last));
 
   if (team->t.t_serialized) {
-    /* NOTE: serialize this dispatch becase we are not at the active level */
+    /* NOTE: serialize this dispatch because we are not at the active level */
     pr = reinterpret_cast<dispatch_private_info_template<T> *>(
         th->th.th_dispatch->th_disp_buffer); /* top of the stack */
     KMP_DEBUG_ASSERT(pr);
 
     if ((status = (pr->u.p.tc != 0)) == 0) {
       *p_lb = 0;
       *p_ub = 0;
       //            if ( p_last != NULL )

openmp/runtime/src/kmp_dispatch_hier.h

if (!sh->hier->is_valid()) {
     return;
   }
   // Have threads allocate their thread-private barrier data if it hasn't
   // already been allocated
   if (th->th.th_hier_bar_data == NULL) {
     th->th.th_hier_bar_data = (kmp_hier_private_bdata_t *)__kmp_allocate(
         sizeof(kmp_hier_private_bdata_t) * kmp_hier_layer_e::LAYER_LAST);
   }
-  // Have threads "register" themselves by modifiying the active count for each
+  // Have threads "register" themselves by modifying the active count for each
   // level they are involved in. The active count will act as nthreads for that
   // level regarding the scheduling algorithms
   for (int i = 0; i < n; ++i) {
     int index = __kmp_dispatch_get_index(tid, hier->get_type(i));
     kmp_hier_top_unit_t<T> *my_unit = hier->get_unit(i, index);
     // Setup the thread's private dispatch buffer's hierarchy pointers
     if (i == 0)
       pr->hier_parent = my_unit;

openmp/runtime/src/kmp_environment.h

 /*
- * kmp_environment.h -- Handle environment varoiables OS-independently.
+ * kmp_environment.h -- Handle environment variables OS-independently.
  */
 
 //===----------------------------------------------------------------------===//
 //
 // 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
 //

openmp/runtime/src/kmp_gsupport.cpp

 #define KMP_DISPATCH_FINI_CHUNK __kmp_aux_dispatch_fini_chunk_8
 #define KMP_DISPATCH_NEXT __kmpc_dispatch_next_8
 #endif /* KMP_ARCH_X86 */
 
 #define KMP_DISPATCH_INIT_ULL __kmp_aux_dispatch_init_8u
 #define KMP_DISPATCH_FINI_CHUNK_ULL __kmp_aux_dispatch_fini_chunk_8u
 #define KMP_DISPATCH_NEXT_ULL __kmpc_dispatch_next_8u
 
-// The parallel contruct
+// The parallel construct
 
 #ifndef KMP_DEBUG
 static
 #endif /* KMP_DEBUG */
     void
     __kmp_GOMP_microtask_wrapper(int *gtid, int *npr, void (*task)(void *),
                                  void *data) {
 #if OMPT_SUPPORT

 #endif /* KMP_DEBUG */
     void
     __kmp_GOMP_parallel_microtask_wrapper(int *gtid, int *npr,
                                           void (*task)(void *), void *data,
                                           unsigned num_threads, ident_t *loc,
                                           enum sched_type schedule, long start,
                                           long end, long incr,
                                           long chunk_size) {
-  // Intialize the loop worksharing construct.
+  // Initialize the loop worksharing construct.
 
   KMP_DISPATCH_INIT(loc, *gtid, schedule, start, end, incr, chunk_size,
                     schedule != kmp_sch_static);
 
 #if OMPT_SUPPORT
   kmp_info_t *thr;
   ompt_frame_t *ompt_frame;
   ompt_state_t enclosing_state;

openmp/runtime/src/kmp_i18n.h

 /* Low-level functions handling message catalog. __kmp_i18n_open() opens message
    catalog, __kmp_i18n_closes() it. Explicit opening is not required: if message
    catalog is not yet open, __kmp_i18n_catgets() will open it implicitly.
    However, catalog should be explicitly closed, otherwise resources (mamory,
    handles) may leak.
 
    __kmp_i18n_catgets() returns read-only string. It should not be freed.
 
-   KMP_I18N_STR macro simplifies acces to strings in message catalog a bit.
+   KMP_I18N_STR macro simplifies access to strings in message catalog a bit.
    Following two lines are equivalent:
 
    __kmp_i18n_catgets( kmp_i18n_str_Warning )
    KMP_I18N_STR( Warning )
 */
 
 void __kmp_i18n_catopen();
 void __kmp_i18n_catclose();

openmp/runtime/src/kmp_i18n.cpp

kmp_msg_t __kmp_msg_format(unsigned id_arg, ...) {
   // default promotions.
   kmp_i18n_id_t id = (kmp_i18n_id_t)id_arg;
 
 #if KMP_OS_UNIX
   // On Linux* OS and OS X*, printf() family functions process parameter
   // numbers, for example:  "%2$s %1$s".
   __kmp_str_buf_vprint(&buffer, __kmp_i18n_catgets(id), args);
 #elif KMP_OS_WINDOWS
-  // On Winodws, printf() family functions does not recognize GNU style
+  // On Windows, printf() family functions does not recognize GNU style
   // parameter numbers, so we have to use FormatMessage() instead. It recognizes
   // parameter numbers, e. g.:  "%2!s! "%1!s!".
   {
     LPTSTR str = NULL;
     int len;
     FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
                   __kmp_i18n_catgets(id), 0, 0, (LPTSTR)(&str), 0, &args);
     len = ___strip_crs(str);

openmp/runtime/src/kmp_lock.h

 
 struct ident;
 typedef struct ident ident_t;
 
 // End of copied code.
 // ----------------------------------------------------------------------------
 
 // We need to know the size of the area we can assume that the compiler(s)
-// allocated for obects of type omp_lock_t and omp_nest_lock_t.  The Intel
+// allocated for objects of type omp_lock_t and omp_nest_lock_t.  The Intel
 // compiler always allocates a pointer-sized area, as does visual studio.
 //
 // gcc however, only allocates 4 bytes for regular locks, even on 64-bit
 // intel archs.  It allocates at least 8 bytes for nested lock (more on
 // recent versions), but we are bounded by the pointer-sized chunks that
 // the Intel compiler allocates.
 
 #if KMP_OS_LINUX && defined(KMP_GOMP_COMPAT)

 // function pointer and call it if non-NULL.
 //
 // In some cases, it makes sense to have a "get" wrapper function check for a
 // NULL get function pointer and return NULL / invalid value / error code if
 // the function pointer is NULL.
 //
 // In other cases, the calling code really should differentiate between an
 // unimplemented function and one that is implemented but returning NULL /
-// invalied value.  If this is the case, no get function wrapper exists.
+// invalid value.  If this is the case, no get function wrapper exists.
 
 extern int (*__kmp_is_user_lock_initialized_)(kmp_user_lock_p lck);
 
-// no set function; fields set durining local allocation
+// no set function; fields set during local allocation
 
 extern const ident_t *(*__kmp_get_user_lock_location_)(kmp_user_lock_p lck);
 
 static inline const ident_t *__kmp_get_user_lock_location(kmp_user_lock_p lck) {
   if (__kmp_get_user_lock_location_ != NULL) {
     return (*__kmp_get_user_lock_location_)(lck);
   } else {
     return NULL;

 
 static inline void __kmp_set_user_lock_flags(kmp_user_lock_p lck,
                                              kmp_lock_flags_t flags) {
   if (__kmp_set_user_lock_flags_ != NULL) {
     (*__kmp_set_user_lock_flags_)(lck, flags);
   }
 }
 
-// The fuction which sets up all of the vtbl pointers for kmp_user_lock_t.
+// The function which sets up all of the vtbl pointers for kmp_user_lock_t.
 extern void __kmp_set_user_lock_vptrs(kmp_lock_kind_t user_lock_kind);
 
 // Macros for binding user lock functions.
 #define KMP_BIND_USER_LOCK_TEMPLATE(nest, kind, suffix)                        \
   {                                                                            \
     __kmp_acquire##nest##user_lock_with_checks_ = (int (*)(                    \
         kmp_user_lock_p, kmp_int32))__kmp_acquire##nest##kind##_##suffix;      \
     __kmp_release##nest##user_lock_with_checks_ = (int (*)(                    \

 // with/without consistency checking.
 extern void (*__kmp_direct_init[])(kmp_dyna_lock_t *, kmp_dyna_lockseq_t);
 extern void (**__kmp_direct_destroy)(kmp_dyna_lock_t *);
 extern int (**__kmp_direct_set)(kmp_dyna_lock_t *, kmp_int32);
 extern int (**__kmp_direct_unset)(kmp_dyna_lock_t *, kmp_int32);
 extern int (**__kmp_direct_test)(kmp_dyna_lock_t *, kmp_int32);
 
 // Function tables for indirect locks. Set/unset/test differentiate functions
-// with/withuot consistency checking.
+// with/without consistency checking.
 extern void (*__kmp_indirect_init[])(kmp_user_lock_p);
 extern void (**__kmp_indirect_destroy)(kmp_user_lock_p);
 extern int (**__kmp_indirect_set)(kmp_user_lock_p, kmp_int32);
 extern int (**__kmp_indirect_unset)(kmp_user_lock_p, kmp_int32);
 extern int (**__kmp_indirect_test)(kmp_user_lock_p, kmp_int32);
 
 // Extracts direct lock tag from a user lock pointer
 #define KMP_EXTRACT_D_TAG(l)                                                   \

openmp/runtime/src/kmp_lock.cpp

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 indrect
+// the indirect lock table holds the address and type of the allocated indirect
 // lock (kmp_indirect_lock_t), and the size of the table doubles when it is
 // full. A destroyed indirect lock object is returned to the reusable pool of
 // locks, unique to each lock type.
 kmp_indirect_lock_t *__kmp_allocate_indirect_lock(void **user_lock,
                                                   kmp_int32 gtid,
                                                   kmp_indirect_locktag_t tag) {
   kmp_indirect_lock_t *lck;
   kmp_lock_index_t idx;

openmp/runtime/src/kmp_omp.h

kmp_uint64
       file; // Pointer to name of source file where the parallel region is.
   kmp_uint64 func; // Pointer to name of routine where the parallel region is.
   kmp_int32 begin; // Beginning of source line range.
   kmp_int32 end; // End of source line range.
   kmp_int32 num_threads; // Specified number of threads.
 } kmp_omp_nthr_item_t;
 
 typedef struct {
-  kmp_int32 num; // Number of items in the arrray.
+  kmp_int32 num; // Number of items in the array.
   kmp_uint64 array; // Address of array of kmp_omp_num_threads_item_t.
 } kmp_omp_nthr_info_t;
 
 /* This structure is known to the idb interface library */
 typedef struct {
 
   /* Change this only if you make a fundamental data structure change here */
   kmp_int32 lib_version;

openmp/runtime/src/kmp_runtime.cpp

if (nNeed <= 0)
     return added;
 
   // Note that __kmp_threads_capacity is not bounded by __kmp_max_nth. If
   // __kmp_max_nth is set to some value less than __kmp_sys_max_nth by the
   // user via KMP_DEVICE_THREAD_LIMIT, then __kmp_threads_capacity may become
   // > __kmp_max_nth in one of two ways:
   //
   // 1) The initialization thread (gtid = 0) exits.  __kmp_threads[0]
-  //    may not be resused by another thread, so we may need to increase
+  //    may not be reused by another thread, so we may need to increase
   //    __kmp_threads_capacity to __kmp_max_nth + 1.
   //
   // 2) New foreign root(s) are encountered.  We always register new foreign
   //    roots. This may cause a smaller # of threads to be allocated at
   //    subsequent parallel regions, but the worker threads hang around (and
   //    eventually go to sleep) and need slots in the __kmp_threads[] array.
   //
   // Anyway, that is the reason for moving the check to see if
if (KMP_AFFINITY_CAPABLE()) {
     __kmp_set_system_affinity(__kmp_affin_fullMask, TRUE);
   }
 }
 #endif
 
 #if KMP_AFFINITY_SUPPORTED
 
 // __kmp_partition_places() is the heart of the OpenMP 4.0 affinity mechanism.
-// It calculats the worker + master thread's partition based upon the parent
+// It calculates the worker + master thread's partition based upon the parent
 // thread's partition, and binds each worker to a thread in their partition.
 // The master thread's partition should already include its current binding.
 static void __kmp_partition_places(kmp_team_t *team, int update_master_only) {
-  // Copy the master thread's place partion to the team struct
+  // Copy the master thread's place partition to the team struct
   kmp_info_t *master_th = team->t.t_threads[0];
   KMP_DEBUG_ASSERT(master_th != NULL);
   kmp_proc_bind_t proc_bind = team->t.t_proc_bind;
   int first_place = master_th->th.th_first_place;
   int last_place = master_th->th.th_last_place;
   int masters_place = master_th->th.th_current_place;
   team->t.t_first_place = first_place;
   team->t.t_last_place = last_place;

 // This change also has a potentially large performance benefit, for some
 // applications.  Previously, as threads were freed from the hot team, they
 // would be placed back on the free list in inverse order.  If the hot team
 // grew back to it's original size, then the freed thread would be placed
 // back on the hot team in reverse order.  This could cause bad cache
 // locality problems on programs where the size of the hot team regularly
 // grew and shrunk.
 //
-// Now, for single-level parallelism, the OMP tid is alway == gtid.
+// Now, for single-level parallelism, the OMP tid is always == gtid.
 void __kmp_free_thread(kmp_info_t *this_th) {
   int gtid;
   kmp_info_t **scan;
 
   KA_TRACE(20, ("__kmp_free_thread: T#%d putting T#%d back on free pool.\n",
                 __kmp_get_gtid(), this_th->th.th_info.ds.ds_gtid));
 
   KMP_DEBUG_ASSERT(this_th);
if (__kmp_thread_pool_insert_pt->th.th_info.ds.ds_gtid > gtid) {
       __kmp_thread_pool_insert_pt = NULL;
     }
   }
 
   // Scan down the list to find the place to insert the thread.
   // scan is the address of a link in the list, possibly the address of
   // __kmp_thread_pool itself.
   //
-  // In the absence of nested parallism, the for loop will have 0 iterations.
+  // In the absence of nested parallelism, the for loop will have 0 iterations.
   if (__kmp_thread_pool_insert_pt != NULL) {
     scan = &(__kmp_thread_pool_insert_pt->th.th_next_pool);
   } else {
     scan = CCAST(kmp_info_t **, &__kmp_thread_pool);
   }
   for (; (*scan != NULL) && ((*scan)->th.th_info.ds.ds_gtid < gtid);
        scan = &((*scan)->th.th_next_pool))
     ;

 }
 
 void __kmp_internal_end_library(int gtid_req) {
   /* if we have already cleaned up, don't try again, it wouldn't be pretty */
   /* this shouldn't be a race condition because __kmp_internal_end() is the
      only place to clear __kmp_serial_init */
   /* we'll check this later too, after we get the lock */
   // 2009-09-06: We do not set g_abort without setting g_done. This check looks
-  // redundaant, because the next check will work in any case.
+  // redundant, because the next check will work in any case.
   if (__kmp_global.g.g_abort) {
     KA_TRACE(11, ("__kmp_internal_end_library: abort, exiting\n"));
     /* TODO abort? */
     return;
   }
   if (TCR_4(__kmp_global.g.g_done) || !__kmp_init_serial) {
     KA_TRACE(10, ("__kmp_internal_end_library: already finished\n"));
     return;

openmp/runtime/src/kmp_sched.cpp

static void __kmp_team_static_init(ident_t *loc, kmp_int32 gtid,
                                    kmp_int32 *p_last, T *p_lb, T *p_ub,
                                    typename traits_t<T>::signed_t *p_st,
                                    typename traits_t<T>::signed_t incr,
                                    typename traits_t<T>::signed_t chunk) {
   // The routine returns the first chunk distributed to the team and
   // stride for next chunks calculation.
   // Last iteration flag set for the team that will execute
   // the last iteration of the loop.
-  // The routine is called for dist_schedue(static,chunk) only.
+  // The routine is called for dist_schedule(static,chunk) only.
   typedef typename traits_t<T>::unsigned_t UT;
   typedef typename traits_t<T>::signed_t ST;
   kmp_uint32 team_id;
   kmp_uint32 nteams;
   UT trip_count;
   T lower;
   T upper;
   ST span;

openmp/runtime/src/kmp_settings.cpp

static void __kmp_stg_parse_str(char const *name, char const *value,
   __kmp_str_free(out);
   *out = __kmp_str_format("%s", value);
 } // __kmp_stg_parse_str
 
 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: Miminal allowed value.
+    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) {

 } // __kmp_stg_parse_max_task_priority
 
 static void __kmp_stg_print_max_task_priority(kmp_str_buf_t *buffer,
                                               char const *name, void *data) {
   __kmp_stg_print_int(buffer, name, __kmp_max_task_priority);
 } // __kmp_stg_print_max_task_priority
 
 // KMP_TASKLOOP_MIN_TASKS
-// taskloop threashold to switch from recursive to linear tasks creation
+// taskloop threshold to switch from recursive to linear tasks creation
 static void __kmp_stg_parse_taskloop_min_tasks(char const *name,
                                                char const *value, void *data) {
   int tmp;
   __kmp_stg_parse_int(name, value, 0, INT_MAX, &tmp);
   __kmp_taskloop_min_tasks = tmp;
 } // __kmp_stg_parse_taskloop_min_tasks
 
 static void __kmp_stg_print_taskloop_min_tasks(kmp_str_buf_t *buffer,
static void __kmp_parse_affinity_env(char const *name, char const *value,
   buf = buffer;
   SKIP_WS(buf);
 
 // Helper macros.
 
 // If we see a parse error, emit a warning and scan to the next ",".
 //
 // FIXME - there's got to be a better way to print an error
-// message, hopefully without overwritting peices of buf.
+// message, hopefully without overwriting peices of buf.
 #define EMIT_WARN(skip, errlist)                                               \
   {                                                                            \
     char ch;                                                                   \
     if (skip) {                                                                \
       SKIP_TO(next, ',');                                                      \
     }                                                                          \
     ch = *next;                                                                \
     *next = '\0';                                                              \

 
 #endif // KMP_DEBUG_ADAPTIVE_LOCKS
 
 #endif // KMP_USE_ADAPTIVE_LOCKS
 
 // -----------------------------------------------------------------------------
 // KMP_HW_SUBSET (was KMP_PLACE_THREADS)
 
-// The longest observable sequense of items is
+// The longest observable sequence of items is
 // Socket-Node-Tile-Core-Thread
 // So, let's limit to 5 levels for now
 // The input string is usually short enough, let's use 512 limit for now
 #define MAX_T_LEVEL 5
 #define MAX_STR_LEN 512
 static void __kmp_stg_parse_hw_subset(char const *name, char const *value,
                                       void *data) {
   // Value example: 1s,5c@3,2T

openmp/runtime/src/kmp_stats.h

 // OMP_loop_static_scheduling -- Time thread spends scheduling loop iterations
 //                               from a statically scheduled loop
 // OMP_loop_dynamic       -- Time thread spends executing loop iterations from
 //                           a dynamically scheduled loop
 // OMP_loop_dynamic_scheduling -- Time thread spends scheduling loop iterations
 //                                from a dynamically scheduled loop
 // OMP_critical           -- Time thread spends executing critical section
 // OMP_critical_wait      -- Time thread spends waiting to enter
-//                           a critcal seciton
+//                           a critical section
 // OMP_single             -- Time spent executing a "single" region
 // OMP_master             -- Time spent executing a "master" region
 // OMP_task_immediate     -- Time spent executing non-deferred tasks
 // OMP_task_taskwait      -- Time spent executing tasks inside a taskwait
 //                           construct
 // OMP_task_taskyield     -- Time spent executing tasks inside a taskyield
 //                           construct
 // OMP_task_taskgroup     -- Time spent executing tasks inside a taskygroup
public:
   partitionedTimers();
   void init(explicitTimer timer);
   void exchange(explicitTimer timer);
   void push(explicitTimer timer);
   void pop();
   void windup();
 };
 
-// Special wrapper around the partioned timers to aid timing code blocks
+// Special wrapper around the partitioned timers to aid timing code blocks
 // It avoids the need to have an explicit end, leaving the scope suffices.
 class blockPartitionedTimer {
   partitionedTimers *part_timers;
 
 public:
   blockPartitionedTimer(partitionedTimers *pt, explicitTimer timer)
       : part_timers(pt) {
     part_timers->push(timer);

  * 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 paritioned timers to begin with name.
+ * \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))

openmp/runtime/src/kmp_stats.cpp

/* We accept the risk that we drop a sample because it really did start at
      t==0. */
   startTime = 0;
   return;
 }
 
 /* ************* partitionedTimers member functions ************* */
 partitionedTimers::partitionedTimers() { timer_stack.reserve(8); }
 
-// initialize the paritioned timers to an initial timer
+// initialize the partitioned timers to an initial timer
 void partitionedTimers::init(explicitTimer timer) {
   KMP_DEBUG_ASSERT(this->timer_stack.size() == 0);
   timer_stack.push_back(timer);
   timer_stack.back().start(tsc_tick_count::now());
 }
 
 // stop/save the current timer, and start the new timer (timer_pair)
 // There is a special condition where if the current timer is equal to
void kmp_stats_output_module::printTimerStats(FILE *statsOut,
   // Also print the Total_ versions of times.
   for (timer_e s = timer_e(0); s < TIMER_LAST; s = timer_e(s + 1)) {
     char tag = timeStat::noUnits(s) ? ' ' : 'T';
     if (totalStats && !timeStat::noTotal(s))
       fprintf(statsOut, "Total_%-29s, %s\n", timeStat::name(s),
               totalStats[s].format(tag, true).c_str());
   }
 
-  // Print historgram of statistics
+  // Print histogram of statistics
   if (theStats[0].haveHist()) {
     fprintf(statsOut, "\nTimer distributions\n");
     for (int s = 0; s < TIMER_LAST; s++) {
       statistic const *stat = &theStats[s];
 
       if (stat->getCount() != 0) {
         char tag = timeStat::noUnits(timer_e(s)) ? ' ' : 'T';
 

openmp/runtime/src/kmp_str.h

 struct kmp_str_fname {
   char *path;
   char *dir;
   char *base;
 }; // struct kmp_str_fname
 typedef struct kmp_str_fname kmp_str_fname_t;
 void __kmp_str_fname_init(kmp_str_fname_t *fname, char const *path);
 void __kmp_str_fname_free(kmp_str_fname_t *fname);
-// Compares file name with specified patern. If pattern is NULL, any fname
+// Compares file name with specified pattern. If pattern is NULL, any fname
 // matched.
 int __kmp_str_fname_match(kmp_str_fname_t const *fname, char const *pattern);
 
 /* The compiler provides source locations in string form
-   ";file;func;line;col;;". It is not convenient for manupulation. This
+   ";file;func;line;col;;". It is not convenient for manipulation. This
    structure keeps source location in more convenient form.
    Usage:
 
    kmp_str_loc_t loc = __kmp_str_loc_init( ident->psource, 0 );
    // use loc.file, loc.func, loc.line, loc.col.
    // loc.fname is available if second argument of __kmp_str_loc_init is true.
    __kmp_str_loc_free( & loc );
 

openmp/runtime/src/kmp_stub.cpp

 void kmp_set_defaults(char const *str) { i; }
 void kmp_set_disp_num_buffers(omp_int_t arg) { i; }
 
 /* KMP memory management functions. */
 void *kmp_malloc(size_t size) {
   i;
   void *res;
 #if KMP_OS_WINDOWS
-  // If succesfull returns a pointer to the memory block, otherwise returns
+  // If successful returns a pointer to the memory block, otherwise returns
   // NULL.
   // Sets errno to ENOMEM or EINVAL if memory allocation failed or parameter
   // validation failed.
   res = _aligned_malloc(size, 1);
 #else
   res = malloc(size);
 #endif
   return res;

openmp/runtime/src/kmp_taskdeps.cpp

 // TODO: Any ITT support needed?
 
 #ifdef KMP_SUPPORT_GRAPH_OUTPUT
 static std::atomic<kmp_int32> kmp_node_id_seed = ATOMIC_VAR_INIT(0);
 #endif
 
 static void __kmp_init_node(kmp_depnode_t *node) {
   node->dn.successors = NULL;
-  node->dn.task = NULL; // will point to the rigth task
+  node->dn.task = NULL; // will point to the right task
   // once dependences have been processed
   for (int i = 0; i < MAX_MTX_DEPS; ++i)
     node->dn.mtx_locks[i] = NULL;
   node->dn.mtx_num_locks = 0;
   __kmp_init_lock(&node->dn.lock);
   KMP_ATOMIC_ST_RLX(&node->dn.nrefs, 1); // init creates the first reference
 #ifdef KMP_SUPPORT_GRAPH_OUTPUT
   node->dn.id = KMP_ATOMIC_INC(&kmp_node_id_seed);
#endif
 
   node->dn.task = task;
   KMP_MB();
 
   // Account for our initial fake value
   npredecessors++;
 
   // Update predecessors and obtain current value to check if there are still
-  // any outstandig dependences (some tasks may have finished while we processed
-  // the dependences)
+  // any outstanding dependences (some tasks may have finished while we
+  // processed the dependences)
   npredecessors =
       node->dn.npredecessors.fetch_add(npredecessors) + npredecessors;
 
   KA_TRACE(20, ("__kmp_check_deps: T#%d found %d predecessors for task %p \n",
                 gtid, npredecessors, taskdata));
 
   // beyond this point the task could be queued (and executed) by a releasing
   // task...
   return npredecessors > 0 ? true : false;
 }
 
 /*!
 @ingroup TASKING
 @param loc_ref location of the original task directive
 @param gtid Global Thread ID of encountering thread
 @param new_task task thunk allocated by __kmp_omp_task_alloc() for the ''new
 task''
 @param ndeps Number of depend items with possible aliasing
 @param dep_list List of depend items with possible aliasing
 @param ndeps_noalias Number of depend items with no aliasing
 @param noalias_dep_list List of depend items with no aliasing
 
 @return Returns either TASK_CURRENT_NOT_QUEUED if the current task was not
-suspendend and queued, or TASK_CURRENT_QUEUED if it was suspended and queued
+suspended and queued, or TASK_CURRENT_QUEUED if it was suspended and queued
 
 Schedule a non-thread-switchable task with dependences for execution
 */
 kmp_int32 __kmpc_omp_task_with_deps(ident_t *loc_ref, kmp_int32 gtid,
                                     kmp_task_t *new_task, kmp_int32 ndeps,
                                     kmp_depend_info_t *dep_list,
                                     kmp_int32 ndeps_noalias,
                                     kmp_depend_info_t *noalias_dep_list) {

openmp/runtime/src/kmp_tasking.cpp

#endif
 
   KA_TRACE(
       20, ("__kmp_task_finish: T#%d finished task %p, %d incomplete children\n",
            gtid, taskdata, children));
 
   /* If the tasks' destructor thunk flag has been set, we need to invoke the
      destructor thunk that has been generated by the compiler. The code is
      placed here, since at this point other tasks might have been released
-     hence overlapping the destructor invokations with some other work in the
+     hence overlapping the destructor invocations with some other work in the
      released tasks.  The OpenMP spec is not specific on when the destructors
      are invoked, so we should be free to choose. */
   if (taskdata->td_flags.destructors_thunk) {
     kmp_routine_entry_t destr_thunk = task->data1.destructors;
     KMP_ASSERT(destr_thunk);
     destr_thunk(gtid, task);
   }
 
__kmpc_omp_reg_task_with_affinity(ident_t *loc_ref, kmp_int32 gtid,
                                   kmp_task_affinity_info_t *affin_list) {
   return 0;
 }
 
 //  __kmp_invoke_task: invoke the specified task
 //
 // gtid: global thread ID of caller
 // task: the task to invoke
-// current_task: the task to resume after task invokation
+// current_task: the task to resume after task invocation
 static void __kmp_invoke_task(kmp_int32 gtid, kmp_task_t *task,
                               kmp_taskdata_t *current_task) {
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
   kmp_info_t *thread;
   int discard = 0 /* false */;
   KA_TRACE(
       30, ("__kmp_invoke_task(enter): T#%d invoking task %p, current_task=%p\n",
            gtid, taskdata, current_task));

 #if USE_ITT_BUILD
       if (itt_sync_obj != NULL)
         __kmp_itt_task_finished(itt_sync_obj);
 #endif /* USE_ITT_BUILD */
       // If this thread is only partway through the barrier and the condition is
       // met, then return now, so that the barrier gather/release pattern can
       // proceed. If this thread is in the last spin loop in the barrier,
       // waiting to be released, we know that the termination condition will not
-      // be satisified, so don't waste any cycles checking it.
+      // be satisfied, so don't waste any cycles checking it.
       if (flag == NULL || (!final_spin && flag->done_check())) {
         KA_TRACE(
             15,
             ("__kmp_execute_tasks_template: T#%d spin condition satisfied\n",
              gtid));
         return TRUE;
       }
       if (thread->th.th_task_team == NULL) {

  * and return the threads to the thread pool).
  *
  * This does not work with the tasking code, as the thread is still
  * expected to participate in the execution of any tasks that may have been
  * spawned my a member of the team, and the thread still needs access to all
  * to each thread in the team, so that it can steal work from it.
  *
  * Enter the existence of the kmp_task_team_t struct.  It employs a reference
- * counting mechanims, and is allocated by the master thread before calling
+ * counting mechanism, and is allocated by the master thread before calling
  * __kmp_<barrier_kind>_release, and then is release by the last thread to
  * exit __kmp_<barrier_kind>_release at the next barrier.  I.e. the lifetimes
  * of the kmp_task_team_t structs for consecutive barriers can overlap
  * (and will, unless the master thread is the last thread to exit the barrier
  * release phase, which is not typical). The existence of such a struct is
  * useful outside the context of tasking.
  *
  * We currently use the existence of the threads array as an indicator that
  * tasks were spawned since the last barrier.  If the structure is to be
  * useful outside the context of tasking, then this will have to change, but
- * not settting the field minimizes the performance impact of tasking on
+ * not setting the field minimizes the performance impact of tasking on
  * barriers, when no explicit tasks were spawned (pushed, actually).
  */
 
 static kmp_task_team_t *__kmp_free_task_teams =
     NULL; // Free list for task_team data structures
 // Lock for task team data structures
 kmp_bootstrap_lock_t __kmp_task_team_lock =
     KMP_BOOTSTRAP_LOCK_INITIALIZER(__kmp_task_team_lock);

 // lb         Pointer to loop lower bound in task structure
 // ub         Pointer to loop upper bound in task structure
 // st         Loop stride
 // ub_glob    Global upper bound (used for lastprivate check)
 // num_tasks  Number of tasks to execute
 // grainsize  Number of loop iterations per task
 // extras     Number of chunks with grainsize+1 iterations
 // tc         Iterations count
-// num_t_min  Threashold to launch tasks recursively
+// num_t_min  Threshold to launch tasks recursively
 // task_dup   Tasks duplication routine
 // codeptr_ra Return address for OMPT events
 void __kmp_taskloop_recur(ident_t *loc, int gtid, kmp_task_t *task,
                           kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st,
                           kmp_uint64 ub_glob, kmp_uint64 num_tasks,
                           kmp_uint64 grainsize, kmp_uint64 extras,
                           kmp_uint64 tc, kmp_uint64 num_t_min,
 #if OMPT_SUPPORT

openmp/runtime/src/kmp_utility.cpp

if ((buf.edx >> 15) & 1) {
       /* CMOV - Conditional MOVe Instruction Available */
       KA_TRACE(trace_level, (" CMOV"));
     }
     if ((buf.edx >> 18) & 1) {
       /* PSN - Processor Serial Number Available */
       KA_TRACE(trace_level, (" PSN"));
     }
     if ((buf.edx >> 19) & 1) {
-      /* CLFULSH - Cache Flush Instruction Available */
+      /* CLFLUSH - Cache Flush Instruction Available */
       cflush_size =
           data[1] * 8; /* Bits 15-08: CLFLUSH line size = 8 (64 bytes) */
       KA_TRACE(trace_level, (" CLFLUSH(%db)", cflush_size));
     }
     if ((buf.edx >> 21) & 1) {
       /* DTES - Debug Trace & EMON Store */
       KA_TRACE(trace_level, (" DTES"));
     }

openmp/runtime/src/kmp_wrapper_malloc.h

 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef KMP_WRAPPER_MALLOC_H
 #define KMP_WRAPPER_MALLOC_H
 
 /* This header serves for 3 purposes:
-   1. Declaring standard memory allocation rourines in OS-independent way.
+   1. Declaring standard memory allocation routines in OS-independent way.
    2. Passing source location info through memory allocation wrappers.
    3. Enabling native memory debugging capabilities.
 
-   1. Declaring standard memory allocation rourines in OS-independent way.
+   1. Declaring standard memory allocation routines in OS-independent way.
    -----------------------------------------------------------------------
    On Linux* OS, alloca() function is declared in <alloca.h> header, while on
    Windows* OS there is no <alloca.h> header, function _alloca() (note
    underscore!) is declared in <malloc.h>. This header eliminates these
    differences, so client code including "kmp_wrapper_malloc.h" can rely on
    following routines:
 
         malloc

 #elif KMP_OS_DRAGONFLY || KMP_OS_FREEBSD || KMP_OS_NETBSD || KMP_OS_OPENBSD
 // Declared in "stdlib.h".
 #elif KMP_OS_UNIX
 #include <alloca.h> // Linux* OS and OS X*: alloc() declared in "alloca".
 #else
 #error Unknown or unsupported OS.
 #endif
 
-/* KMP_SRC_LOC_DECL -- Declaring source location paramemters, to be used in
+/* KMP_SRC_LOC_DECL -- Declaring source location parameters, to be used in
    function declaration.
-   KMP_SRC_LOC_PARM -- Source location paramemters, to be used to pass
+   KMP_SRC_LOC_PARM -- Source location parameters, to be used to pass
    parameters to underlying levels.
    KMP_SRC_LOC_CURR -- Source location arguments describing current location,
    to be used at top-level.
 
    Typical usage:
    void * _aligned_malloc( int size KMP_SRC_LOC_DECL ) {
      // Note: Comma is missed before KMP_SRC_LOC_DECL.
      KE_TRACE( 25, ( "called from %s:%d\n", KMP_SRC_LOC_PARM ) );

openmp/runtime/src/ompt-specific.h

 
 inline void ompt_set_thread_state(kmp_info_t *thread, ompt_state_t state) {
   thread->th.ompt_thread_info.state = state;
 }
 
 inline const char *ompt_get_runtime_version() {
   return &__kmp_version_lib_ver[KMP_VERSION_MAGIC_LEN];
 }
-#endif // OMPT_SUPPRORT
+#endif // OMPT_SUPPORT
 
 // macros providing the OMPT callbacks for reduction clause
 #if OMPT_SUPPORT && OMPT_OPTIONAL
 #define OMPT_REDUCTION_DECL(this_thr, gtid)                                    \
   ompt_data_t *my_task_data = OMPT_CUR_TASK_DATA(this_thr);                    \
   ompt_data_t *my_parallel_data = OMPT_CUR_TEAM_DATA(this_thr);                \
   void *return_address = OMPT_LOAD_RETURN_ADDRESS(gtid);
 #define OMPT_REDUCTION_BEGIN                                                   \

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

  * 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_metdata_type.
+ * The type of metadata is specified by an enumerated type __itt_metadata_type.
  * @{
  */
 
 /**
  * @ingroup parameters
  * @brief describes the type of metadata
  */
 typedef enum {

 #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,timestame,relation,tail)
+#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_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
 #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 */

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

for (; s[i]; i++)
             break;
     }
 
     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 aviod dynamic allocation for few 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)
 {
 #define MAX_ENV_VALUE_SIZE 4086
     static char  env_buff[MAX_ENV_VALUE_SIZE];
     static char* env_value = (char*)env_buff;
 
static void __itt_reinit_all_pointers(void)
     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;
 }
 */
 
 static void __itt_nullify_all_pointers(void)
 {
     int i;
-    /* Nulify all pointers except domain_create, string_handle_create  and counter_create */
+    /* 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;
 }
 
 #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' */

openmp/runtime/src/z_Linux_util.cpp

if (__kmp_load_balance_interval < 180 && (res >= 1)) {
     return -1;
   }
 
   return ret_avg;
 }
 
 #else // Linux* OS
 
-// The fuction returns number of running (not sleeping) threads, or -1 in case
+// The function returns number of running (not sleeping) threads, or -1 in case
 // of error. Error could be reported if Linux* OS kernel too old (without
 // "/proc" support). Counting running threads stops if max running threads
 // encountered.
 int __kmp_get_load_balance(int max) {
   static int permanent_error = 0;
   static int glb_running_threads = 0; // Saved count of the running threads for
   // the thread balance algorithm
   static double glb_call_time = 0; /* Thread balance algorithm call time */

openmp/runtime/test/lock/omp_init_lock.c

for (i = 0; i < ITERATIONS; i++) {
     for (j = 0; j < LOCKS_PER_ITER; j++) {
       omp_init_lock(&my_lcks[j]);
     }
     for (j = 0; j < LOCKS_PER_ITER * 100; j++) {
       omp_set_lock(&my_lcks[j % LOCKS_PER_ITER]);
       omp_unset_lock(&my_lcks[j % LOCKS_PER_ITER]);
     }
   }
-  // Wait until all repititions are done.  The test is exercising growth of
+  // Wait until all repetitions are done.  The test is exercising growth of
   // the global lock pool, which does not shrink when no locks are allocated.
   {
     int j;
     for (j = 0; j < ITERATIONS * LOCKS_PER_ITER; j++) {
       omp_destroy_lock(&lcks[j]);
     }
   }
 
   return 0;
 }
 
 int main() {
   // No use repeating this test, since it's exercising a private global pool
   // which is not reset between test iterations.
   return test_omp_init_lock();
 }

openmp/runtime/test/ompt/synchronization/barrier/implicit_task_data.c

 // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
 // REQUIRES: ompt
 
 // This test checks that values stored in task_data in a barrier_begin event
 // are still present in the corresponding barrier_end event.
-// Therefore, callback implementations different from the ones in callback.h are neccessary.
+// Therefore, callback implementations different from the ones in callback.h are necessary.
 // This is a test for an issue reported in 
 // https://github.com/OpenMPToolsInterface/LLVM-openmp/issues/39
 
 #define _BSD_SOURCE
 #include <stdio.h>
 #include <unistd.h>
 #include <inttypes.h>
 #include <omp.h>

openmp/runtime/test/tasking/kmp_task_modifier_simple_par_new.cpp

 //------------------------------------------------
 // Compiler-generated code
 
 typedef struct red_input {
   void *reduce_shar; /**< shared between tasks item to reduce into */
   void *reduce_orig; /**< original reduction item used for initialization */
   size_t reduce_size; /**< size of data item in bytes */
   // three compiler-generated routines (init, fini are optional):
-  void *reduce_init; /**< data initialization routine (single paramemter) */
+  void *reduce_init; /**< data initialization routine (single parameter) */
   void *reduce_fini; /**< data finalization routine */
   void *reduce_comb; /**< data combiner routine */
   unsigned flags; /**< flags for additional info from compiler */
 } red_input_t;
 
 void i_comb(void *lhs, void *rhs) { *(int *)lhs += *(int *)rhs; }
 
 int main() {

openmp/runtime/test/tasking/kmp_task_modifier_simple_par_old.cpp

 
 //------------------------------------------------
 // Compiler-generated code
 
 typedef struct red_input {
   void *reduce_shar; /**< shared between tasks item to reduce into */
   size_t reduce_size; /**< size of data item in bytes */
   // three compiler-generated routines (init, fini are optional):
-  void *reduce_init; /**< data initialization routine (single paramemter) */
+  void *reduce_init; /**< data initialization routine (single parameter) */
   void *reduce_fini; /**< data finalization routine */
   void *reduce_comb; /**< data combiner routine */
   unsigned flags; /**< flags for additional info from compiler */
 } red_input_t;
 
 void i_comb(void *lhs, void *rhs) { *(int *)lhs += *(int *)rhs; }
 
 int main() {

openmp/runtime/test/tasking/kmp_task_modifier_simple_ws_new.cpp

 //------------------------------------------------
 // Compiler-generated code
 
 typedef struct red_input {
   void *reduce_shar; /**< shared between tasks item to reduce into */
   void *reduce_orig; /**< original reduction item used for initialization */
   size_t reduce_size; /**< size of data item in bytes */
   // three compiler-generated routines (init, fini are optional):
-  void *reduce_init; /**< data initialization routine (single paramemter) */
+  void *reduce_init; /**< data initialization routine (single parameter) */
   void *reduce_fini; /**< data finalization routine */
   void *reduce_comb; /**< data combiner routine */
   unsigned flags; /**< flags for additional info from compiler */
 } red_input_t;
 
 void i_comb(void *lhs, void *rhs) { *(int *)lhs += *(int *)rhs; }
 
 int main() {

openmp/runtime/test/tasking/kmp_task_modifier_simple_ws_old.cpp

 
 //------------------------------------------------
 // Compiler-generated code
 
 typedef struct red_input {
   void *reduce_shar; /**< shared between tasks item to reduce into */
   size_t reduce_size; /**< size of data item in bytes */
   // three compiler-generated routines (init, fini are optional):
-  void *reduce_init; /**< data initialization routine (single paramemter) */
+  void *reduce_init; /**< data initialization routine (single parameter) */
   void *reduce_fini; /**< data finalization routine */
   void *reduce_comb; /**< data combiner routine */
   unsigned flags; /**< flags for additional info from compiler */
 } red_input_t;
 
 void i_comb(void *lhs, void *rhs) { *(int *)lhs += *(int *)rhs; }
 
 int main() {

openmp/runtime/test/worksharing/for/omp_for_schedule_static_3.c

#ifdef VERBOSE
     fprintf (stderr, "%d: %d \n", i, tids[i]);
 #endif
   }
 
   /* Now we check if several loop regions in one parallel region have the
    * same logical assignment of chunks to threads. We use the nowait
    * clause to increase the probability to get an error. */
 
-  /* First we allocate some more memmory */
+  /* First we allocate some more memory */
   free (tids);
   tids = (int *) malloc (sizeof (int) * LOOPCOUNT);
   tids2 = (int *) malloc (sizeof (int) * LOOPCOUNT);
 
   #pragma omp parallel
   {
     {
       int n;

openmp/runtime/tools/check-depends.pl

 
 use tools;
 
 our $VERSION = "0.005";
 my $target_os;
 my $target_arch;
 
 # --------------------------------------------------------------------------------------------------
-# Ouput parse error.
+# Output parse error.
 #     $tool -- Name of tool.
 #     @bulk -- Output of the tool.
 #     $n    -- Number of line caused parse error.
 sub parse_error($\@$) {
     my ( $tool, $bulk, $n ) = @_;
     my @bulk;
     for ( my $i = 0; $i < @$bulk; ++ $i ) {
         push( @bulk, ( $i == $n ? ">>> " : "    " ) . $bulk->[ $i ] );

openmp/runtime/tools/check-execstack.pl

 =pod
 
 =head1 NAME
 
 B<check-execstack.pl> -- Check whether stack is executable, issue an error if so.
 
 =head1 SYNOPSIS
 
-B<check-execstack.pl> I<optiion>... I<file>...
+B<check-execstack.pl> I<option>... I<file>...
 
 =head1 DESCRIPTION
 
 The script checks whether stack of specified executable file, and issues error if stack is
 executable. If stack is not executable, the script exits silently with zero exit code.
 
 The script runs C<readelf> utility to get information about specified executable file. So, the
 script fails if C<readelf> is not available. Effectively it means the script works only on Linux* OS

openmp/runtime/tools/check-instruction-set.pl

sub check_file($;$$) {
     if ( not defined( $max_instructions ) ) {
         $max_instructions = 100;
     }; # if
 
     execute( [ "x86_64-k1om-linux-objdump", "-d", $file ], -stdout => \@bulk );
 
     my $n = 0;
     my $errors = 0;
-    my $current_func  = "";    # Name of current fuction.
+    my $current_func  = "";    # Name of current function.
     my $reported_func = "";    # name of last reported function.
     foreach my $line ( @bulk ) {
         ++ $n;
         if ( 0 ) {
         } elsif ( $line =~ m{^\s*$} ) {
             # Empty line.
             # Ignore.
         } elsif ( $line =~ m{^In archive (.*?):\s*$} ) {

openmp/runtime/tools/generate-def.pl

foreach my $entry ( sort( keys( %$entries ) ) ) {
         }; # if
     }; # foreach
     if ( defined( $output ) ) {
         write_file( $output, \$bulk );
     } else {
         print( $bulk );
     }; # if
 
-}; # sub generate_ouput
+}; # sub generate_output
 
 #
 # Parse command line.
 #
 
 my $input;   # The name of input file.
 my $output;  # The name of output file.
 my %defs;

 
 A name of input file.
 
 =back
 
 =head1 DESCRIPTION
 
 The script reads input file, process conditional directives, checks content for consistency, and
-generates ouptput file suitable for linker.
+generates output file suitable for linker.
 
 =head2 Input File Format
 
 =over
 
 =item Comments
 
     # It's a comment.
 
 Comments start with C<#> symbol and continue to the end of line.
 
 =item Conditional Directives
 
     %ifdef name
     %ifndef name
     %endif
 
 A part of file surrounded by C<%ifdef I<name>> and C<%endif> directives is a conditional part -- it
-has effect only if I<name> is defined in the comman line by B<--define> option. C<%ifndef> is a
+has effect only if I<name> is defined in the command line by B<--define> option. C<%ifndef> is a
 negated version of C<%ifdef> -- conditional part has an effect only if I<name> is B<not> defined.
 
 Conditional parts may be nested.
 
 =item Export Definitions
 
     symbol
     symbol ordinal

openmp/runtime/tools/lib/Platform.pm

 
 sub target_options() {
     my @options = (
         "target-os|os=s" =>
             sub {
                 set_target_os( $_[ 1 ] ) or
                     die "Bad value of --target-os option: \"$_[ 1 ]\"\n";
             },
-        "target-architecture|targert-arch|architecture|arch=s" =>
+        "target-architecture|target-arch|architecture|arch=s" =>
            sub {
                set_target_arch( $_[ 1 ] ) or
                    die "Bad value of --target-architecture option: \"$_[ 1 ]\"\n";
            },
-        "target-mic-architecture|targert-mic-arch|mic-architecture|mic-arch=s" =>
+        "target-mic-architecture|target-mic-arch|mic-architecture|mic-arch=s" =>
            sub {
                set_target_mic_arch( $_[ 1 ] ) or
                    die "Bad value of --target-mic-architecture option: \"$_[ 1 ]\"\n";
            },
     );
     return @options;
 }; # sub target_options
 
=head1 SYNOPSIS
     use tools;
 
     my $arch   = canon_arch( "em64T" );        # Returns "32e".
     my $legal  = legal_arch( "em64t" );        # Returns "Intel(R) 64".
     my $option = arch_opt( "em64t" );          # Returns "intel64".
     my $os     = canon_os( "Windows NT" );     # Returns "win".
 
     print( $host_arch, $host_os, $host_platform );
-    print( $taregt_arch, $target_os, $target_platform );
+    print( $target_arch, $target_os, $target_platform );
 
     tools::get_options(
         Platform::target_options(),
         ...
     );
 
 
 =head1 DESCRIPTION

openmp/runtime/tools/lib/tools.pm

 use vars qw( $tool $verbose $timestamps );
 $tool = $FindBin::Script;
 
 my @warning = ( sub {}, \&warning, \&runtime_error );
 
 
 sub check_opts(\%$;$) {
 
-    my $opts = shift( @_ );  # Referense to hash containing real options and their values.
+    my $opts = shift( @_ );  # Reference to hash containing real options and their values.
     my $good = shift( @_ );  # Reference to an array containing all known option names.
     my $msg  = shift( @_ );  # Optional (non-mandatory) message.
 
     if ( not defined( $msg ) ) {
         $msg = "unknown option(s) passed";   # Default value for $msg.
     }; # if
 
     # I'll use these hashes as sets of options.

 B<Synopsis:>
 
     get_options( @arguments )
 
 B<Description:>
 
 It is very simple wrapper arounf Getopt::Long::GetOptions. It passes all arguments to GetOptions,
 and add definitions for standard help options: --help, --doc, --verbose, and --quiet.
-When GetOptions finihes, this subroutine checks exit code, if it is non-zero, standard error
+When GetOptions finishes, this subroutine checks exit code, if it is non-zero, standard error
 message is issued and script terminated.
 
 If --verbose or --quiet option is specified, C<tools.pm_verbose> environment variable is set.
 It is the way to propagate verbose/quiet mode to callee Perl scripts.
 
 =cut
 
 sub get_options {

 
 B<Synopsis:>
 
     $verbose
 
 B<Description:>
 
 Package variable. It determines verbosity level, which affects C<warning()>, C<info()>, and
-C<debug()> subroutnes .
+C<debug()> subroutines .
 
 The variable gets initial value from C<tools.pm_verbose> environment variable if it is exists.
 If the environment variable does not exist, variable is set to 2.
 
 Initial value may be overridden later directly or by C<get_options> function.
 
 =cut
 
 $verbose = exists( $ENV{ "tools.pm_verbose" } ) ? $ENV{ "tools.pm_verbose" } : 2;
 
 #--------------------------------------------------------------------------------------------------
 
 =pod
 
 =head3 $timestamps
 
 B<Synopsis:>
 
     $timestamps
 
 B<Description:>
 
 Package variable. It determines whether C<debug()>, C<info()>, C<warning()>, C<runtime_error()>
-subroutnes print timestamps or not.
+subroutines print timestamps or not.
 
 The variable gets initial value from C<tools.pm_timestamps> environment variable if it is exists.
 If the environment variable does not exist, variable is set to false.
 
 Initial value may be overridden later directly or by C<get_options()> function.
 
 =cut
 

 =back
 
 Examples:
 
 Look for "echo" in the directories specified in PATH:
 
     my $echo = which( "echo" );
 
-Look for all occurenses of "cp" in the PATH:
+Look for all occurrences of "cp" in the PATH:
 
     my @cps = which( "cp", -all => 1 );
 
 Look for the first occurrence of "icc" in the specified directories:
 
     my $icc = which( "icc", -dirs => [ ".", "/usr/local/bin", "/usr/bin", "/bin" ] );
 
 Look for the C<omp_lib.f> file:

 Write file.
 
 B<Arguments:>
 
 =over
 
 =item B<$file>
 
-The name or handle of file to writte to.
+The name or handle of file to write to.
 
 =item B<$bulk>
 
 Bulk to write to a file. Can be a scalar, or a reference to scalar or an array.
 
 =back
 
 B<Options:>

openmp/tools/archer/README.md

To compile Fortran applications, compile with gfortran, link with clang:
     clang -fopenmp -fsanitize=thread app.o -lgfortran
 
 
 <a id="org110062c"></a>
 
 ## Runtime Flags
 
 TSan runtime flags are passed via **TSAN&#95;OPTIONS** environment variable,
-we highly recommend the following option to aviod false alerts for the
+we highly recommend the following option to avoid false alerts for the
 OpenMP or MPI runtime implementation:
 
     export TSAN_OPTIONS="ignore_noninstrumented_modules=1"
 
 
 Runtime flags are passed via **ARCHER&#95;OPTIONS** environment variable,
 different flags are separated by spaces, e.g.:
 

openmp/tools/archer/ompt-tsan.cpp

void newDatas() {
     // For "single producer" pattern, a single thread creates tasks, these are
     // executed by other threads.
     // The master will have a high demand on TaskData, so return after use.
     struct pooldata {
       DataPool<T, N> *dp;
       T data;
     };
     // We alloc without initialize the memory. We cannot call constructors.
-    // Therfore use malloc!
+    // Therefore use malloc!
     pooldata *datas = (pooldata *)malloc(sizeof(pooldata) * N);
     memory.push_back(datas);
     for (int i = 0; i < N; i++) {
       datas[i].dp = this;
       DataPointer.push(&(datas[i].data));
     }
     total += N;
   }