[OpenMP] NFC: Fix trivial typos in comments

[Jim]

openmp/runtime/src/kmp_tasking.cpp

4148

Why new line here?

[kiszk]

openmp/runtime/src/kmp_tasking.cpp

4148

This is because this change leads to more than 80-column length.

[Jim]

LGTM.

[kiszk]

Thank you.
I do not have commit rights to the repository yet. Could someone commit this change if it is OK?
Kazuaki Ishizaki <[e-mail]>

openmp/libomptarget/deviceRTLs/common/debug.h

 
 #if OMPTARGET_NVPTX_DEBUG
 #define OMPTARGET_NVPTX_WARNING (LW_SET_NONE)
 #else
 #define OMPTARGET_NVPTX_WARNING (LW_SET_FUSSY)
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
-// implemtation for debug
+// implementation for debug
 ////////////////////////////////////////////////////////////////////////////////
 
 #if OMPTARGET_NVPTX_DEBUG || OMPTARGET_NVPTX_TEST || OMPTARGET_NVPTX_WARNING
 #include <stdio.h>
 #include "common/support.h"
 
 template <typename... Arguments>
 NOINLINE static void log(const char *fmt, Arguments... parameters) {

openmp/libomptarget/deviceRTLs/common/omptarget.h

public:
 
   // 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 (IsMasterThread) {
-      // Do not initalize this slot again if it has already been initalized.
+      // 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.
       master_rootS[0].Next = 0;
       master_rootS[0].Prev = 0;
       master_rootS[0].PrevSlotStackPtr = 0;
       return (__kmpc_data_sharing_slot *)&master_rootS[0];
     }
-    // Do not initalize this slot again if it has already been initalized.
+    // Do not initialize this slot again if it has already been initalized.
     if (worker_rootS[wid].DataEnd ==
         &worker_rootS[wid].Data[0] + DS_Worker_Warp_Slot_Size)
       return 0;
     // Initialize the pointer to the end of the slot given the size of the data
     // section. DataEnd is non-inclusive.
     worker_rootS[wid].DataEnd =
         &worker_rootS[wid].Data[0] + DS_Worker_Warp_Slot_Size;
     // We currently do not have a next slot.
public:
   INLINE omptarget_nvptx_TeamDescr &TeamContext() { return teamContext; }
 
   INLINE void InitThreadPrivateContext(int tid);
   INLINE uint64_t &Cnt() { return cnt; }
 
 private:
   // team context for this team
   omptarget_nvptx_TeamDescr teamContext;
-  // task ICV for implict threads in the only parallel region
+  // task ICV for implicit threads in the only parallel region
   omptarget_nvptx_TaskDescr levelOneTaskDescr[MAX_THREADS_PER_TEAM];
   // pointer where to find the current task ICV (top of the stack)
   omptarget_nvptx_TaskDescr *topTaskDescr[MAX_THREADS_PER_TEAM];
   union {
     // Only one of the two is live at the same time.
     // parallel
     uint16_t tnum[MAX_THREADS_PER_TEAM];
     // simd limit

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

 }
 
 EXTERN int omp_test_lock(omp_lock_t *lock) {
   int rc = __kmpc_impl_test_lock(lock);
   PRINT(LD_IO, "call omp_test_lock() return %d\n", rc);
   return rc;
 }
 
