[openmp] Fixed a number of typos

[GabrielRavier]

Summary

I went over the output of the following mess of a command:

(ulimit -m 2000000; ulimit -v 2000000; git ls-files -z | parallel --xargs -0 cat | aspell list --mode=none --ignore-case | grep -E '^[A-Za-z][a-z]*$' | sort | uniq -c | sort -n | grep -vE '.{25}' | aspell pipe -W3 | grep : | cut -d' ' -f2 | less)

and proceeded to spend a few days looking at it to find probable typos
and fixed a few hundred of them in all of the llvm project (note, the
ones I found are not anywhere near all of them, but it seems like a
good start).

[jdoerfert]

LG, thx

openmp/libomptarget/DeviceRTL/include/Configuration.h

 
 /// Return the number of devices in the system, same number as returned on the
 /// host by omp_get_num_devices.
 uint32_t getNumDevices();
 
 /// Return the device number in the system for omp_get_device_num.
 uint32_t getDeviceNum();
 
-/// Return the user choosen debug level.
+/// Return the user chosen debug level.
 uint32_t getDebugKind();
 
 /// Return the amount of dynamic shared memory that was allocated at launch.
 uint64_t getDynamicMemorySize();
 
 /// Return if debugging is enabled for the given debug kind.
 bool isDebugMode(DebugKind Level);
 
 /// Indicates if this kernel may require thread-specific states, or if it was
 /// explicitly disabled by the user.
 bool mayUseThreadStates();
 
 } // namespace config
 } // namespace _OMP
 
 #endif

openmp/libomptarget/DeviceRTL/src/Workshare.cpp

static void ForStaticChunk(int &last, T &lb, T &ub, ST &stride, ST chunk,
                              T entityId, T numberOfEntities) {
     // each thread executes multiple chunks all of the same size, except
     // the last one
     // distance between two successive chunks
     stride = numberOfEntities * chunk;
     lb = lb + entityId * chunk;
     T inputUb = ub;
     ub = lb + chunk - 1; // Clang uses i <= ub
-    // Say ub' is the begining of the last chunk. Then who ever has a
+    // Say ub' is the beginning of the last chunk. Then who ever has a
     // lower bound plus a multiple of the increment equal to ub' is
     // the last one.
-    T beginingLastChunk = inputUb - (inputUb % chunk);
-    last = ((beginingLastChunk - lb) % stride) == 0;
+    T beginningLastChunk = inputUb - (inputUb % chunk);
+    last = ((beginningLastChunk - lb) % stride) == 0;
   }
 
   ////////////////////////////////////////////////////////////////////////////////
   // Loop with static scheduling without chunk
 
   // helper function for static no chunk
   static void ForStaticNoChunk(int &last, T &lb, T &ub, ST &stride, ST &chunk,
                                T entityId, T numberOfEntities) {

openmp/libomptarget/include/omptargetplugin.h

 int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *Image);
 
 // This provides the same functionality as __tgt_rtl_is_valid_binary except we
 // also use additional information to determine if the image is valid. This
 // allows us to determine if an image has a compatible architecture.
 int32_t __tgt_rtl_is_valid_binary_info(__tgt_device_image *Image,
                                        __tgt_image_info *Info);
 
-// Return an integer other than zero if the data can be exchaned from SrcDevId
+// Return an integer other than zero if the data can be exchanged from SrcDevId
 // to DstDevId. If it is data exchangable, the device plugin should provide
 // function to move data from source device to destination device directly.
 int32_t __tgt_rtl_is_data_exchangable(int32_t SrcDevId, int32_t DstDevId);
 
 // Return an integer other than zero if the plugin can handle images which do
 // not contain target regions and global variables (but can contain other
 // functions)
 int32_t __tgt_rtl_supports_empty_images();

openmp/libomptarget/plugins/amdgpu/impl/system.cpp

if (module_load_success) {
 
     err = hsa::executable_iterate_symbols(
         executable,
         [&](hsa_executable_t, hsa_executable_symbol_t symbol) -> hsa_status_t {
           return populate_InfoTables(symbol, KernelInfoTable, SymbolInfoTable);
         });
     if (err != HSA_STATUS_SUCCESS) {
       printf("[%s:%d] %s failed: %s\n", __FILE__, __LINE__,
-             "Iterating over symbols for execuatable", get_error_string(err));
+             "Iterating over symbols for executable", get_error_string(err));
       return HSA_STATUS_ERROR;
     }
 
     // save the executable and destroy during finalize
     HSAExecutables.push_back(executable);
     return HSA_STATUS_SUCCESS;
   } else {
     return HSA_STATUS_ERROR;
   }
 }
 
 } // namespace core

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

