[OpenMP] NFC: Fix trivial typos in comments

[jdoerfert]

LGTM.

[JonChesterfield]

Great! Thank you

[kiszk]

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

openmp/CMakeLists.txt

 # there is no point in trying to compile libomptarget on other OSes.
 if (APPLE OR WIN32 OR NOT OPENMP_HAVE_STD_CPP11_FLAG)
   set(ENABLE_LIBOMPTARGET OFF)
 endif()
 
 option(OPENMP_ENABLE_LIBOMPTARGET "Enable building libomptarget for offloading."
        ${ENABLE_LIBOMPTARGET})
 if (OPENMP_ENABLE_LIBOMPTARGET)
-  # Check that the library can acutally be built.
+  # Check that the library can actually be built.
   if (APPLE OR WIN32)
     message(FATAL_ERROR "libomptarget cannot be built on Windows and MacOS X!")
   elseif (NOT OPENMP_HAVE_STD_CPP11_FLAG)
     message(FATAL_ERROR "Host compiler must support C++11 to build libomptarget!")
   endif()
 
   add_subdirectory(libomptarget)
 endif()

openmp/runtime/CMakeLists.txt

else() # Part of LLVM build
   endif ()
   set(LIBOMP_ENABLE_ASSERTIONS ${LLVM_ENABLE_ASSERTIONS})
 endif()
 libomp_check_variable(LIBOMP_ARCH 32e x86_64 32 i386 arm ppc64 ppc64le aarch64 mic mips mips64 riscv64)
 
 set(LIBOMP_LIB_TYPE normal CACHE STRING
   "Performance,Profiling,Stubs library (normal/profile/stubs)")
 libomp_check_variable(LIBOMP_LIB_TYPE normal profile stubs)
-# Set the OpenMP Year and Month assiociated with version
+# Set the OpenMP Year and Month associated with version
 set(LIBOMP_OMP_YEAR_MONTH 201611)
 set(LIBOMP_MIC_ARCH knc CACHE STRING
   "Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture) (knf/knc).  Ignored if not Intel(R) MIC Architecture build.")
 if("${LIBOMP_ARCH}" STREQUAL "mic")
   libomp_check_variable(LIBOMP_MIC_ARCH knf knc)
 endif()
 set(LIBOMP_FORTRAN_MODULES FALSE CACHE BOOL
   "Create Fortran module files? (requires fortran compiler)")

openmp/runtime/src/i18n/en_US.txt

 DecreaseToThreads            "%1$s: decrease to %2$d threads"
 IncreaseToThreads            "%1$s: increase to %2$d threads"
 OBSOLETE                     "%1$s: Internal thread %2$d bound to OS proc set %3$s"
 AffCapableUseCpuinfo         "%1$s: Affinity capable, using cpuinfo file"
 AffUseGlobCpuid              "%1$s: Affinity capable, using global cpuid info"
 AffCapableUseFlat            "%1$s: Affinity capable, using default \"flat\" topology"
 AffNotCapableUseLocCpuid     "%1$s: Affinity not capable, using local cpuid info"
 AffNotCapableUseCpuinfo      "%1$s: Affinity not capable, using cpuinfo file"
-AffFlatTopology              "%1$s: Affinity not capable, assumming \"flat\" topology"
+AffFlatTopology              "%1$s: Affinity not capable, assuming \"flat\" topology"
 InitOSProcSetRespect         "%1$s: Initial OS proc set respected: %2$s"
 InitOSProcSetNotRespect      "%1$s: Initial OS proc set not respected: %2$s"
 AvailableOSProc              "%1$s: %2$d available OS procs"
 Uniform                      "%1$s: Uniform topology"
 NonUniform                   "%1$s: Nonuniform topology"
 Topology                     "%1$s: %2$d packages x %3$d cores/pkg x %4$d threads/core (%5$d total cores)"
 OBSOLETE                     "%1$s: OS proc to physical thread map ([] => level not in map):"
 OSProcToPackage              "%1$s: OS proc <n> maps to <n>th package core 0"

openmp/runtime/src/kmp.h

typedef struct kmp_tasking_flags { /* Total struct must be exactly 32 bits */
   // (1) or may be deferred (0)
   unsigned team_serial : 1; // entire team is serial (1) [1 thread] or parallel
   // (0) [>= 2 threads]
   /* If either team_serial or tasking_ser is set, task team may be NULL */
   /* Task State Flags: */
   unsigned started : 1; /* 1==started, 0==not started     */
   unsigned executing : 1; /* 1==executing, 0==not executing */
   unsigned complete : 1; /* 1==complete, 0==not complete   */
-  unsigned freed : 1; /* 1==freed, 0==allocateed        */
+  unsigned freed : 1; /* 1==freed, 0==allocated        */
   unsigned native : 1; /* 1==gcc-compiled task, 0==intel */
   unsigned reserved31 : 7; /* reserved for library use */
 
 } kmp_tasking_flags_t;
 
 struct kmp_taskdata { /* aligned during dynamic allocation       */
   kmp_int32 td_task_id; /* id, assigned by debugger                */
   kmp_tasking_flags_t td_flags; /* task flags                              */

openmp/runtime/src/kmp_affinity.cpp

if (num_records == 0) {
     return -1;
   }
   if (num_records > (unsigned)__kmp_xproc) {
     *line = 0;
     *msg_id = kmp_i18n_str_TooManyProcRecords;
     return -1;
   }
 
-  // Set the file pointer back to the begginning, so that we can scan the file
+  // Set the file pointer back to the beginning, so that we can scan the file
   // again, this time performing a full parse of the data. Allocate a vector of
   // ProcCpuInfo object, where we will place the data. Adding an extra element
   // at the end allows us to remove a lot of extra checks for termination
   // conditions.
   if (fseek(f, 0, SEEK_SET) != 0) {
     *line = 0;
     *msg_id = kmp_i18n_str_CantRewindCpuinfo;
     return -1;
#endif // KMP_MIC && REDUCE_TEAM_SIZE
           // Restart the thread counter, as we are on a new core.
           threadIdCt = 0;
 
           // Auto-assign the thread id field if it wasn't specified.
           if (threadInfo[i][threadIdIndex] == UINT_MAX) {
             threadInfo[i][threadIdIndex] = threadIdCt++;
           }
 
-          // Aparrently the thread id field was specified for some entries and
+          // Apparently the thread id field was specified for some entries and
           // not others. Start the thread id counter off at the next higher
           // thread id.
           else if (threadIdCt <= threadInfo[i][threadIdIndex]) {
             threadIdCt = threadInfo[i][threadIdIndex] + 1;
           }
         }
         break;
       }

openmp/runtime/src/kmp_alloc.cpp

static void bectl(kmp_info_t *th, bget_compact_t compact,
                   bget_acquire_t acquire, bget_release_t release,
                   bufsize pool_incr);
 
 /* BGET CONFIGURATION */
 /* Buffer allocation size quantum: all buffers allocated are a
    multiple of this size.  This MUST be a power of two. */
 
 /* On IA-32 architecture with  Linux* OS, malloc() does not
-   ensure 16 byte alignmnent */
+   ensure 16 byte alignment */
 
 #if KMP_ARCH_X86 || !KMP_HAVE_QUAD
 
 #define SizeQuant 8
 #define AlignType double
 
 #else
 

openmp/runtime/src/kmp_atomic.cpp

@code
     __kmpc_atomic_float16_swp
     __kmpc_atomic_float16_wr
 @endcode
 
 Functions for Complex types
 ---------------------------
 Functions for complex types whose component floating point variables are of size
 4,8,10 or 16 bytes. The names here are based on the size of the component float,
-*not* the size of the complex type. So `__kmpc_atomc_cmplx8_add` is an operation
-on a `complex<double>` or `complex(kind=8)`, *not* `complex<float>`.
+*not* the size of the complex type. So `__kmpc_atomic_cmplx8_add` is an
+operation on a `complex<double>` or `complex(kind=8)`, *not* `complex<float>`.
 
 @code
     __kmpc_atomic_cmplx4_add
     __kmpc_atomic_cmplx4_add_cmplx8
     __kmpc_atomic_cmplx4_add_cpt
     __kmpc_atomic_cmplx4_div
     __kmpc_atomic_cmplx4_div_cmplx8
     __kmpc_atomic_cmplx4_div_cpt

