[mlir] NFC: fix trivial typo in source files

[kiszk]

Summary

fix trivial typos in the source files

[kiszk]

Sorry for putting unnecessary text again... https://github.com/llvm/llvm-project/commit/e5a8512655cea42f70d4205f59e9c36d3628b8da

I made a mistake. arcfilter should be executed manually. I thought that it is a hook that is automatically executed by arc. I am sorry again.

mlir/include/mlir/Dialect/SPIRV/SPIRVAttributes.h

public:
 
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     IntegerAttr version,
                                                     ArrayAttr capabilities,
                                                     ArrayAttr extensions);
 };
 
 /// An attribute that specifies the target version, allowed extensions and
-/// capabilities, and resource limits. These information describles a SPIR-V
+/// capabilities, and resource limits. These information describes a SPIR-V
 /// target environment.
 class TargetEnvAttr
     : public Attribute::AttrBase<TargetEnvAttr, Attribute,
                                  detail::TargetEnvAttributeStorage> {
 public:
   using Base::Base;
 
   /// Gets a TargetEnvAttr instance.

mlir/include/mlir/Transforms/Passes.h

 
 /// Creates a pass to perform optimizations relying on memref dataflow such as
 /// store to load forwarding, elimination of dead stores, and dead allocs.
 std::unique_ptr<OpPassBase<FuncOp>> createMemRefDataFlowOptPass();
 
 /// Creates a pass to strip debug information from a function.
 std::unique_ptr<Pass> createStripDebugInfoPass();
 
-/// Creates a pass which prints the list of ops and the number of occurences in
+/// Creates a pass which prints the list of ops and the number of occurrences in
 /// the module.
 std::unique_ptr<OpPassBase<ModuleOp>> createPrintOpStatsPass();
 
 /// Creates a pass which inlines calls and callable operations as defined by
 /// the CallGraph.
 std::unique_ptr<Pass> createInlinerPass();
 
 /// Creates a pass which delete symbol operations that are unreachable. This
 /// pass may *only* be scheduled on an operation that defines a SymbolTable.
 std::unique_ptr<Pass> createSymbolDCEPass();
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_PASSES_H

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

static Value buildMinMaxReductionSeq(Location loc, CmpIPredicate predicate,
   for (; valueIt != values.end(); ++valueIt) {
     auto cmpOp = builder.create<CmpIOp>(loc, predicate, value, *valueIt);
     value = builder.create<SelectOp>(loc, cmpOp.getResult(), value, *valueIt);
   }
 
   return value;
 }
 
-/// Emit instructions that correspond to computing the maximum value amoung the
+/// Emit instructions that correspond to computing the maximum value among the
 /// values of a (potentially) multi-output affine map applied to `operands`.
 static Value lowerAffineMapMax(OpBuilder &builder, Location loc, AffineMap map,
                                ValueRange operands) {
   if (auto values = expandAffineMap(builder, loc, map, operands))
     return buildMinMaxReductionSeq(loc, CmpIPredicate::sgt, *values, builder);
   return nullptr;
 }
 
-/// Emit instructions that correspond to computing the minimum value amoung the
+/// Emit instructions that correspond to computing the minimum value among the
 /// values of a (potentially) multi-output affine map applied to `operands`.
 static Value lowerAffineMapMin(OpBuilder &builder, Location loc, AffineMap map,
                                ValueRange operands) {
   if (auto values = expandAffineMap(builder, loc, map, operands))
     return buildMinMaxReductionSeq(loc, CmpIPredicate::slt, *values, builder);
   return nullptr;
 }
 

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.cpp

public:
 
   LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// This is separate because in Vulkan workgroup size is exposed to shaders via
 /// a constant with WorkgroupSize decoration. So here we cannot generate a
-/// builtin variable; instead the infromation in the `spv.entry_point_abi`
+/// builtin variable; instead the information in the `spv.entry_point_abi`
 /// attribute on the surrounding FuncOp is used to replace the gpu::BlockDimOp.
 class WorkGroupSizeConversion : public SPIRVOpLowering<gpu::BlockDimOp> {
 public:
   using SPIRVOpLowering<gpu::BlockDimOp>::SPIRVOpLowering;
 
   LogicalResult
   matchAndRewrite(gpu::BlockDimOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

public:
   void runOnModule() override;
 
 private:
   /// Creates a SPIR-V binary shader from the given `module` using
   /// `spirv::serialize` function.
   LogicalResult createBinaryShader(ModuleOp module,
                                    std::vector<char> &binaryShader);
 
-  /// Converts the given `luanchOp` to vulkan launch call.
+  /// Converts the given `launchOp` to vulkan launch call.
   void convertGpuLaunchFunc(gpu::LaunchFuncOp launchOp);
 
   /// Checks where the given type is supported by Vulkan runtime.
   bool isSupportedType(Type type) {
     // TODO(denis0x0D): Handle other types.
     if (auto memRefType = type.dyn_cast_or_null<MemRefType>())
       return memRefType.hasRank() &&
              (memRefType.getRank() == 1 || memRefType.getRank() == 2);

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp

 SingleWorkgroupReduction::matchAsPerformingReduction(
     linalg::GenericOp genericOp) {
   Operation *op = genericOp.getOperation();
 
   // Make sure the linalg.generic is working on memrefs.
   if (!genericOp.hasBufferSemantics())
     return llvm::None;
 
-  // Make sure this is reudction with one input and one output.
+  // Make sure this is reduction with one input and one output.
   if (genericOp.args_in().getZExtValue() != 1 ||
       genericOp.args_out().getZExtValue() != 1)
     return llvm::None;
 
   auto originalInputType = op->getOperand(0).getType().cast<MemRefType>();
   auto originalOutputType = op->getOperand(1).getType().cast<MemRefType>();
 
   // Make sure the original input has one dimension.

mlir/lib/Conversion/LoopToStandard/LoopToStandard.cpp

if (first) {
       // Store the results of the outermost loop that will be used to replace
       // the results of the parallel loop when it is fully rewritten.
       loopResults.assign(forOp.result_begin(), forOp.result_end());
       first = false;
     } else {
       // A loop is constructed with an empty "yield" terminator by default.
       // Replace it with another "yield" that forwards the results of the nested
       // loop to the parent loop. We need to explicitly make sure the new
-      // terminator is the last operation in the block because further transfoms
-      // rely on this.
+      // terminator is the last operation in the block because further
+      // transforms rely on this.
       rewriter.setInsertionPointToEnd(rewriter.getInsertionBlock());
       rewriter.replaceOpWithNewOp<YieldOp>(
           rewriter.getInsertionBlock()->getTerminator(), forOp.getResults());
     }
 
     rewriter.setInsertionPointToStart(forOp.getBody());
   }
 

mlir/lib/Conversion/LoopsToGPU/LoopsToGPU.cpp

if (isMappedToProcessor(processor)) {
           rewriter.getAffineDimExpr(0) * rewriter.getAffineSymbolExpr(0) +
               rewriter.getAffineSymbolExpr(1));
       newIndex = rewriter.create<AffineApplyOp>(
           loc, annotation.map().getValue().compose(lowerAndStep),
           ValueRange{operand, step, lowerBound});
       // If there was also a bound, insert that, too.
       // TODO(herhut): Check that we do not assign bounds twice.
       if (annotation.bound().getValue()) {
-        // We pass as the single opererand to the bound-map the number of
+        // We pass as the single operand to the bound-map the number of
         // iterations, which is (upperBound - lowerBound) ceilDiv step. To
         // support inner loops with dynamic upper bounds (as generated by e.g.
         // tiling), try to derive a max for the bounds. If the used bound for
         // the hardware id is imprecise, wrap the contained code into a
         // conditional. If the lower-bound is constant or defined before the
         // launch, we can use it in the launch bounds. Otherwise fail.
         if (!launchIndependent(lowerBound) &&
             !isa_and_nonnull<ConstantOp>(lowerBound.getDefiningOp()))
ParallelToGpuLaunchLowering::matchAndRewrite(ParallelOp parallelOp,
   bool seenSideeffects = false;
   // Whether we have left a nesting scope (and hence are no longer innermost).
   bool leftNestingScope = false;
   while (!worklist.empty()) {
     Operation *op = worklist.pop_back_val();
     // Now walk over the body and clone it.
     // TODO: This is only correct if there either is no further loop.parallel
     //       nested or this code is side-effect free. Otherwise we might need
-    //       predication. We are overly consertaive for now and only allow
+    //       predication. We are overly conservative for now and only allow
     //       side-effects in the innermost scope.
     if (auto nestedParallel = dyn_cast<ParallelOp>(op)) {
       // Before entering a nested scope, make sure there have been no
       // sideeffects until now.
       if (seenSideeffects)
         return failure();
       // A nested loop.parallel needs insertion of code to compute indices.
       // Insert that now. This will also update the worklist with the loops

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // AffineParallelOp
 //===----------------------------------------------------------------------===//
 
 void AffineParallelOp::build(Builder *builder, OperationState &result,
                              ArrayRef<int64_t> ranges) {
-  // Default initalize empty maps.
+  // Default initialize empty maps.
   auto lbMap = AffineMap::get(builder->getContext());
   auto ubMap = AffineMap::get(builder->getContext());
   // If there are ranges, set each to [0, N).
   if (ranges.size()) {
     SmallVector<AffineExpr, 8> lbExprs(ranges.size(),
                                        builder->getAffineConstantExpr(0));
     lbMap = AffineMap::get(0, 0, lbExprs);
     SmallVector<AffineExpr, 8> ubExprs;

mlir/lib/Dialect/Linalg/Transforms/LinalgToLoops.cpp

static void emitScalarImplementation(ArrayRef<Value> allIvs,
     C(i, j) = C(i, j) + A(i, r_k) * B(r_k, j);
   }
 };
 
 template <typename IndexedValueType>
 class LinalgScopedEmitter<IndexedValueType, ConvOp> {
 public:
   /// Returns the input value of convOp. If the indices in `imIdx` is out of
-  /// boundrary, returns 0 instead.
+  /// boundary, returns 0 instead.
   static ValueHandle getConvOpInput(ConvOp convOp, IndexedValueType im,
                                     ArrayRef<ValueHandle> imIdx) {
     // TODO(ntv): add a level of indirection to linalg.generic.
     if (!convOp.padding())
       return im(imIdx);
 
     auto *context = ScopedContext::getContext();
     ValueHandle zeroIndex = std_constant_index(0);
for (auto iter : llvm::enumerate(imIdx)) {
       ValueHandle leftOutOfBound = dim < zeroIndex;
       if (conds.empty())
         conds.push_back(leftOutOfBound);
       else
         conds.push_back(conds.back() || leftOutOfBound);
       ValueHandle rightBound = std_dim(convOp.input(), idx);
       conds.push_back(conds.back() || (dim >= rightBound));
 
-      // When padding is involed, the indices will only be shifted to negative,
+      // When padding is involved, the indices will only be shifted to negative,
       // so having a max op is enough.
       auto maxMap = AffineMap::get(/*dimCount=*/1, 0,
                                    {getAffineDimExpr(/*position=*/0, context),
                                     getAffineConstantExpr(0, context)});
       clampedImIdx.push_back(
           affine_max(dim.getType(), maxMap, ValueRange{dim}));
     }
 

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

Attribute SPIRVDialect::parseAttribute(DialectAsmParser &parser,
   if (parser.parseKeyword(&attrKind))
     return {};
 
   if (attrKind == spirv::TargetEnvAttr::getKindName())
     return parseTargetEnvAttr(parser);
   if (attrKind == spirv::VerCapExtAttr::getKindName())
     return parseVerCapExtAttr(parser);
 
-  parser.emitError(parser.getNameLoc(), "unknown SPIR-V attriubte kind: ")
+  parser.emitError(parser.getNameLoc(), "unknown SPIR-V attribute kind: ")
       << attrKind;
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // Attribute Printing
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp

Type SPIRVTypeConverter::getIndexType(MLIRContext *context) {
   // instructions. The Vulkan spec requires the builtins like
   // GlobalInvocationID, etc. to be 32-bit (unsigned) integers which should be
   // SExtended to 64-bit for index computations.
   return IntegerType::get(32, context);
 }
 
 /// Mapping between SPIR-V storage classes to memref memory spaces.
 ///
-/// Note: memref does not have a defined smenatics for each memory space; it
+/// Note: memref does not have a defined semantics for each memory space; it
 /// depends on the context where it is used. There are no particular reasons
-/// behind the number assigments; we try to follow NVVM conventions and largely
+/// behind the number assignments; we try to follow NVVM conventions and largely
 /// give common storage classes a smaller number. The hope is use symbolic
 /// memory space representation eventually after memref supports it.
 // TODO(antiagainst): swap Generic and StorageBuffer assignment to be more akin
 // to NVVM.
 #define STORAGE_SPACE_MAP_LIST(MAP_FN)                                         \
   MAP_FN(spirv::StorageClass::Generic, 1)                                      \
   MAP_FN(spirv::StorageClass::StorageBuffer, 0)                                \
   MAP_FN(spirv::StorageClass::Workgroup, 3)                                    \
convertScalarType(const spirv::TargetEnv &targetEnv, spirv::ScalarType type,
   if (succeeded(checkCapabilityRequirements(type, targetEnv, capabilities)) &&
       succeeded(checkExtensionRequirements(type, targetEnv, extensions)))
     return type;
 
   // Otherwise we need to adjust the type, which really means adjusting the
   // bitwidth given this is a scalar type.
   // TODO(antiagainst): We are unconditionally converting the bitwidth here,
   // this might be okay for non-interface types (i.e., types used in
-  // Priviate/Function storage classes), but not for interface types (i.e.,
+  // Private/Function storage classes), but not for interface types (i.e.,
   // types used in StorageBuffer/Uniform/PushConstant/etc. storage classes).
   // This is because the later actually affects the ABI contract with the
   // runtime. So we may want to expose a control on SPIRVTypeConverter to fail
   // conversion if we cannot change there.
 
   if (auto floatType = type.dyn_cast<FloatType>()) {
     LLVM_DEBUG(llvm::dbgs() << type << " converted to 32-bit for SPIR-V\n");
     return Builder(targetEnv.getContext()).getF32Type();

mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp

break
       MIN_VERSION_CASE(0);
       MIN_VERSION_CASE(1);
       MIN_VERSION_CASE(2);
       MIN_VERSION_CASE(3);
       MIN_VERSION_CASE(4);
       MIN_VERSION_CASE(5);
 #undef MIN_VERSION_CASE
     default:
-      return emitError(unknownLoc, "unspported SPIR-V minor version: ")
+      return emitError(unknownLoc, "unsupported SPIR-V minor version: ")
              << minorVersion;
     }
   } else {
-    return emitError(unknownLoc, "unspported SPIR-V major version: ")
+    return emitError(unknownLoc, "unsupported SPIR-V major version: ")
            << majorVersion;
   }
 
   // TODO(antiagainst): generator number, bound, schema
   curOffset = spirv::kHeaderWordCount;
   return success();
 }
 

mlir/lib/Dialect/Traits.cpp

for (auto other : make_early_inc_range(rankedOperands)) {
     SmallVector<int64_t, 4> temp = resultShape;
     if (!util::getBroadcastedShape(temp, getShape(other), resultShape))
       return op->emitOpError("operands don't have broadcast-compatible shapes");
   }
 
   auto rankedResults = make_filter_range(
       op->getResultTypes(), [](Type t) { return t.isa<RankedTensorType>(); });
 
-  // If all of the results are unranked then no further verfication.
+  // If all of the results are unranked then no further verification.
   if (rankedResults.empty())
     return success();
 
   for (auto type : rankedResults) {
     ArrayRef<int64_t> actualSuffix =
         getShape(type).take_back(resultShape.size());
     if (!areCompatibleShapes(actualSuffix, resultShape))
       return op->emitOpError()
              << "result type " << getShapeString(getShape(type))
              << " not broadcast compatible with broadcasted operands's shapes "
              << getShapeString(resultShape);
   }
   return success();
 }

mlir/lib/Dialect/Vector/VectorTransforms.cpp

 //             |            |          |                       |
 //              \           |          |                      /
 //               -------------------- opA1 -------------------
 //                          |          |
 //                           \        /
 //                           insertslice
 //                                |
 
-// TODO(andydavis) Add the following canonicalization/simplifcation patterns:
+// TODO(andydavis) Add the following canonicalization/simplification patterns:
 // *) Add pattern which matches InsertStridedSlice -> StridedSlice and forwards
 //    InsertStridedSlice operand to StridedSlice.
 // *) Add pattern which matches SourceOp -> StridedSlice -> UserOp which checks
 //    if there are duplicate identical StridedSlice ops from SourceOp, and
 //    rewrites itself to use the first duplicate. This transformation should
 //    cause users of identifical StridedSlice ops to reuse the same StridedSlice
 //    operation, and leave the duplicate StridedSlice ops with no users
 //    (removable with DCE).

mlir/lib/ExecutionEngine/RunnerUtils.cpp

 //===- RunnerUtils.cpp - Utils for MLIR exec on targets with a C++ runtime ===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
-// This file imlpements basic functions to debug structured MLIR types at
+// This file implements basic functions to debug structured MLIR types at
 // runtime. Entities in this file may not be compatible with targets without a
 // C++ runtime. These may be progressively migrated to CRunnerUtils.cpp over
 // time.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/ExecutionEngine/RunnerUtils.h"
 

mlir/lib/IR/AsmPrinter.cpp

public:
   /// Returns the output stream of the printer.
   raw_ostream &getStream() { return os; }
 
   template <typename Container, typename UnaryFunctor>
   inline void interleaveComma(const Container &c, UnaryFunctor each_fn) const {
     mlir::interleaveComma(c, os, each_fn);
   }
 
-  /// This enum descripes the different kinds of elision for the type of an
+  /// This enum describes the different kinds of elision for the type of an
   /// attribute when printing it.
   enum class AttrTypeElision {
     /// The type must not be elided,
     Never,
     /// The type may be elided when it matches the default used in the parser
     /// (for example i64 is the default for integer attributes).
     May,
     /// The type must be elided.
public:
   /// Renumber the arguments for the specified region to the same names as the
   /// SSA values in namesToUse. This may only be used for IsolatedFromAbove
   /// operations. If any entry in namesToUse is null, the corresponding
   /// argument name is left alone.
   void shadowRegionArgs(Region &region, ValueRange namesToUse) override {
     state->getSSANameState().shadowRegionArgs(region, namesToUse);
   }
 
-  /// Print the given affine map with the smybol and dimension operands printed
+  /// Print the given affine map with the symbol and dimension operands printed
   /// inline with the map.
   void printAffineMapOfSSAIds(AffineMapAttr mapAttr,
                               ValueRange operands) override;
 
   /// Print the given string as a symbol reference.
   void printSymbolName(StringRef symbolRef) override {
     ::printSymbolReference(symbolRef, os);
   }

mlir/lib/IR/MLIRContext.cpp

static Dialect &lookupDialectForSymbol(MLIRContext *ctx,
                                        const ClassID *const classID) {
   auto &impl = ctx->getImpl();
   auto it = impl.registeredDialectSymbols.find(classID);
   assert(it != impl.registeredDialectSymbols.end() &&
          "symbol is not registered.");
   return *it->second;
 }
 
-/// Returns the storage unqiuer used for constructing type storage instances.
+/// Returns the storage uniquer used for constructing type storage instances.
 /// This should not be used directly.
 StorageUniquer &MLIRContext::getTypeUniquer() { return getImpl().typeUniquer; }
 
 /// Get the dialect that registered the type with the provided typeid.
 Dialect &TypeUniquer::lookupDialectForType(MLIRContext *ctx,
                                            const ClassID *const typeID) {
   return lookupDialectForSymbol(ctx, typeID);
 }

mlir/lib/Parser/Parser.cpp

p.emitError(loc) << "expected floating-point or integer element type, got "
                      << elementType;
     return nullptr;
   }
 
   std::string data;
   if (parseElementAttrHexValues(p, hexStorage.getValue(), data))
     return nullptr;
 
-  // Check that the size of the hex data correpsonds to the size of the type, or
+  // Check that the size of the hex data corresponds to the size of the type, or
   // a splat of the type.
   // TODO: bf16 is currently stored as a double, this should be removed when
   // APFloat properly supports it.
   int64_t elementWidth =
       elementType.isBF16() ? 64 : elementType.getIntOrFloatBitWidth();
   if (static_cast<int64_t>(data.size() * CHAR_BIT) !=
       (type.getNumElements() * elementWidth)) {
     p.emitError(loc) << "elements hex data size is invalid for provided type: "

mlir/test/lib/Transforms/TestGpuParallelLoopMapping.cpp

 
 #include "mlir/Dialect/GPU/ParallelLoopMapper.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// Simple pass for testing the mapping of parallel loops to hardware ids using
-/// a greedy mapping stratgegy.
+/// a greedy mapping strategy.
 class TestGpuGreedyParallelLoopMappingPass
     : public OperationPass<TestGpuGreedyParallelLoopMappingPass, FuncOp> {
   void runOnOperation() override {
     Operation *op = getOperation();
     for (Region &region : op->getRegions())
       greedilyMapParallelLoopsToGPU(region);
   }
 };

mlir/tools/mlir-tblgen/OpFormatGen.cpp

private:
   /// This struct represents a type resolution instance. It includes a specific
   /// type as well as an optional transformer to apply to that type in order to
   /// properly resolve the type of a variable.
   struct TypeResolutionInstance {
     const NamedTypeConstraint *type;
     Optional<StringRef> transformer;
   };
 
-  /// Given the values of an `AllTypesMatch` trait, check for inferrable type
+  /// Given the values of an `AllTypesMatch` trait, check for inferable type
   /// resolution.
   void handleAllTypesMatchConstraint(
       ArrayRef<StringRef> values,
       llvm::StringMap<TypeResolutionInstance> &variableTyResolver);
-  /// Check for inferrable type resolution given all operands, and or results,
+  /// Check for inferable type resolution given all operands, and or results,
   /// have the same type. If 'includeResults' is true, the results also have the
   /// same type as all of the operands.
   void handleSameTypesConstraint(
       llvm::StringMap<TypeResolutionInstance> &variableTyResolver,
       bool includeResults);
 
   /// Returns an argument with the given name that has been seen within the
   /// format.

mlir/tools/mlir-vulkan-runner/VulkanRuntime.h

struct NumWorkGroups {
   uint32_t y{1};
   uint32_t z{1};
 };
 
 /// Struct containing information regarding a descriptor set.
 struct DescriptorSetInfo {
   /// Index of a descriptor set in descriptor sets.
   DescriptorSetIndex descriptorSet{0};
-  /// Number of desriptors in a set.
+  /// Number of descriptors in a set.
   uint32_t descriptorSize{0};
   /// Type of a descriptor set.
   VkDescriptorType descriptorType{VK_DESCRIPTOR_TYPE_MAX_ENUM};
 };
 
 /// VulkanHostMemoryBuffer mapped into a descriptor set and a binding.
 using ResourceData =
     llvm::DenseMap<DescriptorSetIndex,

mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp

LogicalResult VulkanRuntime::destroy() {
   for (auto &descriptorSetLayout: descriptorSetLayouts) {
     vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
   }
   vkDestroyShaderModule(device, shaderModule, nullptr);
 
   // For each descriptor set.
   for (auto &deviceMemoryBufferMapPair : deviceMemoryBufferMap) {
     auto &deviceMemoryBuffers = deviceMemoryBufferMapPair.second;
-    // For each descirptor binding.
+    // For each descriptor binding.
     for (auto &memoryBuffer : deviceMemoryBuffers) {
       vkFreeMemory(device, memoryBuffer.deviceMemory, nullptr);
       vkDestroyBuffer(device, memoryBuffer.buffer, nullptr);
     }
   }
 
   vkDestroyDevice(device, nullptr);
   vkDestroyInstance(instance, nullptr);
LogicalResult VulkanRuntime::createDevice() {
   RETURN_ON_VULKAN_ERROR(physicalDeviceCount ? VK_SUCCESS : VK_INCOMPLETE,
                          "physicalDeviceCount");
 
   // TODO(denis0x0D): find the best device.
   physicalDevice = physicalDevices.front();
   if (failed(getBestComputeQueue()))
     return failure();
 
-  const float queuePrioritory = 1.0f;
+  const float queuePriority = 1.0f;
   VkDeviceQueueCreateInfo deviceQueueCreateInfo = {};
   deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
   deviceQueueCreateInfo.pNext = nullptr;
   deviceQueueCreateInfo.flags = 0;
   deviceQueueCreateInfo.queueFamilyIndex = queueFamilyIndex;
   deviceQueueCreateInfo.queueCount = 1;
-  deviceQueueCreateInfo.pQueuePriorities = &queuePrioritory;
+  deviceQueueCreateInfo.pQueuePriorities = &queuePriority;
 
   // Structure specifying parameters of a newly created device.
   VkDeviceCreateInfo deviceCreateInfo = {};
   deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
   deviceCreateInfo.pNext = nullptr;
   deviceCreateInfo.flags = 0;
   deviceCreateInfo.queueCreateInfoCount = 1;
   deviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo;
RETURN_ON_VULKAN_ERROR(vkCreateDescriptorPool(device,
                                                 &descriptorPoolCreateInfo, 0,
                                                 &descriptorPool),
                          "vkCreateDescriptorPool");
   return success();
 }
 
 LogicalResult VulkanRuntime::allocateDescriptorSets() {
   VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = {};
-  // Size of desciptor sets and descriptor layout sets is the same.
+  // Size of descriptor sets and descriptor layout sets is the same.
   descriptorSets.resize(descriptorSetLayouts.size());
   descriptorSetAllocateInfo.sType =
       VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
   descriptorSetAllocateInfo.pNext = nullptr;
   descriptorSetAllocateInfo.descriptorPool = descriptorPool;
   descriptorSetAllocateInfo.descriptorSetCount = descriptorSetLayouts.size();
   descriptorSetAllocateInfo.pSetLayouts = descriptorSetLayouts.data();
   RETURN_ON_VULKAN_ERROR(vkAllocateDescriptorSets(device,
for (const auto &descriptorSetInfo : descriptorSetInfoPool) {
     // For each device memory buffer in the descriptor set.
     const auto &deviceMemoryBuffers =
         deviceMemoryBufferMap[descriptorSetInfo.descriptorSet];
     for (const auto &memoryBuffer : deviceMemoryBuffers) {
       // Structure describing descriptor sets to write to.
       VkWriteDescriptorSet wSet = {};
       wSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
       wSet.pNext = nullptr;
-      // Descirptor set.
+      // Descriptor set.
       wSet.dstSet = *descriptorSetIt;
       wSet.dstBinding = memoryBuffer.bindingIndex;
       wSet.dstArrayElement = 0;
       wSet.descriptorCount = 1;
       wSet.descriptorType = memoryBuffer.descriptorType;
       wSet.pImageInfo = nullptr;
       wSet.pBufferInfo = &memoryBuffer.bufferInfo;
       wSet.pTexelBufferView = nullptr;