Move Common.py to module

tensilelite/Tensile/Activation.py

@@ -31,7 +31,7 @@
                           TensileInstructions
 from .TensileInstructions.Enums import *
 from .TensileInstructions.Instructions import *
-from .Common import printExit, printWarning, globalParameters
+from .Common import printExit, printWarning
 
 from dataclasses import dataclass, field
 

tensilelite/Tensile/AsmAddressCalculation.py

@@ -22,8 +22,7 @@
 
 from .TensileInstructions import Module, EXEC, vgpr, sgpr, log2, Label
 from .TensileInstructions.Instructions import *
-from .Common import globalParameters
-from .Utils import DataDirection
+from .Common import INDEX_CHARS, DataDirection
 
 ##############################################################################
 # Fields associated with computing address
@@ -192,7 +191,7 @@ def emitExtractAndScalePackedDims(self, kernel, ss, tmpVgpr, storeChar):
             #   - tmp+0 may be the incoming packed coordinate 0, used on replay too
             #   - tmp+1 is DIV output
             #   - tmp+2 is scratch
-            idxChar= globalParameters["IndexChars"][idx]
+            idxChar= INDEX_CHARS[idx]
             module.addComment0("extract %s"%kw.sizeRef(idx))
             assert(tmpVgpr+1 != packedBits) # bad since we still need packedBits below for remainder (can't overwrite here)
             module.add(MacroInstruction("V_MAGIC_DIV", \

tensilelite/Tensile/AsmMemoryInstruction.py

@@ -22,11 +22,11 @@
 #
 ################################################################################
 
-from .Common import printExit
 from .TensileInstructions import DSStoreB8, DSStoreB8HID16, ReadWriteInstruction, \
                         DSLoadD16HIU16, DSLoadD16HIU8, \
                         DSLoadU8, DSLoadU16, DSStoreD16HIB16, \
                         DSStoreB16
+from .Common import printExit
 
 from dataclasses import dataclass, field
 from typing import Type

tensilelite/Tensile/AsmStoreState.py

@@ -22,7 +22,7 @@
 
 from .TensileInstructions import DataType
 from .AsmAddressCalculation import AddrCalculation
-from .Utils import DataDirection
+from .Common import DataDirection
 
 from math import ceil, trunc, modf
 from dataclasses import dataclass, field

tensilelite/Tensile/BenchmarkProblems.py

@@ -31,21 +31,18 @@
 from copy import deepcopy
 from pathlib import Path
 
-from . import ClientExecutable
-from . import SolutionLibrary
-from . import LibraryIO
-from . import Utils
+from . import CUSTOM_KERNEL_PATH, ClientExecutable, SolutionLibrary, LibraryIO
 from .BenchmarkStructs import BenchmarkProcess, constructForkPermutations
 from .Contractions import ProblemType as ContractionsProblemType
 from .ClientWriter import runClient, writeClientConfig, writeClientConfigIni
-from .Common import globalParameters, HR, print1, print2, \
-        printExit, printWarning, ensurePath, startTime, validParameters
 from .KernelWriterAssembly import KernelWriterAssembly
 from .SolutionStructs import Solution, ProblemType, ProblemSizes
 from .TensileCreateLibrary import copyStaticFiles, writeSolutionsAndKernels
 from .CustomKernels import getCustomKernelConfig
 from .Toolchain.Assembly import AssemblyToolchain
 from .Toolchain.Source import SourceToolchain
+from .Common import globalParameters, HR, print1, print2, \
+        printExit, printWarning, ensurePath, startTime, tqdm, state
 
 
 def generateForkedSolutions(problemType, constantParams, forkPermutations, cxxCompiler):
@@ -71,7 +68,7 @@ def generateForkedSolutions(problemType, constantParams, forkPermutations, cxxCo
     return solutions
 
 
-def getCustomKernelSolutionObj(kernelName, internalSupportParams, cxxCompiler: str, directory=globalParameters["CustomKernelDirectory"]):
+def getCustomKernelSolutionObj(kernelName, internalSupportParams, cxxCompiler: str, directory=CUSTOM_KERNEL_PATH):
     """Creates the Solution object for a custom kernel"""
     config = getCustomKernelConfig(kernelName, internalSupportParams, directory)
     return Solution(config, cxxCompiler)
@@ -115,7 +112,7 @@ def generateCustomKernelSolutions(problemType, customKernels, internalSupportPar
 
 def writeBenchmarkFiles(stepBaseDir, solutions, problemSizes, \
         biasTypeArgs, factorDimArgs, activationArgs, icacheFlushArgs, stepName, solutionSummationSizes, \
-        asmToolchain: AssemblyToolchain, srcToolchain: SourceToolchain, sourcePath: Path, buildTmpPath: Path):
+        asmToolchain: AssemblyToolchain, srcToolchain: SourceToolchain, sourcePath: Path):
     """Write all the files needed for a given benchmarking step"""
 
     ensurePath(sourcePath)
@@ -127,7 +124,7 @@ def writeBenchmarkFiles(stepBaseDir, solutions, problemSizes, \
     kernelHelperNames = set()
 
     # get unique kernels and kernel helpers
-    for solution in Utils.tqdm(solutions, "Finding unique solutions"):
+    for solution in tqdm(solutions, "Finding unique solutions"):
         solutionKernels = solution.getKernels()
         for kernel in solutionKernels:
             kName = Solution.getKeyNoInternalArgs(kernel)
@@ -144,7 +141,7 @@ def writeBenchmarkFiles(stepBaseDir, solutions, problemSizes, \
 
     kernelSerialNaming = Solution.getSerialNaming(kernels)
     kernelMinNaming = Solution.getMinNaming(kernels)
-    kernelWriterAssembly = KernelWriterAssembly(kernelMinNaming, kernelSerialNaming, srcToolchain.compiler)
+    kernelWriterAssembly = KernelWriterAssembly(kernelMinNaming, kernelSerialNaming, asmToolchain.assembler, asmToolchain.assemblerVersion)
 
     # write solution, kernels and CMake
     problemType = solutions[0]["ProblemType"]
@@ -157,9 +154,9 @@ def writeBenchmarkFiles(stepBaseDir, solutions, problemSizes, \
 
     newLibraryDir = ensurePath(sourcePath / 'library')
     newLibraryFile = os.path.join(newLibraryDir, "TensileLibrary")
-    newLibrary = SolutionLibrary.MasterSolutionLibrary.BenchmarkingLibrary(solutions, srcToolchain.compiler)
+    newLibrary = SolutionLibrary.MasterSolutionLibrary.BenchmarkingLibrary(solutions, asmToolchain.assembler)
     newLibrary.applyNaming(kernelMinNaming)
-    LibraryIO.write(newLibraryFile, Utils.state(newLibrary), globalParameters["LibraryFormat"])
+    LibraryIO.write(newLibraryFile, state(newLibrary), globalParameters["LibraryFormat"])
 
     codeObjectFiles = [os.path.relpath(f, sourcePath) \
             for f in codeObjectFiles]
@@ -316,7 +313,7 @@ def benchmarkProblemType(problemTypeConfig, problemSizeGroupConfig, problemSizeG
                     benchmarkStep.problemSizes, benchmarkStep.biasTypeArgs,    \
                     benchmarkStep.factorDimArgs, benchmarkStep.activationArgs, \
                     benchmarkStep.icacheFlushArgs, shortName, [], asmToolchain, srcToolchain, \
-                    sourcePath, buildTmpPath)
+                    sourcePath)
             # ^ this mutates solutions
 
             # write cache data

tensilelite/Tensile/ClientExecutable.py

@@ -1,6 +1,6 @@
 ################################################################################
 #
-# Copyright (C) 2022-2024 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright (C) 2022-2025 Advanced Micro Devices, Inc. All rights reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -28,8 +28,8 @@
 from typing import Optional
 from pathlib import Path
 
-from . import Common
-from .Common import globalParameters
+from . import SOURCE_PATH
+from .Common import globalParameters, print2, ClientExecutionLock, ensurePath
 
 class CMakeEnvironment:
     def __init__(self, sourceDir, buildDir, **options):
@@ -43,23 +43,23 @@ def generate(self):
         args += itertools.chain.from_iterable([ ['-D', '{}={}'.format(key, value)] for key,value in self.options.items()])
         args += [self.sourceDir]
 
-        Common.print2(' '.join(args))
-        with Common.ClientExecutionLock():
-            subprocess.check_call(args, cwd=Common.ensurePath(self.buildDir))
+        print2(' '.join(args))
+        with ClientExecutionLock(globalParameters["ClientExecutionLockPath"]):
+            subprocess.check_call(args, cwd=ensurePath(self.buildDir))
 
     def build(self):
         args = ['make', '-j']
-        Common.print2(' '.join(args))
-        with Common.ClientExecutionLock():
+        print2(' '.join(args))
+        with ClientExecutionLock(globalParameters["ClientExecutionLockPath"]):
             subprocess.check_call(args, cwd=self.buildDir)
 
     def builtPath(self, path, *paths):
         return os.path.join(self.buildDir, path, *paths)
 
 def clientExecutableEnvironment(builddir: Optional[str], cxxCompiler: str, cCompiler: str):
-    sourcedir = globalParameters["SourcePath"]
-    
-    builddir = Common.ensurePath(builddir)
+    sourcedir = SOURCE_PATH
+
+    builddir = ensurePath(builddir)
 
     options = {'CMAKE_BUILD_TYPE': globalParameters["CMakeBuildType"],
                'TENSILE_USE_MSGPACK': 'ON',

tensilelite/Tensile/ClientWriter.py

@@ -22,21 +22,21 @@
 #
 ################################################################################
 
-from pathlib import Path
-from . import ClientExecutable
-from . import LibraryIO
-from .TensileInstructions import getGfxName, DataType
-from .Common import globalParameters, ensurePath, print1, printExit, CHeader, printWarning, listToInitializer, ClientExecutionLock
-from .SolutionStructs import Problem, ProblemType, ProblemSizesMock, ProblemSizesMockDummy, ActivationArgs, BiasTypeArgs, FactorDimArgs
-from .TensileCreateLibrary import copyStaticFiles
-
 import os
 import subprocess
 import shlex
 import shutil
+
+from pathlib import Path
 from enum import Enum
 from glob import glob
 
+from . import ROOT_PATH
+from . import ClientExecutable
+from . import LibraryIO
+from .Common import globalParameters, ensurePath, print1, printExit, printWarning, ClientExecutionLock, isaToGfx
+from .SolutionStructs import ProblemType, ProblemSizesMock, ProblemSizesMockDummy, ActivationArgs, BiasTypeArgs, FactorDimArgs
+from .TensileCreateLibrary import copyStaticFiles
 from .Contractions import FreeIndex, BatchIndex
 from .Contractions import ProblemType as ContractionsProblemType
 
@@ -194,7 +194,7 @@ def runClient(libraryLogicPath, forBenchmark, enableTileSelection, cxxCompiler:
   buildPath = ensurePath(outputPath / "build")
 
   runScriptName = writeRunScript(buildPath, forBenchmark, enableTileSelection, cxxCompiler, cCompiler, buildPath, configPaths)
-  with ClientExecutionLock():
+  with ClientExecutionLock(globalParameters["ClientExecutionLockPath"]):
     process = subprocess.Popen(runScriptName, cwd=buildPath)
     process.communicate()
 
@@ -207,7 +207,7 @@ def getBuildClientLibraryScript(buildPath, libraryLogicPath, cxxCompiler):
   import io
   runScriptFile = io.StringIO()
 
-  callCreateLibraryCmd = globalParameters["ScriptPath"] + "/bin/TensileCreateLibrary"
+  callCreateLibraryCmd = ROOT_PATH + "/bin/TensileCreateLibrary"
 
   if not globalParameters["LazyLibraryLoading"]:
     callCreateLibraryCmd += " --no-lazy-library-loading"
@@ -516,7 +516,7 @@ def param(key, value):
           libraryFile = os.path.join(sourceDir, "library", libraryFilename)
         param("library-file", libraryFile)
 
-        currentGFXName = getGfxName(globalParameters["CurrentISA"])
+        currentGFXName = isaToGfx(globalParameters["CurrentISA"])
         for coFile in codeObjectFiles:
             if 'gfx' not in coFile or currentGFXName in coFile:
                 param("code-object", os.path.join(sourceDir,coFile))