openmp/runtime/src/kmp_dispatch_hier.h

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);
     // Only master threads of this unit within the hierarchy do initialization
     KD_TRACE(10, ("__kmp_dispatch_init_hierarchy: T#%d (%d) prev_id is 0\n",
                   gtid, i));
     my_unit->reset_shared_barrier();
     my_unit->hier_pr.flags.contains_last = FALSE;
     // Last layer, initialize the private buffers with entire loop information
-    // Now the next next_algorithim() call will get the first chunk of
+    // Now the next next_algorithm() call will get the first chunk of
     // iterations properly
     if (i == n - 1) {
       __kmp_dispatch_init_algorithm<T>(
           loc, gtid, my_unit->get_my_pr(), hier->get_sched(i), lb, ub, st,
 #if USE_ITT_BUILD
           NULL,
 #endif
           hier->get_chunk(i), hier->get_num_active(i), my_unit->get_hier_id());

openmp/runtime/src/kmp_ftn_entry.h

if ((*(void **)(&fptr) = dlsym(RTLD_DEFAULT, "_Offload_number_of_devices"))) {
     return (*fptr)();
   } else { // liboffload & libomptarget don't exist
     return 0;
   }
 #endif // KMP_MIC || KMP_OS_DARWIN || KMP_OS_WINDOWS || defined(KMP_STUB)
 }
 
 // This function always returns true when called on host device.