-// for xlf Fotran
-// Fotran, the return is LOGICAL type
+// for xlf Fortran
+// Fortran, the return is LOGICAL type
 
 #define FLOGICAL long
 EXTERN FLOGICAL __xlf_omp_is_initial_device_i8() {
   int ret = omp_is_initial_device();
   if (ret == 0)
     return (FLOGICAL)0;
   else
     return (FLOGICAL)1;

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

EXTERN void __kmpc_spmd_kernel_init(int ThreadLimit, int16_t RequiresOMPRuntime,
 
   // init thread private from init value
   PRINT(LD_PAR,
         "thread will execute parallel region with id %d in a team of "
         "%d threads\n",
         (int)newTaskDescr->ThreadId(), (int)ThreadLimit);
 
   if (RequiresDataSharing && GetLaneId() == 0) {
-    // Warp master innitializes data sharing environment.
+    // Warp master initializes data sharing environment.
     unsigned WID = threadId / WARPSIZE;
     __kmpc_data_sharing_slot *RootS = currTeamDescr.RootS(
         WID, WID == WARPSIZE - 1);
     DataSharingState.SlotPtr[WID] = RootS;
     DataSharingState.StackPtr[WID] = (void *)&RootS->Data[0];
   }
 }
 

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

 //===---- parallel.cu - GPU OpenMP parallel implementation ------- 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
 //
 //===----------------------------------------------------------------------===//
 //
-// Parallel implemention in the GPU. Here is the pattern:
+// Parallel implementation in the GPU. Here is the pattern:
 //
 //    while (not finished) {
 //
 //    if (master) {
 //      sequential code, decide which par loop to do, or if finished
 //     __kmpc_kernel_prepare_parallel() // exec by master only
 //    }
 //    syncthreads // A

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

EXTERN int32_t __kmpc_omp_task_with_deps(kmp_Ident *loc, uint32_t global_tid,
                                          kmp_TaskDescr *newKmpTaskDescr,
                                          int32_t depNum, void *depList,
                                          int32_t noAliasDepNum,
                                          void *noAliasDepList) {
   PRINT(LD_IO, "call to __kmpc_omp_task_with_deps(task 0x%llx)\n",
         P64(newKmpTaskDescr));
   ASSERT0(LT_FUSSY, checkRuntimeInitialized(loc),
           "Runtime must be initialized.");
-  // 1. get explict task descr from kmp task descr
+  // 1. get explicit task descr from kmp task descr
   omptarget_nvptx_ExplicitTaskDescr *newExplicitTaskDescr =
       (omptarget_nvptx_ExplicitTaskDescr *)SUB_BYTES(
           newKmpTaskDescr, sizeof(omptarget_nvptx_TaskDescr));
   ASSERT0(LT_FUSSY, &newExplicitTaskDescr->kmpTaskDescr == newKmpTaskDescr,
           "bad assumptions");
   omptarget_nvptx_TaskDescr *newTaskDescr = &newExplicitTaskDescr->taskDescr;
   ASSERT0(LT_FUSSY, (uint64_t)newTaskDescr == (uint64_t)newExplicitTaskDescr,
           "bad assumptions");

 }
 
 EXTERN void __kmpc_omp_task_begin_if0(kmp_Ident *loc, uint32_t global_tid,
                                       kmp_TaskDescr *newKmpTaskDescr) {
   PRINT(LD_IO, "call to __kmpc_omp_task_begin_if0(task 0x%llx)\n",
         (unsigned long long)newKmpTaskDescr);
   ASSERT0(LT_FUSSY, checkRuntimeInitialized(loc),
           "Runtime must be initialized.");
-  // 1. get explict task descr from kmp task descr
+  // 1. get explicit task descr from kmp task descr
   omptarget_nvptx_ExplicitTaskDescr *newExplicitTaskDescr =
       (omptarget_nvptx_ExplicitTaskDescr *)SUB_BYTES(
           newKmpTaskDescr, sizeof(omptarget_nvptx_TaskDescr));
   ASSERT0(LT_FUSSY, &newExplicitTaskDescr->kmpTaskDescr == newKmpTaskDescr,
           "bad assumptions");
   omptarget_nvptx_TaskDescr *newTaskDescr = &newExplicitTaskDescr->taskDescr;
   ASSERT0(LT_FUSSY, (uint64_t)newTaskDescr == (uint64_t)newExplicitTaskDescr,
           "bad assumptions");

 }
 
 EXTERN void __kmpc_omp_task_complete_if0(kmp_Ident *loc, uint32_t global_tid,
                                          kmp_TaskDescr *newKmpTaskDescr) {
   PRINT(LD_IO, "call to __kmpc_omp_task_complete_if0(task 0x%llx)\n",
         (unsigned long long)newKmpTaskDescr);
   ASSERT0(LT_FUSSY, checkRuntimeInitialized(loc),
           "Runtime must be initialized.");
-  // 1. get explict task descr from kmp task descr
+  // 1. get explicit task descr from kmp task descr
   omptarget_nvptx_ExplicitTaskDescr *newExplicitTaskDescr =
       (omptarget_nvptx_ExplicitTaskDescr *)SUB_BYTES(
           newKmpTaskDescr, sizeof(omptarget_nvptx_TaskDescr));
   ASSERT0(LT_FUSSY, &newExplicitTaskDescr->kmpTaskDescr == newKmpTaskDescr,
           "bad assumptions");
   omptarget_nvptx_TaskDescr *newTaskDescr = &newExplicitTaskDescr->taskDescr;
   ASSERT0(LT_FUSSY, (uint64_t)newTaskDescr == (uint64_t)newExplicitTaskDescr,
           "bad assumptions");

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

#pragma omp parallel num_threads(NumThreads)
       // Multiply return value of omp_get_level by 5 to avoid that this test
       // passes if both API calls return wrong values.
       check1[id] += omp_get_level() * 5 + omp_get_active_level();
 
       // Expected to return 0 and 1.
       check2[id] += omp_get_ancestor_thread_num(0) + 5 * omp_get_team_size(0);
       // Expected to return the current thread num.
       check2[id] += (omp_get_ancestor_thread_num(1) - id);
-      // Exepcted to return the current number of threads.
+      // Expected to return the current number of threads.
       check2[id] += 3 * omp_get_team_size(1);
       // Expected to return -1, see above.
       check2[id] += omp_get_ancestor_thread_num(2) + omp_get_team_size(2);
 
       // Expecting serialized parallel region.
       #pragma omp parallel
       {
         #pragma omp atomic
         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);
-        // Exepcted to return the number of threads in the active parallel region.
+        // 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.
         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/plugins/cuda/src/rtl.cpp

struct KernelTy {
   // 0 - SPMD mode (without master warp)
   // 1 - Generic mode (with master warp)
   int8_t ExecutionMode;
 
   KernelTy(CUfunction _Func, int8_t _ExecutionMode)
       : Func(_Func), ExecutionMode(_ExecutionMode) {}
 };
 
-/// Device envrionment data
+/// Device environment data
 /// Manually sync with the deviceRTL side for now, move to a dedicated header file later.
 struct omptarget_device_environmentTy {
   int32_t debug_level;
 };
 
 /// List that contains all the kernels.
 /// FIXME: we may need this to be per device and per library.
 std::list<KernelTy> KernelsList;
if (e->size) {
           DPxPTR(e - HostBegin), e->name, DPxPTR(cuptr));
       entry.addr = (void *)cuptr;
 
       // Note: In the current implementation declare target variables
       // can either be link or to. This means that once unified
       // memory is activated via the requires directive, the variable
       // can be used directly from the host in both cases.
       // TODO: when variables types other than to or link are added,
-      // the below condition should be changed to explicitely
+      // the below condition should be changed to explicitly
       // check for to and link variables types:
       //  (DeviceInfo.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY &&
       //   (e->flags & OMP_DECLARE_TARGET_LINK ||
       //    e->flags == OMP_DECLARE_TARGET_TO))
       if (DeviceInfo.RequiresFlags & OMP_REQ_UNIFIED_SHARED_MEMORY) {
         // If unified memory is present any target link or to variables
         // can access host addresses directly. There is no longer a
         // need for device copies.
if (err == CUDA_SUCCESS) {
             DPxPTR(&device_env), DPxPTR(device_env_Ptr), cusize);
         CUDA_ERR_STRING(err);
         return NULL;
       }
 
       DP("Sending global device environment data %zu bytes\n", (size_t)cusize);
     } else {
       DP("Finding global device environment '%s' - symbol missing.\n", device_env_Name);
-      DP("Continue, considering this is a device RTL which does not accept envrionment setting.\n");
+      DP("Continue, considering this is a device RTL which does not accept environment setting.\n");
     }
   }
 
   return DeviceInfo.getOffloadEntriesTable(device_id);
 }
 
 void *__tgt_rtl_data_alloc(int32_t device_id, int64_t size, void *hst_ptr) {
   if (size == 0) {

openmp/libomptarget/src/private.h

 // This structure stores all components of a user-defined mapper. The number of
 // components are dynamically decided, so we utilize C++ STL vector
 // implementation here.
 struct MapperComponentsTy {
   std::vector<MapComponentInfoTy> Components;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// implemtation for fatal messages
+// implementation for fatal messages
 ////////////////////////////////////////////////////////////////////////////////
 
 #define FATAL_MESSAGE0(_num, _str)                                    \
   do {                                                                \
     fprintf(stderr, "Libomptarget fatal error %d: %s\n", _num, _str); \
     exit(1);                                                          \
   } while (0)
 

openmp/runtime/cmake/LibompMicroTests.cmake

 #  - Available for all Unix,Mac,Windows builds.  Not available on Intel(R) MIC Architecture builds.
 # (2) test-relo
 #  - Tests dynamic libraries for position-dependent code (can not have any position dependent code)
 #  - 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 exectuable.
+#  - 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)
 #  - 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

openmp/runtime/cmake/config-ix.cmake

foreach(libomp_btype IN ITEMS DEBUG RELWITHDEBINFO RELEASE MINSIZEREL)
       string(REPLACE "/MD" "/MT"
         CMAKE_${libomp_lang}_FLAGS_${libomp_btype}
         "${CMAKE_${libomp_lang}_FLAGS_${libomp_btype}}"
       )
     endforeach()
   endforeach()
 else()
   # It is difficult to create a dummy assembly file that compiles into an
-  # exectuable for every architecture and then check the C compiler to
+  # executable for every architecture and then check the C compiler to
   # see if -x assembler-with-cpp exists and works, so we assume it does for non-Windows.
   set(LIBOMP_HAVE_X_ASSEMBLER_WITH_CPP_FLAG TRUE)
 endif()
 if(${LIBOMP_FORTRAN_MODULES})
   libomp_check_fortran_flag(-m32 LIBOMP_HAVE_M32_FORTRAN_FLAG)
 endif()
 
 # Check linker flags

openmp/runtime/src/extractExternal.cpp

private:
   const char *buf;
 
 protected:
   _rstream(pair<const char *, streamsize> p)
       : istrstream(p.first, p.second), buf(p.first) {}
   ~_rstream() { delete[] buf; }
 };
 
-// A stream encapuslating the content of a file or the content of a string,
+// A stream encapsulating the content of a file or the content of a string,
 // overriding the >> operator to read various integer types in binary form,
 // as well as a symbol table entry.
 class rstream : public _rstream {
 private:
   template <class T> inline rstream &doRead(T &x) {
     read((char *)&x, sizeof(T));
     return *this;
   }

openmp/runtime/src/i18n/en_US.txt

 AffInfoStr                   "%1$s: %2$s."
 AffInfoStrStr                "%1$s: %2$s - %3$s."
 OSProcToPhysicalThreadMap    "%1$s: OS proc to physical thread map:"
 AffUsingFlatOS               "%1$s: using \"flat\" OS <-> physical proc mapping."
 AffParseFilename             "%1$s: parsing %2$s."
 MsgExiting                   "%1$s - exiting."
 IncompatibleLibrary          "Incompatible %1$s library with version %2$s found."
 IttFunctionError             "ittnotify: Function %1$s failed:"
-IttUnknownError              "ittnofify: Error #%1$d."
+IttUnknownError              "ittnotify: Error #%1$d."
 EnvMiddleWarn                "%1$s must be set prior to first parallel region or certain API calls; ignored."
 CnsLockNotDestroyed          "Lock initialized at %1$s(%2$d) was not destroyed"
                                  # %1, %2, %3, %4 -- file, line, func, col
 CantLoadBalUsing             "Cannot determine machine load balance - Using %1$s"
 AffNotCapableUsePthread      "%1$s: Affinity not capable, using pthread info"
 AffUsePthread                "%1$s: Affinity capable, using pthread info"
 OBSOLETE                     "Loading \"%1$s\" library failed:"
 OBSOLETE                     "Lookup of \"%1$s\" function failed:"

openmp/runtime/src/include/omp_lib.f.var

 !dec$ attributes alias:'kmp_set_warnings_off_'::kmp_set_warnings_off
 !dec$ attributes alias:'kmp_get_cancellation_status_'::kmp_get_cancellation_status
 
 !dec$ endif
 
 !dec$ if defined(__APPLE__)
 
 !***
-!*** The Mac entry points are in lowercase, with an both an underscore
+!*** The Mac entry points are in lowercase, with both an underscore
 !*** appended and an underscore prepended.
 !***
 
 !dec$ attributes alias:'_omp_set_num_threads_'::omp_set_num_threads
 !dec$ attributes alias:'_omp_set_dynamic_'::omp_set_dynamic
 !dec$ attributes alias:'_omp_set_nested_'::omp_set_nested
 !dec$ attributes alias:'_omp_get_num_threads_'::omp_get_num_threads
 !dec$ attributes alias:'_omp_get_max_threads_'::omp_get_max_threads

openmp/runtime/src/kmp.h

enum {
 
   KMP_IDENT_BARRIER_IMPL_SINGLE = 0x0140,
   KMP_IDENT_BARRIER_IMPL_WORKSHARE = 0x01C0,
 
   /*! To mark a static loop in OMPT callbacks */
   KMP_IDENT_WORK_LOOP = 0x200,
   /*! To mark a sections directive in OMPT callbacks */
   KMP_IDENT_WORK_SECTIONS = 0x400,
-  /*! To mark a distirbute construct in OMPT callbacks */
+  /*! To mark a distribute construct in OMPT callbacks */
   KMP_IDENT_WORK_DISTRIBUTE = 0x800,
   /*! Atomic hint; bottom four bits as omp_sync_hint_t. Top four reserved and
       not currently used. If one day we need more bits, then we can use
       an invalid combination of hints to mean that another, larger field
       should be used in a different flag. */
   KMP_IDENT_ATOMIC_HINT_MASK = 0xFF0000,
   KMP_IDENT_ATOMIC_HINT_UNCONTENDED = 0x010000,
   KMP_IDENT_ATOMIC_HINT_CONTENDED = 0x020000,

 #define KMP_GTID_SHUTDOWN (-3) /* Library is shutting down */
 #define KMP_GTID_MONITOR (-4) /* Monitor thread ID */
 #define KMP_GTID_UNKNOWN (-5) /* Is not known */
 #define KMP_GTID_MIN (-6) /* Minimal gtid for low bound check in DEBUG */
 
 /* OpenMP 5.0 Memory Management support */
 
 #ifndef __OMP_H
-// Duplicate type definitios from omp.h
+// Duplicate type definitions from omp.h
 typedef uintptr_t omp_uintptr_t;
 
 typedef enum {
   OMP_ATK_THREADMODEL = 1,
   OMP_ATK_ALIGNMENT = 2,
   OMP_ATK_ACCESS = 3,
   OMP_ATK_POOL_SIZE = 4,
   OMP_ATK_FALLBACK = 5,

 extern omp_allocator_handle_t const omp_high_bw_mem_alloc;
 extern omp_allocator_handle_t const omp_low_lat_mem_alloc;
 extern omp_allocator_handle_t const omp_cgroup_mem_alloc;
 extern omp_allocator_handle_t const omp_pteam_mem_alloc;
 extern omp_allocator_handle_t const omp_thread_mem_alloc;
 extern omp_allocator_handle_t const kmp_max_mem_alloc;
 extern omp_allocator_handle_t __kmp_def_allocator;
 
-// end of duplicate type definitios from omp.h
+// end of duplicate type definitions from omp.h
 #endif
 
 extern int __kmp_memkind_available;
 
 typedef omp_memspace_handle_t kmp_memspace_t; // placeholder
 
 typedef struct kmp_allocator_t {
   omp_memspace_handle_t memspace;

 typedef kmp_int32 kmp_critical_name[8];
 
 /*!
 @ingroup PARALLEL
 The type for a microtask which gets passed to @ref __kmpc_fork_call().
 The arguments to the outlined function are
 @param global_tid the global thread identity of the thread executing the
 function.
-@param bound_tid  the local identitiy of the thread executing the function
+@param bound_tid  the local identity of the thread executing the function
 @param ... pointers to shared variables accessed by the function.
 */
 typedef void (*kmpc_micro)(kmp_int32 *global_tid, kmp_int32 *bound_tid, ...);
 typedef void (*kmpc_micro_bound)(kmp_int32 *bound_tid, kmp_int32 *bound_nth,
                                  ...);
 
 /*!
 @ingroup THREADPRIVATE
#endif /* KMP_ARCH_X86 || KMP_ARCH_X86_64 */
   void *t_inline_argv[KMP_INLINE_ARGV_ENTRIES];
 
   KMP_ALIGN_CACHE kmp_info_t **t_threads;
   kmp_taskdata_t
       *t_implicit_task_taskdata; // Taskdata for the thread's implicit task
   int t_level; // nested parallel level
 
   KMP_ALIGN_CACHE int t_max_argc;
-  int t_max_nproc; // max threads this team can handle (dynamicly expandable)
+  int t_max_nproc; // max threads this team can handle (dynamically expandable)
   int t_serialized; // levels deep of serialized teams
   dispatch_shared_info_t *t_disp_buffer; // buffers for dispatch system
   int t_id; // team's id, assigned by debugger.
   int t_active_level; // nested active parallel level
   kmp_r_sched_t t_sched; // run-time schedule for the team
 #if KMP_AFFINITY_SUPPORTED
   int t_first_place; // first & last place in parent thread's partition.
   int t_last_place; // Restore these values to master after par region.

openmp/runtime/src/kmp_affinity.cpp

if (!KMP_AFFINITY_CAPABLE()) {
     // cpuid instruction from every thread, can correlating the cpuid info, so
     // if the machine is not affinity capable, we assume that HT is off. We have
     // seen quite a few machines where maxThreadsPerPkg is 2, yet the machine
     // does not support HT.
     //
     // - Older OSes are usually found on machines with older chips, which do not
     //   support HT.
     // - The performance penalty for mistakenly identifying a machine as HT when
-    //   it isn't (which results in blocktime being incorrecly set to 0) is
+    //   it isn't (which results in blocktime being incorrectly set to 0) is
     //   greater than the penalty when for mistakenly identifying a machine as
     //   being 1 thread/core when it is really HT enabled (which results in
     //   blocktime being incorrectly set to a positive value).
     __kmp_ncores = __kmp_xproc;
     nPackages = (__kmp_xproc + nCoresPerPkg - 1) / nCoresPerPkg;
     __kmp_nThreadsPerCore = 1;
     if (__kmp_affinity_verbose) {
       KMP_INFORM(AffNotCapableUseLocCpuid, "KMP_AFFINITY");
static void __kmp_aux_affinity_initialize(void) {
   if ((__kmp_cpuinfo_file != NULL) &&
       (__kmp_affinity_top_method == affinity_top_method_all)) {
     __kmp_affinity_top_method = affinity_top_method_cpuinfo;
   }
 
   if (__kmp_affinity_top_method == affinity_top_method_all) {
     // In the default code path, errors are not fatal - we just try using
     // another method. We only emit a warning message if affinity is on, or the
-    // verbose flag is set, an the nowarnings flag was not set.
+    // verbose flag is set, and the nowarnings flag was not set.
     const char *file_name = NULL;
     int line = 0;
 #if KMP_USE_HWLOC
     if (depth < 0 &&
         __kmp_affinity_dispatch->get_api_type() == KMPAffinity::HWLOC) {
       if (__kmp_affinity_verbose) {
         KMP_INFORM(AffUsingHwloc, "KMP_AFFINITY");
       }

openmp/runtime/src/kmp_atomic.cpp

 void __kmpc_atomic_<type>_wr ( ident_t *id_ref, int gtid, TYPE * lhs, TYPE rhs
 );
 @endcode
 
 Full list of functions
 ======================
 This leads to the generation of 376 atomic functions, as follows.
 
-Functons for integers
+Functions for integers
 ---------------------
 There are versions here for integers of size 1,2,4 and 8 bytes both signed and
 unsigned (where that matters).
 @code
     __kmpc_atomic_fixed1_add
     __kmpc_atomic_fixed1_add_cpt
     __kmpc_atomic_fixed1_add_fp
     __kmpc_atomic_fixed1_andb

openmp/runtime/src/kmp_dispatch.cpp

while (1) {
       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
-        // atomically inrement iterations, get old value
+        // 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
           status = 1;
while (1) {
       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
-        // atomically inrement iterations, get old value
+        // 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
           status = 1;
#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
-  // disadavantage of schedule(runtime): even when static scheduling is used it
+  // 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;
 

openmp/runtime/src/kmp_gsupport.cpp

 // 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).
 //
 // Conversely, KMP_DISPATCH_NEXT returns and inclusive upper bound in *p_ub,
-// but the Gnu codegen expects an excluside upper bound, so the adjustment
+// but the Gnu codegen expects an exclusive upper bound, so the adjustment
 // "*p_ub += stride" compensates for the discrepancy.
 //
 // Correction: the gnu codegen always adjusts the upper bound by +-1, not the
 // stride value.  We adjust the dispatch parameters accordingly (by +-1), but
 // we still adjust p_ub by the actual stride value.
 //
 // The "runtime" versions do not take a chunk_sz parameter.
 //
#endif
   loop_bounds[1] = end + (up ? -1 : 1);
   __kmpc_taskloop(&loc, gtid, task, if_val, (kmp_uint64 *)&(loop_bounds[0]),
                   (kmp_uint64 *)&(loop_bounds[1]), (kmp_int64)step, nogroup,
                   sched, (kmp_uint64)num_tasks, (void *)task_dup);
 }
 
 // 4 byte version of GOMP_doacross_post
 // This verison needs to create a temporary array which converts 4 byte
-// integers into 8 byte integeres
+// integers into 8 byte integers
 template <typename T, bool need_conversion = (sizeof(long) == 4)>
 void __kmp_GOMP_doacross_post(T *count);
 
 template <> void __kmp_GOMP_doacross_post<long, true>(long *count) {
   int gtid = __kmp_entry_gtid();
   kmp_info_t *th = __kmp_threads[gtid];
   MKLOC(loc, "GOMP_doacross_post");
   kmp_int64 num_dims = th->th.th_dispatch->th_doacross_info[0];

openmp/runtime/src/kmp_itt.inl

/* Barriers reporting.
    Note: Call __kmp_itt_barrier_object() before call to
    __kmp_itt_barrier_starting() and save result in local variable.
    __kmp_itt_barrier_object(), being called too late (e. g. after gather phase)
    would return itt sync object for the next barrier!
 
    ITT need an address (void *) to be specified as a sync object. OpenMP RTL
    does not have barrier object or barrier data structure. Barrier is just a
    counter in team and thread structures. We could use an address of team
-   structure as an barrier sync object, but ITT wants different objects for
+   structure as a barrier sync object, but ITT wants different objects for
    different barriers (even whithin the same team). So let us use team address
    as barrier sync object for the first barrier, then increase it by one for the
    next barrier, and so on (but wrap it not to use addresses outside of team
    structure). */
 
 void *__kmp_itt_barrier_object(int gtid, int bt, int set_name,
                                int delta // 0 (current barrier) is default
                                // value; specify -1 to get previous
if (team != NULL) {
     kmp_uint64 counter =
         team->t.t_bar[bt].b_arrived / KMP_BARRIER_STATE_BUMP + delta;
     // Now form the barrier id. Encode barrier type (bt) in barrier id too, so
     // barriers of different types do not have the same ids.
     KMP_BUILD_ASSERT(sizeof(kmp_team_t) >= bs_last_barrier);
     // This condition is a must (we would have zero divide otherwise).
     KMP_BUILD_ASSERT(sizeof(kmp_team_t) >= 2 * bs_last_barrier);
     // More strong condition: make sure we have room at least for for two
-    // differtent ids (for each barrier type).
+    // different ids (for each barrier type).
     object = reinterpret_cast<void *>(
         kmp_uintptr_t(team) +
         counter % (sizeof(kmp_team_t) / bs_last_barrier) * bs_last_barrier +
         bt);
     KMP_ITT_DEBUG_LOCK();
     KMP_ITT_DEBUG_PRINT("[bar obj] type=%d, counter=%lld, object=%p\n", bt,
                         counter, object);
 

openmp/runtime/src/kmp_lock.h

struct kmp_base_drdpa_lock {
 
   std::atomic<kmp_uint64> next_ticket;
 
   // now_serving is used to store our ticket value while we hold the lock. It
   // has a slightly different meaning in the DRDPA ticket locks (where it is
   // written by the acquiring thread) than it does in the simple ticket locks
   // (where it is written by the releasing thread).
   //
-  // Since now_serving is only read an written in the critical section,
+  // Since now_serving is only read and written in the critical section,
   // it is non-volatile, but it needs to exist on a separate cache line,
   // as it is invalidated at every lock acquire.
   //
   // Likewise, the vars used for nested locks (owner_id and depth_locked) are
   // only written by the thread owning the lock, so they are put in this cache
   // line.  owner_id is read by other threads, so it must be declared volatile.
   KMP_ALIGN_CACHE
   kmp_uint64 now_serving; // doesn't have to be volatile

openmp/runtime/src/kmp_os.h

 // 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]]
 #elif __has_cpp_attribute(clang::fallthrough)
 #  define KMP_FALLTHROUGH() [[clang::fallthrough]]
-#elif __has_attribute(fallthough) || __GNUC__ >= 7
+#elif __has_attribute(fallthrough) || __GNUC__ >= 7
 #  define KMP_FALLTHROUGH() __attribute__((__fallthrough__))
 #else
 #  define KMP_FALLTHROUGH() ((void)0)
 #endif
 
 // Define attribute that indicates a function does not return
 #if __cplusplus >= 201103L
 #define KMP_NORETURN [[noreturn]]

openmp/runtime/src/kmp_runtime.cpp

if (i == 1) {
     KMP_DEBUG_ASSERT(root->r.r_uber_thread ==
                      root->r.r_uber_thread->th.th_cg_roots->cg_root);
     KMP_DEBUG_ASSERT(root->r.r_uber_thread->th.th_cg_roots->up == NULL);
     __kmp_free(root->r.r_uber_thread->th.th_cg_roots);
     root->r.r_uber_thread->th.th_cg_roots = NULL;
   }
   __kmp_reap_thread(root->r.r_uber_thread, 1);
 
-  // We canot put root thread to __kmp_thread_pool, so we have to reap it istead
-  // of freeing.
+  // We canot put root thread to __kmp_thread_pool, so we have to reap it
+  // instead of freeing.
   root->r.r_uber_thread = NULL;
   /* mark root as no longer in use */
   root->r.r_begin = FALSE;
 
   return n;
 }
 
 void __kmp_unregister_root_current_thread(int gtid) {

openmp/runtime/src/kmp_settings.cpp

for (;;) {
     }
     // Next character is not an integer or not a comma => end of list
     if (((*next < '0') || (*next > '9')) && (*next != ',')) {
       KMP_WARNING(NthSyntaxError, var, env);
       return;
     }
     // The next character is ','
     if (*next == ',') {
-      // ',' is the fisrt character
+      // ',' is the first character
       if (total == 0 || prev_comma) {
         total++;
       }
       prev_comma = TRUE;
       next++; // skip ','
       SKIP_WS(next);
     }
     // Next character is a digit
for (i = 0; i < 3; i++) {
     // Next character is not an integer or not a comma OR number of values > 2
     // => end of list
     if (((*next < '0' || *next > '9') && *next != ',') || total > 2) {
       KMP_WARNING(EnvSyntaxError, name, value);
       return;
     }
     // The next character is ','
     if (*next == ',') {
-      // ',' is the fisrt character
+      // ',' is the first character
       if (total == 0 || prev_comma) {
         total++;
       }
       prev_comma = TRUE;
       next++; // skip ','
       SKIP_WS(next);
     }
     // Next character is a digit
for (i = 0; i < 3; i++) {
     // Next character is not an integer or not a comma OR number of values > 2
     // => end of list
     if (((*next < '0' || *next > '9') && *next != ',') || total > 2) {
       KMP_WARNING(EnvSyntaxError, name, value);
       return;
     }
     // The next character is ','
     if (*next == ',') {
-      // ',' is the fisrt character
+      // ',' is the first character
       if (total == 0 || prev_comma) {
         total++;
       }
       prev_comma = TRUE;
       next++; // skip ','
       SKIP_WS(next);
     }
     // Next character is a digit

openmp/runtime/src/kmp_stats.cpp

fprintf(eventsOut, "%d %llu %llu %1.1f rgb(%1.1f,%1.1f,%1.1f) %s\n", gtid,
             1.2 - (ev.getNestLevel() * 0.2), color.r, color.g, color.b,
             timeStat::name(ev.getTimerName()));
   }
   return;
 }
 
 void kmp_stats_output_module::windupExplicitTimers() {
   // Wind up any explicit timers. We assume that it's fair at this point to just
-  // walk all the explcit timers in all threads and say "it's over".
+  // walk all the explicit timers in all threads and say "it's over".
   // If the timer wasn't running, this won't record anything anyway.
   kmp_stats_list::iterator it;
   for (it = __kmp_stats_list->begin(); it != __kmp_stats_list->end(); it++) {
     kmp_stats_list *ptr = *it;
     ptr->getPartitionedTimers()->windup();
     ptr->endLife();
   }
 }

openmp/runtime/src/kmp_taskdeps.cpp

static bool __kmp_check_deps(kmp_int32 gtid, kmp_depnode_t *node,
                              kmp_depend_info_t *dep_list,
                              kmp_int32 ndeps_noalias,
                              kmp_depend_info_t *noalias_dep_list) {
   int i, n_mtxs = 0;
 #if KMP_DEBUG
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task);
 #endif
   KA_TRACE(20, ("__kmp_check_deps: T#%d checking dependencies for task %p : %d "
-                "possibly aliased dependencies, %d non-aliased depedencies : "
+                "possibly aliased dependencies, %d non-aliased dependencies : "
                 "dep_barrier=%d .\n",
                 gtid, taskdata, ndeps, ndeps_noalias, dep_barrier));
 
   // Filter deps in dep_list
   // TODO: Different algorithm for large dep_list ( > 10 ? )
   for (i = 0; i < ndeps; i++) {
     if (dep_list[i].base_addr != 0) {
       for (int j = i + 1; j < ndeps; j++) {

openmp/runtime/src/kmp_tasking.cpp

if (thread_data->td.td_susp_tied_tasks.ts_entries != TASK_STACK_EMPTY) {
     __kmp_free_task_stack(__kmp_thread_from_gtid(gtid), thread_data);
   }
 #endif // BUILD_TIED_TASK_STACK
 }
 
 // __kmp_realloc_task_threads_data:
 // Allocates a threads_data array for a task team, either by allocating an
 // initial array or enlarging an existing array.  Only the first thread to get
-// the lock allocs or enlarges the array and re-initializes the array eleemnts.
+// the lock allocs or enlarges the array and re-initializes the array elements.
 // That thread returns "TRUE", the rest return "FALSE".
 // Assumes that the new array size is given by task_team -> tt.tt_nproc.
 // The current size is given by task_team -> tt.tt_max_threads.
 static int __kmp_realloc_task_threads_data(kmp_info_t *thread,
                                            kmp_task_team_t *task_team) {
   kmp_thread_data_t **threads_data_p;
   kmp_int32 nthreads, maxthreads;
   int is_init_thread = FALSE;
for (i = 0; i < num_tasks; ++i) {
 
     // adjust task-specific bounds
     next_task_bounds.set_lb(lower);
     if (next_taskdata->td_flags.native) {
       next_task_bounds.set_ub(upper + (st > 0 ? 1 : -1));
     } else {
       next_task_bounds.set_ub(upper);
     }
-    if (ptask_dup != NULL) // set lastprivate flag, construct fistprivates, etc.
+    if (ptask_dup != NULL) // set lastprivate flag, construct firstprivates,
+                           // etc.
       ptask_dup(next_task, task, lastpriv);
     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
#endif
   }
   ub0 = lower + st * (tc0 - 1);
   lb1 = ub0 + st;
 
   // create pattern task for 2nd half of the loop
   next_task = __kmp_task_dup_alloc(thread, task); // duplicate the task
   // adjust lower bound (upper bound is not changed) for the 2nd half
   *(kmp_uint64 *)((char *)next_task + lower_offset) = lb1;
-  if (ptask_dup != NULL) // construct fistprivates, etc.
+  if (ptask_dup != NULL) // construct firstprivates, etc.
     ptask_dup(next_task, task, 0);
   *ub = ub0; // adjust upper bound for the 1st half
 
   // create auxiliary task for 2nd half of the loop
   kmp_task_t *new_task =
       __kmpc_omp_task_alloc(loc, gtid, 1, 3 * sizeof(void *),
                             sizeof(__taskloop_params_t), &__kmp_taskloop_task);
   __taskloop_params_t *p = (__taskloop_params_t *)new_task->shareds;

openmp/runtime/src/kmp_wrapper_malloc.h

/* This header serves for 3 purposes:
    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.
    -----------------------------------------------------------------------
    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 incluiding "kmp_wrapper_malloc.h" can rely on
+   differences, so client code including "kmp_wrapper_malloc.h" can rely on
    following routines:
 
         malloc
         calloc
         realloc
         free
         alloca
 

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

 #define __itt_heap_allocate_end_ptr   0
 #endif /* INTEL_NO_ITTNOTIFY_API */
 #else  /* INTEL_NO_MACRO_BODY */
 #define __itt_heap_allocate_end_ptr   0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Record an free begin occurrence.
+ * @brief Record a free begin occurrence.
  */
 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)
 #define __itt_heap_free_begin_ptr ITTNOTIFY_NAME(heap_free_begin)
 #else  /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_free_begin(h, addr)
 #define __itt_heap_free_begin_ptr   0
 #endif /* INTEL_NO_ITTNOTIFY_API */
 #else  /* INTEL_NO_MACRO_BODY */
 #define __itt_heap_free_begin_ptr   0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Record an free end occurrence.
+ * @brief Record a free end occurrence.
  */
 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)
 #define __itt_heap_free_end_ptr ITTNOTIFY_NAME(heap_free_end)
 #else  /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_free_end(h, addr)
 #define __itt_heap_free_end_ptr   0
 #endif /* INTEL_NO_ITTNOTIFY_API */
 #else  /* INTEL_NO_MACRO_BODY */
 #define __itt_heap_free_end_ptr   0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Record an reallocation begin occurrence.
+ * @brief Record a reallocation begin occurrence.
  */
 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)
 #define __itt_heap_reallocate_begin_ptr ITTNOTIFY_NAME(heap_reallocate_begin)
 #else  /* INTEL_NO_ITTNOTIFY_API */
 #define __itt_heap_reallocate_begin(h, addr, new_size, initialized)
 #define __itt_heap_reallocate_begin_ptr   0
 #endif /* INTEL_NO_ITTNOTIFY_API */
 #else  /* INTEL_NO_MACRO_BODY */
 #define __itt_heap_reallocate_begin_ptr   0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Record an reallocation end occurrence.
+ * @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);
 
 /** @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)

 #endif /* INTEL_NO_ITTNOTIFY_API */
 #else  /* INTEL_NO_MACRO_BODY */
 #define __itt_clock_domain_create_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
  * @ingroup clockdomains
- * @brief Recalculate clock domains frequences and clock base timestamps.
+ * @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_stack_caller_create_ptr 0
 #endif /* INTEL_NO_ITTNOTIFY_API */
 #else  /* INTEL_NO_MACRO_BODY */
 #define __itt_stack_caller_create_ptr 0
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
 /**
- * @brief Destroy the inforamtion 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)

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

#if ITT_PLATFORM==ITT_PLATFORM_WIN
         else if (rc > 0)
         {
             const char* ret = (const char*)env_value;
             env_value += rc + 1;
             return ret;
         }
         else
         {
-            /* If environment variable is empty, GetEnvirornmentVariables()
+            /* 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 (err != ERROR_ENVVAR_NOT_FOUND)
                 __itt_report_error(__itt_error_cant_read_env, name, (int)err);

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

 #define __itt_frame_createA_ptr 0
 #define __itt_frame_createW_ptr 0
 #else /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #define __itt_frame_create_ptr  0
 #endif /* ITT_PLATFORM==ITT_PLATFORM_WIN */
 #endif /* INTEL_NO_MACRO_BODY */
 /** @endcond */
 
-/** @brief Record an frame begin occurrence. */
+/** @brief Record a frame begin occurrence. */
 void ITTAPI __itt_frame_begin(__itt_frame frame);
-/** @brief Record an frame end occurrence. */
+/** @brief Record a frame end occurrence. */
 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)

openmp/runtime/test/ompt/synchronization/lock.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
-  //need to use an OpenMP construct so that OMPT will be initalized
+  //need to use an OpenMP construct so that OMPT will be initialized
   #pragma omp parallel num_threads(1)
     print_ids(0);
 
   omp_lock_t lock;
   printf("%" PRIu64 ": &lock: %" PRIu64 "\n", ompt_get_thread_data()->value, (ompt_wait_id_t)(uintptr_t) &lock);
   omp_init_lock(&lock);
   print_fuzzy_address(1);
   omp_set_lock(&lock);

openmp/runtime/test/ompt/synchronization/nest_lock.c

 // RUN: %libomp-compile-and-run | FileCheck %s
 // REQUIRES: ompt
 #include "callback.h"
 #include <omp.h>
 
 int main()
 {
-  //need to use an OpenMP construct so that OMPT will be initalized
+  //need to use an OpenMP construct so that OMPT will be initialized
   #pragma omp parallel num_threads(1)
     print_ids(0);
 
   omp_nest_lock_t nest_lock;
   printf("%" PRIu64 ": &nest_lock: %lli\n", ompt_get_thread_data()->value, (ompt_wait_id_t)(uintptr_t) &nest_lock);
   omp_init_nest_lock(&nest_lock);
   print_fuzzy_address(1);
   omp_set_nest_lock(&nest_lock);

openmp/runtime/test/threadprivate/omp_threadprivate.c

#pragma omp parallel
     }
   }/* end parallel*/
 
   srand(45);
   for (iter = 0; iter < 100; iter++) {
     my_random = rand(); /* random number generator is
                  called inside serial region*/
 
-    /* the first parallel region is used to initialiye myvalue
+    /* the first parallel region is used to initialize myvalue
        and the array with my_random+rank */
     #pragma omp parallel
     {
       int rank;
       rank = omp_get_thread_num ();
       myvalue = data[rank] = my_random + rank;
     }
 

openmp/runtime/tools/check-depends.pl

 =head1 SYNOPSIS
 
 B<check-depends.pl> I<OPTIONS>... I<library>
 
 =head1 DESCRIPTION
 
 C<check-depends.pl> finds direct dependencies for a specified library. List of actual dependencies
 is sorted alphabetically and printed. If list of expected dependencies is specified, the scripts
-checks the library has only allowed dependencies. In case of not expected depndencies the script
+checks the library has only allowed dependencies. In case of not expected dependencies. the script
 issues error message and exits with non-zero code.
 
-Linux* OS and OS X*: The script finds dependencies only for dymamic libraries. Windows* OS: The script
-finds dependencies for either static or dymamic libraries.
+Linux* OS and OS X*: The script finds dependencies only for dynamic libraries. Windows* OS: The script
+finds dependencies for either static or dynamic libraries.
 
 The script uses external tools. On Linux* OS, it runs F<readelf>, on OS X* -- F<otool> (or F<otool64>),
 on Windows* OS -- F<link>.
 
 On Windows* OS dependencies are printed in lower case, case of expected dependencies ignored.
 
 =head1 OPTIONS
 

openmp/runtime/tools/generate-def.pl

foreach my $line ( @bulk ) {
             }; # if
         } else {
             $error->( "", $n, $line );
         }; # if
     }; # foreach
 
     if ( @dirs ) {
         my $dir = pop( @dirs );
-        $error->( "Unterminated %if direcive.", $dir->{ n }, $dir->{ line } );
+        $error->( "Unterminated %if directive.", $dir->{ n }, $dir->{ line } );
     }; # while
 
     return %entries;
 
 }; # sub parse_input
 
 sub process(\%) {
 

openmp/runtime/tools/lib/Uname.pm

if ( $^O =~ m/cygwin/i ) {
     # Function from Net::Domain module works well, but on Cygwin it prints to
     # stderr "domainname: not found". So we will use environment variables for now.
     $values{ fqdn } = lc( $ENV{ COMPUTERNAME } . "." . $ENV{ USERDNSDOMAIN } );
 } else {
     # On systems other than Cygwin, let us use Net::Domain::hostfqdn(), but do it only node name
     # is really requested.
     $values{ fqdn } =
         sub {
-            my $fqdn = Net::Domain::hostfqdn(); # "fqdn" stands for "fully qualified doamain name".
+            my $fqdn = Net::Domain::hostfqdn(); # "fqdn" stands for "fully qualified domain name".
             # On some systems POSIX::uname() and Net::Domain::hostfqdn() reports different names.
             # Let us issue a warning if they significantly different. Names are insignificantly
             # different if POSIX::uname() matches the beginning of Net::Domain::hostfqdn().
             if (
                 $fqdn eq substr( $fqdn, 0, length( $fqdn ) )
                 &&
                 (
                     length( $fqdn ) == length( $fqdn )

openmp/runtime/tools/lib/tools.pm

 
 =item C<make_dir( $dir, @options )>
 
 Make a directory.
 
 This function makes a directory. If necessary, more than one level can be created.
 If directory exists, warning issues (the script behavior depends on value of
 C<-warning_level> option). If directory creation fails or C<$dir> exists but it is not a
-directory, error isssues.
+directory, error issues.
 
 Options:
 
 =over
 
 =item C<-mode>
 
 The numeric mode for new directories, 0750 (rwxr-x---) by default.
Examples:
     execute( [ "cvs", "-n", "-q", "update", "." ], -stdout => \$output );
         # Execute "cvs -n -q update ." command, output is saved
         # in $output variable.
 
     my @output;
     execute( [ qw( cvs -n -q update . ) ], -stdout => \@output, -stderr => undef );
         # Execute specified command,  output is saved in @output
         # variable, stderr stream is redirected to null device
-        # (/dev/null in Linux* OS an nul in Windows* OS).
+        # (/dev/null in Linux* OS and nul in Windows* OS).
 
 =cut
 
 sub execute($@) {
 
     # !!! Add something to complain on unknown options...
 
     my $command = shift( @_ );

openmp/runtime/tools/message-converter.pl

 
 =item B<--prefix=>I<prefix>
 
 Prefix to be used for all C identifiers (type and variable names) in enum and default messages
 files.
 
 =item B<--os=>I<str>
 
-Specify OS name the message formats to be converted for. If not specified expolicitly, value of
+Specify OS name the message formats to be converted for. If not specified explicitly, value of
 LIBOMP_OS environment variable is used. If LIBOMP_OS is not defined, host OS is detected.
 
 Depending on OS, B<message-converter.pl> converts message formats to GNU style or MS style.
 
 =item Standard Options
 
 =over
 
enum kmp_i18n_id {
 
         // Set #2, strings.
         kmp_i18n_str_first = 131072,
         kmp_i18n_str_Error,
         kmp_i18n_str_UnknownFile,
         kmp_i18n_str_NotANumber,
         ...
 
-        // Set #3, fotrmats.
+        // Set #3, formats.
         ...
 
         kmp_i18n_xxx_lastest
 
     }; // enum kmp_i18n_id
 
     typedef enum kmp_i18n_id  kmp_i18n_id_t;
 

 
 Here is the example of Linux* OS message file:
 
     $quote "
     1 "Japanese"
     2 "Japan"
     3 "1041"
     4 "2"
-    5 "Based on Enlish message catalog revision 20090806"
+    5 "Based on English message catalog revision 20090806"
     ...
 
 Example of Windows* OS message file:
 
     LanguageNames = (Japanese=10041:msg_1041)
 
     FacilityNames = (
      prp=1

openmp/tools/archer/tests/races/task-dependency.c

 /*
- * task-deoendency.c -- Archer testcase
+ * task-dependency.c -- Archer testcase
  */
 
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 //
 // See tools/archer/LICENSE.txt for details.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception