Comment Spelling Fixes

CMakeLists.txt

@@ -57,7 +57,7 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
   message(FATAL_ERROR
     "In-source build are not allowed.
 Please create a directory directory and run cmake from there, passing the path
-to this source directory as the last argumente.
+to this source directory as the last argument.
 This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
 Please delete them.")
 endif()

examples/blackscholes/blackscholes.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2007, Intel Copr.
+// Copyright (c) 2007, Intel Corp.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without

include/shad/core/vector.h

@@ -37,7 +37,7 @@ namespace impl {
 /// @brief Distributed vector without resizing capabilities.
 /// TODO change the descriptions
 /// The C++ standard defines the ::vector as a dynamically
-/// resizeable sequence of objects.  A ::vector should be a contiguous container
+/// resizable sequence of objects.  A ::vector should be a contiguous container
 /// (as defined in the C++ standard).  According to that definition, contiguous
 /// containers requires contiguous iterators.  The definition of contiguous
 /// iterators implies contiguous memory allocation for the sequence, and it
@@ -852,7 +852,7 @@ class alignas(64) vector<T>::vector_iterator {
 /// @brief Fixed size distributed vector.
 ///
 /// Section XX.X.X.X of the C++ standard defines the ::vector as a dynamically
-/// resizeable sequence of objects.  A ::vector should be a contiguous container
+/// resizable sequence of objects.  A ::vector should be a contiguous container
 /// (as defined in section XX.X.X).  According to that definition, contiguous
 /// containers requires contiguous iterators.  The definition of contiguous
 /// iterators implies contiguous memory allocation for the sequence, and it

include/shad/data_structures/abstract_data_structure.h

@@ -47,7 +47,7 @@ namespace shad {
 /// @warning Subclasses SUBC of AbstractDataStructure MUST implement the
 /// constructor SUBC(ObjectID oid, Args ... args) and the GetGlobalID() method.
 ///
-/// The inheriting class constructor can accept aribitrary memcpyable arguments
+/// The inheriting class constructor can accept arbitrary memcpyable arguments
 /// (args): the create method of AbstractDataStructure can be called from the
 /// subclass using the same arguments (args) of the constructor.  It is
 /// recommended to implement the constructor as private/protected.
@@ -116,7 +116,7 @@ class AbstractDataStructure {
   /// retrieve a valid shared_ptr via the GetPtr operation.
   ///
   /// @param oid The global identifier of the DataStructure instance.
-  /// @return A shared_ptr to the DataStructure instance associared to oid.
+  /// @return A shared_ptr to the DataStructure instance associated to oid.
   static SharedPtr GetPtr(ObjectID oid) {
     return Catalog::Instance()->GetPtr(oid);
   }

include/shad/data_structures/array.h

@@ -307,7 +307,7 @@ class Array : public AbstractDataStructure<Array<T>> {
 
   /// @brief Lookup Method.
   ///
-  /// Retireve an element at a given position.
+  /// Retrieve an element at a given position.
   ///
   /// Typical usage:
   /// @code
@@ -324,7 +324,7 @@ class Array : public AbstractDataStructure<Array<T>> {
 
   /// @brief Asynchronous Lookup Method.
   ///
-  /// Retireve an element at a given position asynchronously.
+  /// Retrieve an element at a given position asynchronously.
   ///
   /// @warning Asynchronous operations are guaranteed to have completed
   /// only after calling the rt::waitForCompletion(rt::Handle &handle) method.

include/shad/data_structures/atomic.h

@@ -36,7 +36,7 @@ namespace shad {
 ///
 /// @warning Writes are not propagated across the system.
 ///
-/// @tparam T The typen of the objects that will be instantiated.
+/// @tparam T The type of the objects that will be instantiated.
 template <typename T>
 class Atomic : public AbstractDataStructure<Atomic<T>> {
  public:
@@ -57,7 +57,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
   static SharedPtr Create(Args... args);
 #endif
 
-  /// @brief Retieve the Global Identifier.
+  /// @brief Retrieve the Global Identifier.
   ///
   /// @return The global identifier associated with the array instance.
   ObjectID GetGlobalID() const { return oid_; }
@@ -144,7 +144,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
   }
 
   /// @brief Atomic Store. Attempts at atomically storing the results of binop
-  ///                      unitil succesful.
+  ///                      until successful.
   ///
   /// @tparam ArgT Type of rhs for the BinaryOp operator.
   /// @tparam BinaryOp User-defined binary operator T (const T& lhs, const ArgT& rhs).
@@ -181,7 +181,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
 
 
   /// @brief Async Atomic Fetch-Store. Attempts at atomically storing
-  ///                            the results of binop unitil succesful.
+  ///                            the results of binop until successful.
   ///
   /// @tparam ArgT Type of rhs for the BinaryOp operator.
   /// @tparam BinaryOp User-defined binary operator T (const T& lhs, const ArgT& rhs).
@@ -272,7 +272,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
   }
 
   /// @brief Async Atomic Store. Attempts at atomically storing
-  ///                            the results of binop unitil succesful.
+  ///                            the results of binop until successful.
   ///
   /// @tparam ArgT Type of rhs for the BinaryOp operator.
   /// @tparam BinaryOp User-defined binary operator T (const T& lhs, const ArgT& rhs).
@@ -309,7 +309,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
   }
 
   /// @brief Async Atomic Fetch-Store. Attempts at atomically storing
-  ///                            the results of binop unitil succesful.
+  ///                            the results of binop until successful.
   ///
   /// @tparam ArgT Type of rhs for the BinaryOp operator.
   /// @tparam BinaryOp User-defined binary operator T (const T& lhs, const ArgT& rhs).
@@ -404,7 +404,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
   /// @brief Fetch Add operation.
   ///
   /// @param[in] add Data to be fetch-added.
-  /// @return Result of the fect-add operation.
+  /// @return Result of the fetch-add operation.
   T FetchAdd(T add) {
     if (ownerLoc_ == rt::thisLocality()) {
      return localInstance_.fetch_add(add);
@@ -462,7 +462,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
   /// @brief Fetch Sub operation.
   ///
   /// @param[in] sub Data to be fetch-subbed.
-  /// @return Result of the fect-sub operation.
+  /// @return Result of the fetch-sub operation.
   T FetchSub(T sub) {
     if (ownerLoc_ == rt::thisLocality()) {
      return localInstance_.fetch_sub(sub);
@@ -520,7 +520,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
   /// @brief Fetch And operation.
   ///
   /// @param[in] operand Data to be fetch-anded.
-  /// @return Result of the fect-and operation.
+  /// @return Result of the fetch-and operation.
   T FetchAnd(T operand) {
     if (ownerLoc_ == rt::thisLocality()) {
      return localInstance_.fetch_and(operand);
@@ -578,7 +578,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
   /// @brief Fetch Or operation.
   ///
   /// @param[in] operand Data to be fetch-ored.
-  /// @return Result of the fect-or operation.
+  /// @return Result of the fetch-or operation.
   T FetchOr(T operand) {
     if (ownerLoc_ == rt::thisLocality()) {
      return localInstance_.fetch_or(operand);
@@ -636,7 +636,7 @@ class Atomic : public AbstractDataStructure<Atomic<T>> {
   /// @brief Fetch Xor operation.
   ///
   /// @param[in] xor Data to be fetch-xored.
-  /// @return Result of the fect-xor operation.
+  /// @return Result of the fetch-xor operation.
   T FetchXor(T operand) {
     if (ownerLoc_ == rt::thisLocality()) {
      return localInstance_.fetch_xor(operand);

include/shad/data_structures/buffer.h

@@ -54,7 +54,7 @@ namespace impl {
 
 /// @brief The Buffer utility.
 ///
-/// Buffer used to agregate data transfers in insertion methods.
+/// Buffer used to aggregate data transfers in insertion methods.
 /// It is associated to a DataStructure instance, through its
 /// global object identifier, and to the Locality target of the
 /// data transfers.

include/shad/data_structures/compare_and_hash_utils.h

@@ -50,7 +50,7 @@ namespace shad {
 ///   if (!MemCmp()(&value1, &value2)) {
 ///     // they are equal so do something
 ///   } else {
-///     // do sothing different
+///     // do something different
 ///   }
 /// }
 /// @endcode
@@ -82,7 +82,7 @@ class MemCmp {
 ///   if (!MemCmp()(&value1, &value2)) {
 ///     // they are equal so do something
 ///   } else {
-///     // do sothing different
+///     // do something different
 ///   }
 /// }
 /// @endcode

include/shad/data_structures/hashmap.h

@@ -49,7 +49,7 @@ class map_iterator;
 /// @tparam KTYPE type of the hashmap keys.
 /// @tparam VTYPE type of the hashmap values.
 /// @tparam KEY_COMPARE key comparison function; default is MemCmp<KTYPE>.
-/// @warning obects of type KTYPE and VTYPE need to be trivially copiable.
+/// @warning objects of type KTYPE and VTYPE need to be trivially copyable.
 /// @tparam INSERT_POLICY insertion policy; default is overwrite
 /// (i.e. insertions overwrite previous values
 ///  associated to the same key, if any).
@@ -95,7 +95,7 @@ class Hashmap : public AbstractDataStructure<
 
   /// @brief Create method.
   ///
-  /// Creates a newhashmap instance.
+  /// Creates a new hashmap instance.
   /// @param numEntries Expected number of entries.
   /// @return A shared pointer to the newly created hashmap instance.
 #ifdef DOXYGEN_IS_RUNNING
@@ -107,7 +107,7 @@ class Hashmap : public AbstractDataStructure<
   /// @return The global identifier associated with the hashmap instance.
   ObjectID GetGlobalID() const { return oid_; }
 
-  /// @brief Getter of the local hasmap.
+  /// @brief Getter of the local hashmap.
   ///
   /// @return The pointer to the local hashmap instance.
   LocalHashmap<KTYPE, VTYPE, KEY_COMPARE, INSERT_POLICY> * GetLocalHashmap() {
@@ -116,7 +116,7 @@ class Hashmap : public AbstractDataStructure<
 
   /// @brief Overall size of the hashmap (number of entries).
   /// @warning Calling the size method may result in one-to-all
-  /// communication among localities to retrieve consinstent information.
+  /// communication among localities to retrieve consistent information.
   /// @return the size of the hashmap.
   size_t Size() const;