-// Compilier/libomptarget should handle when it is called inside target region.
+// Compiler/libomptarget should handle when it is called inside target region.
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) KMP_WEAK_ATTRIBUTE;
 int FTN_STDCALL KMP_EXPAND_NAME(FTN_IS_INITIAL_DEVICE)(void) {
   return 1; // This is the host
 }
 
 // libomptarget, if loaded, provides this function
 int FTN_STDCALL FTN_GET_INITIAL_DEVICE(void) KMP_WEAK_ATTRIBUTE;
 int FTN_STDCALL FTN_GET_INITIAL_DEVICE(void) {

openmp/runtime/src/kmp_gsupport.cpp

 
 // 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
-// "*p_ub += stride" compenstates for the discrepancy.
+// "*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.
 //
 // The profile lib cannot support construct checking of unordered loops that

openmp/runtime/src/kmp_itt.inl

 #if USE_ITT_BUILD
 /*
  * kmp_itt.inl -- Inline functions of ITT Notify.
  */
 
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Inline function definitions. This file should be included into kmp_itt.h file
-// for production build (to let compliler inline functions) or into kmp_itt.c
+// for production build (to let compiler inline functions) or into kmp_itt.c
 // file for debug build (to reduce the number of files to recompile and save
 // build time).
 
 #include "kmp.h"
 #include "kmp_str.h"
 
 #if KMP_ITT_DEBUG
 extern kmp_bootstrap_lock_t __kmp_itt_debug_lock;
#if USE_ITT_NOTIFY
   if (team != NULL) {
     // Master thread increases b_arrived by KMP_BARRIER_STATE_BUMP each time.
     // Divide b_arrived by KMP_BARRIER_STATE_BUMP to get plain barrier counter.
     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 conditon is a must (we would have zero divide otherwise).
+    // 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).
     object = reinterpret_cast<void *>(
         kmp_uintptr_t(team) +
         counter % (sizeof(kmp_team_t) / bs_last_barrier) * bs_last_barrier +
         bt);
     KMP_ITT_DEBUG_LOCK();

openmp/runtime/src/kmp_runtime.cpp

#if OMPT_SUPPORT
   this_thr->th.ompt_thread_info.parallel_flags |= ompt_parallel_league;
 #endif
   __kmp_run_after_invoked_task(gtid, 0, this_thr, team);
   return 1;
 }
 
 /* this sets the requested number of threads for the next parallel region
    encountered by this team. since this should be enclosed in the forkjoin
-   critical section it should avoid race conditions with assymmetrical nested
+   critical section it should avoid race conditions with asymmetrical nested
    parallelism */
 
 void __kmp_push_num_threads(ident_t *id, int gtid, int num_threads) {
   kmp_info_t *thr = __kmp_threads[gtid];
 
   if (num_threads > 0)
     thr->th.th_set_nproc = num_threads;
 }

openmp/runtime/src/kmp_str.cpp

void __kmp_str_fname_init(kmp_str_fname_t *fname, char const *path) {
   fname->dir = NULL;
   fname->base = NULL;
 
   if (path != NULL) {
     char *slash = NULL; // Pointer to the last character of dir.
     char *base = NULL; // Pointer to the beginning of basename.
     fname->path = __kmp_str_format("%s", path);
     // Original code used strdup() function to copy a string, but on Windows* OS
-    // Intel(R) 64 it causes assertioon id debug heap, so I had to replace
+    // Intel(R) 64 it causes assertion id debug heap, so I had to replace
     // strdup with __kmp_str_format().
     if (KMP_OS_WINDOWS) {
       __kmp_str_replace(fname->path, '\\', '/');
     }
     fname->dir = __kmp_str_format("%s", fname->path);
     slash = strrchr(fname->dir, '/');
     if (KMP_OS_WINDOWS &&
         slash == NULL) { // On Windows* OS, if slash not found,

openmp/runtime/src/kmp_tasking.cpp

KMP_DEBUG_ASSERT(
       taskdata->td_flags.task_serial);
   if (taskdata->td_flags.task_serial) {
     if (resumed_task == NULL) {
       resumed_task = taskdata->td_parent; // In a serialized task, the resumed
       // task is the parent
     }
   } else {
     KMP_DEBUG_ASSERT(resumed_task !=
-                     NULL); // verify that resumed task is passed as arguemnt
+                     NULL); // verify that resumed task is passed as argument
   }
 
   // Free this task and then ancestor tasks if they have no children.
   // Restore th_current_task first as suggested by John:
   // johnmc: if an asynchronous inquiry peers into the runtime system
   // it doesn't see the freed task as the current task.
   thread->th.th_current_task = resumed_task;
   if (!detach)

  * Utility routines for "task teams".  A task team (kmp_task_t) is kind of
  * like a shadow of the kmp_team_t data struct, with a different lifetime.
  * After a child * thread checks into a barrier and calls __kmp_release() from
  * the particular variant of __kmp_<barrier_kind>_barrier_gather(), it can no
  * longer assume that the kmp_team_t structure is intact (at any moment, the
  * master thread may exit the barrier code and free the team data structure,
  * and return the threads to the thread pool).
  *
- * This does not work with the the tasking code, as the thread is still
+ * 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
  * __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
static void __kmp_bottom_half_finish_proxy(kmp_int32 gtid, kmp_task_t *ptask) {
   __kmp_free_task_and_ancestors(gtid, taskdata, thread);
 }
 
 /*!
 @ingroup TASKING
 @param gtid Global Thread ID of encountering thread
 @param ptask Task which execution is completed
 
-Execute the completation of a proxy task from a thread of that is part of the
+Execute the completion of a proxy task from a thread of that is part of the
 team. Run first and bottom halves directly.
 */
 void __kmpc_proxy_task_completed(kmp_int32 gtid, kmp_task_t *ptask) {
   KMP_DEBUG_ASSERT(ptask != NULL);
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(ptask);
   KA_TRACE(
       10, ("__kmp_proxy_task_completed(enter): T#%d proxy task %p completing\n",
            gtid, taskdata));
 
   KMP_DEBUG_ASSERT(taskdata->td_flags.proxy == TASK_PROXY);
 
   __kmp_first_top_half_finish_proxy(taskdata);
   __kmp_second_top_half_finish_proxy(taskdata);
   __kmp_bottom_half_finish_proxy(gtid, ptask);
 
   KA_TRACE(10,
            ("__kmp_proxy_task_completed(exit): T#%d proxy task %p completing\n",
             gtid, taskdata));
 }
 
 /*!
 @ingroup TASKING
 @param ptask Task which execution is completed
 
-Execute the completation of a proxy task from a thread that could not belong to
+Execute the completion of a proxy task from a thread that could not belong to
 the team.
 */
 void __kmpc_proxy_task_completed_ooo(kmp_task_t *ptask) {
   KMP_DEBUG_ASSERT(ptask != NULL);
   kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(ptask);
 
   KA_TRACE(
       10,

 void __kmp_taskloop_recur(ident_t *, int, kmp_task_t *, kmp_uint64 *,
                           kmp_uint64 *, kmp_int64, kmp_uint64, kmp_uint64,
                           kmp_uint64, kmp_uint64, kmp_uint64, kmp_uint64,
 #if OMPT_SUPPORT
                           void *,
 #endif
                           void *);
 
-// Execute part of the the taskloop submitted as a task.
+// Execute part of the taskloop submitted as a task.
 int __kmp_taskloop_task(int gtid, void *ptask) {
   __taskloop_params_t *p =
       (__taskloop_params_t *)((kmp_task_t *)ptask)->shareds;
   kmp_task_t *task = p->task;
   kmp_uint64 *lb = p->lb;
   kmp_uint64 *ub = p->ub;
   void *task_dup = p->task_dup;
   //  p_task_dup_t ptask_dup = (p_task_dup_t)task_dup;
#if OMPT_SUPPORT
                           codeptr_ra,
 #endif
                           task_dup);
 
   KA_TRACE(40, ("__kmp_taskloop_task(exit): T#%d\n", gtid));
   return 0;
 }
 
-// Schedule part of the the taskloop as a task,
-// execute the rest of the the taskloop.
+// Schedule part of the taskloop as a task,
+// execute the rest of the taskloop.
 //
 // loc        Source location information
 // gtid       Global thread ID
 // task       Pattern task, exposes the loop iteration range
 // 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)

openmp/runtime/src/z_Linux_util.cpp

 
 // The fuction 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 algortihm
+  // the thread balance algorithm
   static double glb_call_time = 0; /* Thread balance algorithm call time */
 
   int running_threads = 0; // Number of running threads in the system.
 
   DIR *proc_dir = NULL; // Handle of "/proc/" directory.
   struct dirent *proc_entry = NULL;
 
   kmp_str_buf_t task_path; // "/proc/<pid>/task/<tid>/" path.
if (proc_entry->d_type == DT_DIR && isdigit(proc_entry->d_name[0])) {
         stat_path_fixed_len = stat_path.used;
 
         task_entry = readdir(task_dir);
         while (task_entry != NULL) {
           // It is a directory and name starts with a digit.
           if (proc_entry->d_type == DT_DIR && isdigit(task_entry->d_name[0])) {
             ++total_threads;
 
-            // Consruct complete stat file path. Easiest way would be:
+            // Construct complete stat file path. Easiest way would be:
             //  __kmp_str_buf_print( & stat_path, "%s/%s/stat", task_path.str,
             //  task_entry->d_name );
             // but seriae of __kmp_str_buf_cat works a bit faster.
             stat_path.used =
                 stat_path_fixed_len; // Reset stat path to its fixed part.
             __kmp_str_buf_cat(&stat_path, task_entry->d_name,
                               KMP_STRLEN(task_entry->d_name));
             __kmp_str_buf_cat(&stat_path, "/stat", 5);

openmp/runtime/src/z_Windows_NT_util.cpp

if (!rc) {
     DWORD error = GetLastError();
     __kmp_fatal(KMP_MSG(CantCloseHandle), KMP_ERR(error), __kmp_msg_null);
   }
 }
 
 int __kmp_get_load_balance(int max) {
   static ULONG glb_buff_size = 100 * 1024;
 
-  // Saved count of the running threads for the thread balance algortihm
+  // Saved count of the running threads for the thread balance algorithm
   static int glb_running_threads = 0;
   static double glb_call_time = 0; /* Thread balance algorithm call time */
 
   int running_threads = 0; // Number of running threads in the system.
   NTSTATUS status = 0;
   ULONG buff_size = 0;
   ULONG info_size = 0;
   void *buffer = NULL;

openmp/runtime/test/ompt/callback.h

 
 // This macro prints the exact address that a previously called runtime function
 // returns to.
 #define print_current_address(id) \
   define_ompt_label(id) \
   print_possible_return_addresses(get_ompt_label_address(id))
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
-// On X86 the NOP instruction is 1 byte long. In addition, the comiler inserts
+// On X86 the NOP instruction is 1 byte long. In addition, the compiler inserts
 // a MOV instruction for non-void runtime functions which is 3 bytes long.
 #define print_possible_return_addresses(addr) \
   printf("%" PRIu64 ": current_address=%p or %p for non-void functions\n", \
          ompt_get_thread_data()->value, ((char *)addr) - 1, ((char *)addr) - 4)
 #elif KMP_ARCH_PPC64
 // On Power the NOP instruction is 4 bytes long. In addition, the compiler
 // inserts a second NOP instruction (another 4 bytes). For non-void runtime
 // functions Clang inserts a STW instruction (but only if compiling under

openmp/runtime/test/tasking/omp_taskloop_grainsize.c

 // RUN: %libomp-compile-and-run
 // RUN: %libomp-compile && env KMP_TASKLOOP_MIN_TASKS=1 %libomp-run
 
 // These compilers don't support the taskloop construct
 // UNSUPPORTED: gcc-4, gcc-5, icc-16
 // GCC 6 has support for taskloops, but at least 6.3.0 is crashing on this test
 // UNSUPPORTED: gcc-6
 
 /*
  * Test for taskloop
- * Method: caculate how many times the iteration space is dispatched
+ * Method: calculate how many times the iteration space is dispatched
  *     and judge if each dispatch has the requested grainsize
  * It is possible for two adjacent chunks are executed by the same thread
  */
 #include <stdio.h>
 #include <omp.h>
 #include <stdlib.h>
 #include "omp_testsuite.h"
 

openmp/runtime/test/tasking/omp_taskloop_num_tasks.c

 // This test is known to be fragile on NetBSD kernel at the moment.
 // UNSUPPORTED: netbsd
 // RUN: %libomp-compile-and-run
 // RUN: %libomp-compile && env KMP_TASKLOOP_MIN_TASKS=1 %libomp-run
 
 // These compilers don't support the taskloop construct
 // UNSUPPORTED: gcc-4, gcc-5, icc-16
 
 // This test is known to be fragile on NetBSD kernel at the moment,
 // https://bugs.llvm.org/show_bug.cgi?id=42020.
 // UNSUPPORTED: netbsd
 
 /*
  * Test for taskloop
- * Method: caculate how many times the iteration space is dispatched
+ * Method: calculate how many times the iteration space is dispatched
  *     and judge if each dispatch has the requested grainsize
  * It is possible for two adjacent chunks are executed by the same thread
  */
 #include <stdio.h>
 #include <omp.h>
 #include <stdlib.h>
 #include "omp_testsuite.h"
 

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

 // RUN: %libomp-compile -DMY_SCHEDULE=static && %libomp-run
 // RUN: %libomp-compile -DMY_SCHEDULE=dynamic && %libomp-run
 // RUN: %libomp-compile -DMY_SCHEDULE=guided && %libomp-run
 
 // Only works with Intel Compiler since at least version 15.0
 // XFAIL: gcc, clang
 
 /*
  * Test that large bounds are handled properly and calculations of
- * loop iterations don't accidently overflow
+ * loop iterations don't accidentally overflow
  */
 #include <stdio.h>
 #include <omp.h>
 #include <stdlib.h>
 #include <limits.h>
 #include "omp_testsuite.h"
 
 #define INCR 50000000

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

 // RUN: %libomp-compile-and-run
 /*
  * Test for dynamic scheduling with chunk size
- * Method: caculate how many times the iteration space is dispatched
+ * Method: calculate how many times the iteration space is dispatched
  *     and judge if each dispatch has the requested chunk size
  *     unless it is the last one.
  * It is possible for two adjacent chunks are assigned to the same thread
  * Modified by Chunhua Liao
  */
 #include <stdio.h>
 #include <omp.h>
 #include <stdlib.h>

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

#endif
       result = 0;
     }
 #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 assignement of chunks to threads. We use the nowait
+   * 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 */
   free (tids);
   tids = (int *) malloc (sizeof (int) * LOOPCOUNT);
   tids2 = (int *) malloc (sizeof (int) * LOOPCOUNT);
 
   #pragma omp parallel

openmp/runtime/tools/lib/Platform.pm

 
 =head2 Functions.
 
 =over
 
 =item B<canon_arch( $arch )>
 
 Input string is an architecture name to canonize. The function recognizes many variants, for example:
-C<32e>, C<Intel64>, C<Intel(R) 64>, etc. Returned string is a canononized architecture name,
+C<32e>, C<Intel64>, C<Intel(R) 64>, etc. Returned string is a canonized architecture name,
 one of: C<32>, C<32e>, C<64>, C<arm>, C<ppc64le>, C<ppc64>, C<mic>, C<mips>, C<mips64>, C<riscv64> or C<undef> is input string is not recognized.
 
 =item B<legal_arch( $arch )>
 
 Input string is architecture name. The function recognizes the same variants as C<arch_canon()> does.
 Returned string is a name approved by Intel Legal, one of: C<IA-32 architecture>, C<Intel(R) 64>
 or C<undef> if input string is not recognized.
 

openmp/runtime/tools/lib/Uname.pm

my $get_os_info =
                debug( "Executing $sw_vers..." );
                execute( [ $sw_vers ], -stdout => \$output, -stderr => undef );
                $output =~ m{^ProductName:\s*(.*)\s*$}m
                    or runtime_error( "There is no ProductName in sw_vers output:", $output, "(eof)" );
                my $name = $1;
                $output =~ m{^ProductVersion:\s*(.*)\s*$}m
                    or runtime_error( "There is no ProductVersion in sw_vers output:", $output, "(eof)" );
                my $release = $1;
-               # Sometimes release reported as "10.4.11" (3 componentes), sometimes as "10.6".
+               # Sometimes release reported as "10.4.11" (3 components), sometimes as "10.6".
                # Handle both variants.
                $release =~ m{^(\d+.\d+)(?:\.\d+)?(?=\s|$)}
                    or runtime_error( "Cannot parse OS X* version: $release" );
                my $version = $1;
                my $codename = ( $codenames{ $version } or "unknown" );
                $darwin->{ operating_system_name        } = $name;
                $darwin->{ operating_system_release     } = $release;
                $darwin->{ operating_system_codename    } = $codename;

openmp/runtime/tools/lib/tools.pm

sub get_options {
     Getopt::Long::GetOptions(
         "h0|usage"        => sub { Pod::Usage::pod2usage( -exitval => 0, -verbose => 0 ); },
         "h1|h|help"       => sub { Pod::Usage::pod2usage( -exitval => 0, -verbose => 1 ); },
         "h2|doc|manual"   => sub { Pod::Usage::pod2usage( -exitval => 0, -verbose => 2 ); },
         "version"         => sub { print( "$tool version $main::VERSION\n" ); exit( 0 ); },
         "v|verbose"       => sub { ++ $verbose;     $ENV{ "tools.pm_verbose"    } = $verbose;    },
         "quiet"           => sub { -- $verbose;     $ENV{ "tools.pm_verbose"    } = $verbose;    },
         "with-timestamps" => sub { $timestamps = 1; $ENV{ "tools.pm_timestamps" } = $timestamps; },
-        @_, # Caller argumetsa are at the end so caller options overrides standard.
+        @_, # Caller arguments are at the end so caller options overrides standard.
     ) or cmdline_error();
 
 }; # sub get_options
 
 
 # =================================================================================================
 # Print utilities.
 # =================================================================================================

 Look for all occurenses 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 the C<omp_lib.f> file:
+Look for the C<omp_lib.f> file:
 
     my @omp_lib = which( "omp_lib.f", -all => 1, -exec => 0, -dirs => [ @include ] );
 
 =cut
 
 sub which($@) {
 
     my $file = shift( @_ );