auto CbMem = [](hsa_amd_memory_pool_t Region, void *Data) -> hsa_status_t {
           "Error returned from hsa_amd_memory_pool_get_info when obtaining "
           "HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_ALIGNMENT\n");
       printf("        Runtime Alloc alignment: \t %zu bytes\n", Size);
       core::checkResult(
           hsa_amd_memory_pool_get_info(
               Region, HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL, &Access),
           "Error returned from hsa_amd_memory_pool_get_info when obtaining "
           "HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL\n");
-      printf("        Accessable by all: \t\t %s\n",
+      printf("        Accessible by all: \t\t %s\n",
              (Access ? "TRUE" : "FALSE"));
 
       return HSA_STATUS_SUCCESS;
     };
     // Iterate over all the memory regions for this agent. Get the memory region
     // type and size
     hsa_amd_agent_iterate_memory_pools(Agent, CbMem, nullptr);
 

openmp/libomptarget/src/rtl.cpp

 void RTLsTy::initAllRTLs() {
   for (auto &R : AllRTLs)
     initRTLonce(R);
 }
 
 void RTLsTy::registerLib(__tgt_bin_desc *Desc) {
   PM->RTLsMtx.lock();
 
-  // Extract the exectuable image and extra information if availible.
+  // Extract the executable image and extra information if availible.
   for (int32_t i = 0; i < Desc->NumDeviceImages; ++i)
     PM->Images.emplace_back(getExecutableImage(&Desc->DeviceImages[i]),
                             getImageInfo(&Desc->DeviceImages[i]));
 
   // Register the images with the RTLs that understand them, if any.
   for (auto &ImageAndInfo : PM->Images) {
     // Obtain the image and information that was previously extracted.
     __tgt_device_image *Img = &ImageAndInfo.first;

openmp/runtime/src/i18n/en_US.txt

 # Default messages, embedded into the OpenMP RTL, and source for English catalog.
 
 
 # Compatible changes (which does not require version bumping):
 #     * Editing message (number and type of placeholders must remain, relative order of
 #       placeholders may be changed, e.g. "File %1$s line %2$d" may be safely edited to
 #       "Line %2$d file %1$s").
 #     * Adding new message to the end of section.
-# Incompatible changes (version must be bumbed by 1):
+# Incompatible changes (version must be bumped by 1):
 #     * Introducing new placeholders to existing messages.
 #     * Changing type of placeholders (e.g. "line %1$d" -> "line %1$s").
 #     * Rearranging order of messages.
 #     * Deleting messages.
 # Use special "OBSOLETE" pseudoidentifier for obsolete entries, which is kept only for backward
 # compatibility. When version is bumped, do not forget to delete all obsolete entries.
 
 

 AffEqualTopologyTypes        "%1$s: topology layer \"%2$s\" is equivalent to \"%3$s\"."
 AffGranTooCoarseProcGroup    "%1$s: granularity=%2$s is too coarse, setting granularity=group."
 StgDeprecatedValue           "%1$s: \"%2$s\" value is deprecated. Please use \"%3$s\" instead."
 NumTeamsNotPositive          "num_teams value must be positive, it is %1$d, using %2$d instead."
 AffHWSubsetIncompat          "KMP_HW_SUBSET ignored: %1$s, %2$s: attributes are ambiguous, please only specify one."
 AffHWSubsetAttrRepeat        "KMP_HW_SUBSET ignored: %1$s: attribute specified more than once."
 AffHWSubsetAttrInvalid       "KMP_HW_SUBSET ignored: %1$s: attribute value %2$s is invalid."
 AffHWSubsetAllFiltered       "KMP_HW_SUBSET ignored: all hardware resources would be filtered, please reduce the filter."
-AffHWSubsetAttrsNonHybrid    "KMP_HW_SUBSET ignored: Too many attributes specified. This machine is not a hybrid architecutre."
-AffHWSubsetIgnoringAttr      "KMP_HW_SUBSET: ignoring %1$s attribute. This machine is not a hybrid architecutre."
+AffHWSubsetAttrsNonHybrid    "KMP_HW_SUBSET ignored: Too many attributes specified. This machine is not a hybrid architecture."
+AffHWSubsetIgnoringAttr      "KMP_HW_SUBSET: ignoring %1$s attribute. This machine is not a hybrid architecture."
 
 # --------------------------------------------------------------------------------------------------
 -*- HINTS -*-
 # --------------------------------------------------------------------------------------------------
 
 # Hints. Hint may be printed after a message. Usually it is longer explanation text or suggestion.
 # To maintain hint numbers (they are visible to customers), add new hints to the end.
 

openmp/runtime/src/kmp_affinity.cpp

if (core_level == level) {
           using_core_types = true;
         if (item.attr[j].is_core_eff_valid())
           using_core_effs = true;
       }
 
       // Check if using a single core attribute on non-hybrid arch.
       // Do not ignore all of KMP_HW_SUBSET, just ignore the attribute.
       //
-      // Check if using multiple core attributes on non-hyrbid arch.
+      // Check if using multiple core attributes on non-hybrid arch.
       // Ignore all of KMP_HW_SUBSET if this is the case.
       if ((using_core_effs || using_core_types) && !__kmp_is_hybrid_cpu()) {
         if (item.num_attrs == 1) {
           if (using_core_effs) {
             KMP_AFF_WARNING(AffHWSubsetIgnoringAttr, "efficiency");
           } else {
             KMP_AFF_WARNING(AffHWSubsetIgnoringAttr, "core_type");
           }
static bool __kmp_affinity_create_hwloc_map(kmp_i18n_id_t *const msg_id) {
   if (__kmp_affinity_verbose) {
     KMP_INFORM(AffUsingHwloc, "KMP_AFFINITY");
   }
 
   if (!KMP_AFFINITY_CAPABLE()) {
     // Hack to try and infer the machine topology using only the data
     // available from hwloc on the current thread, and __kmp_xproc.
     KMP_ASSERT(__kmp_affinity_type == affinity_none);
-    // hwloc only guarantees existance of PU object, so check PACKAGE and CORE
+    // hwloc only guarantees existence of PU object, so check PACKAGE and CORE
     hwloc_obj_t o = hwloc_get_obj_by_type(tp, HWLOC_OBJ_PACKAGE, 0);
     if (o != NULL)
       nCoresPerPkg = __kmp_hwloc_get_nobjs_under_obj(o, HWLOC_OBJ_CORE);
     else
       nCoresPerPkg = 1; // no PACKAGE found
     o = hwloc_get_obj_by_type(tp, HWLOC_OBJ_CORE, 0);
     if (o != NULL)
       __kmp_nThreadsPerCore = __kmp_hwloc_get_nobjs_under_obj(o, HWLOC_OBJ_PU);

openmp/runtime/src/kmp_csupport.cpp

 @param global_tid global thread number
 @param num_teams_lb lower bound on number of teams requested for the teams
 construct
 @param num_teams_ub upper bound on number of teams requested for the teams
 construct
 @param num_threads number of threads per team requested for the teams construct
 
 Set the number of teams to be used by the teams construct. The number of initial
-teams cretaed will be greater than or equal to the lower bound and less than or
+teams created will be greater than or equal to the lower bound and less than or
 equal to the upper bound.
 This call is only required if the teams construct has a `num_teams` clause
 or a `thread_limit` clause (or both).
 */
 void __kmpc_push_num_teams_51(ident_t *loc, kmp_int32 global_tid,
                               kmp_int32 num_teams_lb, kmp_int32 num_teams_ub,
                               kmp_int32 num_threads) {
   KA_TRACE(20, ("__kmpc_push_num_teams_51: enter T#%d num_teams_lb=%d"

openmp/runtime/src/kmp_io.cpp

if (!__kmp_console_exists) {
     HANDLE ho;
     HANDLE he;
 
     __kmp_str_buf_init(&__kmp_console_buf);
 
     AllocConsole();
     // We do not check the result of AllocConsole because
     //  1. the call is harmless
-    //  2. it is not clear how to communicate failue
+    //  2. it is not clear how to communicate failure
     //  3. we will detect failure later when we get handle(s)
 
     ho = GetStdHandle(STD_OUTPUT_HANDLE);
     if (ho == INVALID_HANDLE_VALUE || ho == NULL) {
 
       DWORD err = GetLastError();
       // TODO: output error somehow (maybe message box)
       (void)err;

openmp/runtime/src/kmp_itt.h

 #define SSC_MARK_SPIN_START() INSERT_SSC_MARK(0x4376)
 #define SSC_MARK_SPIN_END() INSERT_SSC_MARK(0x4377)
 
 // Markers for architecture simulation.
 // FORKING      : Before the primary thread forks.
 // JOINING      : At the start of the join.
 // INVOKING     : Before the threads invoke microtasks.
 // DISPATCH_INIT: At the start of dynamically scheduled loop.
-// DISPATCH_NEXT: After claming next iteration of dynamically scheduled loop.
+// DISPATCH_NEXT: After claiming next iteration of dynamically scheduled loop.
 #define SSC_MARK_FORKING() INSERT_SSC_MARK(0xd693)
 #define SSC_MARK_JOINING() INSERT_SSC_MARK(0xd694)
 #define SSC_MARK_INVOKING() INSERT_SSC_MARK(0xd695)
 #define SSC_MARK_DISPATCH_INIT() INSERT_SSC_MARK(0xd696)
 #define SSC_MARK_DISPATCH_NEXT() INSERT_SSC_MARK(0xd697)
 
 // The object is an address that associates a specific set of the prepare,
 // acquire, release, and cancel operations.

 #include "kmp_itt.inl"
 #endif
 
 #endif // KMP_ITT_H
 
 #else /* USE_ITT_BUILD */
 
 // Null definitions of the synchronization tracing functions.
-// If USE_ITT_BULID is not enabled, USE_ITT_NOTIFY cannot be either.
+// If USE_ITT_BUILD is not enabled, USE_ITT_NOTIFY cannot be either.
 // By defining these we avoid unpleasant ifdef tests in many places.
 #define KMP_FSYNC_PREPARE(obj) ((void)0)
 #define KMP_FSYNC_CANCEL(obj) ((void)0)
 #define KMP_FSYNC_ACQUIRED(obj) ((void)0)
 #define KMP_FSYNC_RELEASING(obj) ((void)0)
 
 #define KMP_FSYNC_SPIN_INIT(obj, spin) ((void)0)
 #define KMP_FSYNC_SPIN_PREPARE(obj) ((void)0)

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
+  // We cannot 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_push_num_teams_51(ident_t *id, int gtid, int num_teams_lb,
   KMP_DEBUG_ASSERT(num_teams_ub >= num_teams_lb);
   KMP_DEBUG_ASSERT(num_threads >= 0);
 
   if (num_teams_lb > num_teams_ub) {
     __kmp_fatal(KMP_MSG(FailedToCreateTeam, num_teams_lb, num_teams_ub),
                 KMP_HNT(SetNewBound, __kmp_teams_max_nth), __kmp_msg_null);
   }
 
-  int num_teams = 1; // defalt number of teams is 1.
+  int num_teams = 1; // default number of teams is 1.
 
   if (num_teams_lb == 0 && num_teams_ub > 0)
     num_teams_lb = num_teams_ub;
 
   if (num_teams_lb == 0 && num_teams_ub == 0) { // no num_teams clause
     num_teams = (__kmp_nteams > 0) ? __kmp_nteams : num_teams;
     if (num_teams > __kmp_teams_max_nth) {
       if (!__kmp_reserve_warn) {

openmp/runtime/src/kmp_settings.cpp

static void __kmp_stg_parse_num_hidden_helper_threads(char const *name,
                                                       char const *value,
                                                       void *data) {
   __kmp_stg_parse_int(name, value, 0, 16, &__kmp_hidden_helper_threads_num);
   // If the number of hidden helper threads is zero, we disable hidden helper
   // task
   if (__kmp_hidden_helper_threads_num == 0) {
     __kmp_enable_hidden_helper = FALSE;
   } else {
-    // Since the main thread of hidden helper team dooes not participate
+    // Since the main thread of hidden helper team does not participate
     // in tasks execution let's increment the number of threads by one
     // so that requested number of threads do actual job.
     __kmp_hidden_helper_threads_num++;
   }
 } // __kmp_stg_parse_num_hidden_helper_threads
 
 static void __kmp_stg_print_num_hidden_helper_threads(kmp_str_buf_t *buffer,
                                                       char const *name,

openmp/runtime/src/kmp_tasking.cpp

if (UNLIKELY(ompt_enabled.enabled)) {
     thread->th.ompt_thread_info.wait_id = 0;
     thread->th.ompt_thread_info.state = (thread->th.th_team_serialized)
                                             ? ompt_state_work_serial
                                             : ompt_state_work_parallel;
     taskdata->ompt_task_info.frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
   }
 #endif
 
-  // Decreament the counter of hidden helper tasks to be executed
+  // Decrement the counter of hidden helper tasks to be executed
   if (taskdata->td_flags.hidden_helper) {
     // Hidden helper tasks can only be executed by hidden helper threads
     KMP_ASSERT(KMP_HIDDEN_HELPER_THREAD(gtid));
     KMP_ATOMIC_DEC(&__kmp_unexecuted_hidden_helper_tasks);
   }
 
   // Proxy tasks are not handled by the runtime
   if (taskdata->td_flags.proxy != TASK_PROXY) {

openmp/runtime/src/kmp_utility.cpp

for (i = 2; i <= max_arg; ++i) {
                ("INFO: CPUID %d: EAX=0x%08X EBX=0x%08X ECX=0x%08X EDX=0x%08X\n",
                 i, buf.eax, buf.ebx, buf.ecx, buf.edx));
     }
 #endif
     p->flags.rtm = 0;
     p->flags.hybrid = 0;
     if (max_arg > 7) {
       /* RTM bit CPUID.07:EBX, bit 11 */
-      /* HYRBID bit CPUID.07:EDX, bit 15 */
+      /* HYBRID bit CPUID.07:EDX, bit 15 */
       __kmp_x86_cpuid(7, 0, &buf);
       p->flags.rtm = (buf.ebx >> 11) & 1;
       p->flags.hybrid = (buf.edx >> 15) & 1;
       if (p->flags.rtm) {
         KA_TRACE(trace_level, (" RTM"));
       }
       if (p->flags.hybrid) {
         KA_TRACE(trace_level, (" HYBRID"));

openmp/runtime/test/affinity/libomp_test_topology.h

if (proc_bind == omp_proc_bind_close) {
                   proc_bind, T, P,
                   "Not enough threads have place %d for their current place\n",
                   parent->place_nums[j]);
             }
             j = (j + 1) % parent->num_places;
             if (current_place != parent->place_nums[j]) {
               proc_bind_die(
                   proc_bind, T, P,
-                  "Thread %d's place (%d) is not corret. Expected %d\n", i,
+                  "Thread %d's place (%d) is not correct. Expected %d\n", i,
                   partitions[i]->current_place, parent->place_nums[j]);
             }
             count = 1;
           }
         }
       }
     } else {
       // proc_bind_primary

openmp/runtime/test/critical/omp_critical_with_hint.c

 // RUN: %libomp-compile-and-run
-// critial with hint was introduced with icc 19
+// critical with hint was introduced with icc 19
 // UNSUPPORTED: icc-18
 
 #include <stdio.h>
 #include <omp.h>
 #include "omp_testsuite.h"
 
 int test_omp_critical(int iter) {
   int sum;

openmp/runtime/test/tasking/hidden_helper_task/single_helper_thread.c

 // RUN: %libomp-compile && env LIBOMP_NUM_HIDDEN_HELPER_THREADS=1 %libomp-run
 
-// The test checks that "devide-by-0" bug fixed in runtime.
+// The test checks that "divide-by-0" bug fixed in runtime.
 // The fix is to increment number of threads by 1 if positive,
 // so that operation
 //   (gtid) % (__kmp_hidden_helper_threads_num - 1)
 // does not cause crash.
 
 #include <stdio.h>
 #include <omp.h>
 

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

 int main(int argc, char *argv[])
 {
   int chunk = 0;
 // static (no chunk)
   omp_set_schedule(omp_sched_static,0);
 #pragma omp parallel// num_threads(num_th)
   run_loop(0, 26, 1, chunk);
 
-// auto (chunk should be ignorted)
+// auto (chunk should be ignored)
   omp_set_schedule(omp_sched_auto,0);
 #pragma omp parallel// num_threads(num_th)
   run_loop(0, 26, 1, chunk);
 
 // static,1
   chunk = 1;
   omp_set_schedule(omp_sched_static,1);
 #pragma omp parallel// num_threads(num_th)

openmp/runtime/tools/lib/tools.pm

 =head3 get_options
 
 B<Synopsis:>
 
     get_options( @arguments )
 
 B<Description:>
 
-It is very simple wrapper arounf Getopt::Long::GetOptions. It passes all arguments to GetOptions,
+It is very simple wrapper around Getopt::Long::GetOptions. It passes all arguments to GetOptions,
 and add definitions for standard help options: --help, --doc, --verbose, and --quiet.
 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

 
 =cut
 
 # -------------------------------------------------------------------------------------------------
 
 =item C<which( $file, @options )>
 
 Searches for specified executable file in the (specified) directories.
-Raises a runtime eroror if no executable file found. Returns a full path of found executable(s).
+Raises a runtime error if no executable file found. Returns a full path of found executable(s).
 
 Options:
 
 =over
 
 =item C<-all> =E<gt> I<bool>
 
 Do not stop on the first found file. Note, that list of full paths is returned in this case.