diff --git a/.gitignore b/.gitignore index c1353509..40214686 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,16 @@ -.vs/* -.vscode/* +.vs/ +.vscode/ Build/* premake5.exe premake5 *.swp .cache + compile_commands.json +.clangd + +# Python +env/ +__pycache__/ +*.pyc +*.pyo diff --git a/Scripts/ConvertXmlToCsv.py b/Scripts/ConvertXmlToCsv.py old mode 100644 new mode 100755 index 8ce91cb0..b94a7928 --- a/Scripts/ConvertXmlToCsv.py +++ b/Scripts/ConvertXmlToCsv.py @@ -1,3 +1,5 @@ +#!/bin/env python3 + import xml.etree.ElementTree as ET import sys diff --git a/Scripts/GraphResults.py b/Scripts/GraphResults.py new file mode 100755 index 00000000..cfcfd08f --- /dev/null +++ b/Scripts/GraphResults.py @@ -0,0 +1,85 @@ +#!/bin/env python3 + +import glob +import sys +from typing import cast +import xml.etree.ElementTree as ElementTree + +import numpy +import pandas +from pandas import DataFrame +from seaborn import lineplot + +import matplotlib.pyplot as plt +from matplotlib.figure import Figure + + +# Change these to where you store the profiling results +RESULT_DIRECTORIES = { + 'New profile-based searcher': './logs/profiled/2080-1070/b10-n40-r100/', + # 'Old profile-based searcher': './logs/old-profiled/2080/b10-n40-r100/', + 'Random searcher': './logs/random/2080/', +} + + +def parseResults(directory: str) -> DataFrame: + outputFiles = glob.glob(directory + 'output-*.xml') + + durations = [] + for file in outputFiles: + xmlTree = ElementTree.parse(file) + results = xmlTree.findall('./Results/KernelResult') + durations.append([float(d.attrib['TotalDuration']) for d in results]) + + iterations = numpy.concatenate( + [numpy.arange(1, len(d) + 1) for d in durations] + ) + + bestDurations = [] + for duration in durations: + bestTime = numpy.empty(len(duration)) + bestTime[0] = duration[0] + + for i in range(1, len(duration)): + time = duration[i] + bestTime[i] = time if time < bestTime[i - 1] else bestTime[i - 1] + + bestDurations.append(bestTime) + + return DataFrame( + { + 'iteration': iterations, + 'time': numpy.concatenate(bestDurations), + } + ) + + +def graphResults(outputPath: str | None): + results = [] + + for name, directory in RESULT_DIRECTORIES.items(): + results.append(parseResults(directory)) + results[-1]['name'] = name + + resultsPlot = lineplot( + data=pandas.concat(results), + x='iteration', + y='time', + hue='name', + ) + + if outputPath is None: + plt.show(block=True) + return + + figure = cast(Figure, resultsPlot.get_figure()) + figure.set_dpi(150) + figure.set_size_inches(19.20, 10.80) + + figure.savefig(outputPath) + plt.clf() + + +if __name__ == '__main__': + outputPath = sys.argv[1] if len(sys.argv) == 2 else None + graphResults(outputPath) diff --git a/Scripts/NewProfileSearcher/.gitignore b/Scripts/NewProfileSearcher/.gitignore new file mode 100644 index 00000000..6ec15e00 --- /dev/null +++ b/Scripts/NewProfileSearcher/.gitignore @@ -0,0 +1 @@ +pyktt.so diff --git a/Scripts/NewProfileSearcher/CudaKernel.cu b/Scripts/NewProfileSearcher/CudaKernel.cu new file mode 100644 index 00000000..999e81d2 --- /dev/null +++ b/Scripts/NewProfileSearcher/CudaKernel.cu @@ -0,0 +1,47 @@ +extern "C" __global__ void directCoulombSum(const float4* atomInfo, const float* atomInfoX, const float* atomInfoY, const float* atomInfoZ, const float* atomInfoW, int numberOfAtoms, float gridSpacing, int gridSize, float* energyGrid) +{ + int xIndex = blockIdx.x*blockDim.x + threadIdx.x; + int yIndex = blockIdx.y*blockDim.y + threadIdx.y; + int zIndex = (blockIdx.z*blockDim.z + threadIdx.z) * Z_ITERATIONS; + + if ((xIndex >= gridSize) || (yIndex >= gridSize) || (zIndex >= gridSize)) + return; + + int sliceOffset = gridSize * gridSize; + int outIndex = sliceOffset*zIndex + gridSize*yIndex + xIndex; + + float coordX = gridSpacing * xIndex; + float coordY = gridSpacing * yIndex; + float coordZ = gridSpacing * zIndex; + + float energyValue[Z_ITERATIONS]; + for (int i = 0; i < Z_ITERATIONS; i++) + energyValue[i] = 0.0f; + + for (int i = 0; i < numberOfAtoms / VECTOR_SIZE; i++) + { + #if USE_SOA == 1 + float dX = coordX - atomInfoX[i]; + float dY = coordY - atomInfoY[i]; + float dZ = coordZ - atomInfoZ[i]; + float w = atomInfoW[i]; + #else + float dX = coordX - atomInfo[i].x; + float dY = coordY - atomInfo[i].y; + float dZ = coordZ - atomInfo[i].z; + float w = atomInfo[i].w; + #endif /* USE_SOA */ + #if INNER_UNROLL_FACTOR > 0 + #pragma unroll INNER_UNROLL_FACTOR + #endif + for (int j = 0; j < Z_ITERATIONS; j++) { + float partialResult = rsqrt(dX * dX + dY * dY + dZ*dZ); + energyValue[j] += w * partialResult; + dZ += gridSpacing; + } + } + + for (int i = 0; i < Z_ITERATIONS; i++) + if (zIndex + i < gridSize) + energyGrid[outIndex + sliceOffset*i] = energyValue[i]; +} diff --git a/Scripts/NewProfileSearcher/ExampleUsage.py b/Scripts/NewProfileSearcher/ExampleUsage.py new file mode 100755 index 00000000..c9a3a8f7 --- /dev/null +++ b/Scripts/NewProfileSearcher/ExampleUsage.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 + +import os +import sys +import glob +from pathlib import Path + +from ProfileBasedSearcher import ProfileBasedSearcher +from modules.logging import LoggingLevel +from modules.info import BatchInfo, ModelInfo + +import lib.pyktt as ktt +import numpy + +LOG_DIRECTORY = './logs/profiled/' + + +def getLogPath(modelInfo: ModelInfo, batchInfo: BatchInfo) -> str: + runningGpu, profilingGpu = ( + Path(modelInfo.counterPath).name.split('_')[0].split('-') + ) + + logPrefix = ( + LOG_DIRECTORY + + f'{runningGpu}-{profilingGpu}/' + + f'b{batchInfo.batchSize}-n{batchInfo.neighborSize}-' + + f'r{batchInfo.randomSize}/' + ) + + # logPrefix = LOG_DIRECTORY # TEST + existingLogs = glob.glob(logPrefix + '*.xml') + return logPrefix + f'output-{len(existingLogs) + 1}' + + +def runTuning(deviceIndex: int, kernelFile: str): + numberOfAtoms = 256 + gridSize = 256 + gridSpacing = 0.5 + gridDimensions = ktt.DimensionVector(gridSize, gridSize, gridSize) + blockDimensions = ktt.DimensionVector(1, 1) + + aX = 100.0 * numpy.random.rand(numberOfAtoms).astype('f') + aY = 100.0 * numpy.random.rand(numberOfAtoms).astype('f') + aZ = 100.0 * numpy.random.rand(numberOfAtoms).astype('f') + aW = 100.0 * numpy.random.rand(numberOfAtoms).astype('f') + aAll = numpy.zeros(numberOfAtoms * 4, dtype=numpy.single) + for i in range(numberOfAtoms): + aAll[4 * i] = aX[i] + aAll[4 * i + 1] = aY[i] + aAll[4 * i + 2] = aZ[i] + aAll[4 * i + 3] = aW[i] + energyGrid = numpy.zeros(gridSize * gridSize * gridSize, dtype=numpy.single) + + tuner = ktt.Tuner(0, deviceIndex, ktt.ComputeApi.CUDA) + tuner.SetCompilerOptions('-use_fast_math') + tuner.SetTimeUnit(ktt.TimeUnit.Microseconds) + tuner.SetProfiling(False) + + definition = tuner.AddKernelDefinitionFromFile( + 'directCoulombSum', kernelFile, gridDimensions, blockDimensions + ) + + aXId = tuner.AddArgumentVectorFloat(aX, ktt.ArgumentAccessType.ReadOnly) + aYId = tuner.AddArgumentVectorFloat(aY, ktt.ArgumentAccessType.ReadOnly) + aZId = tuner.AddArgumentVectorFloat(aZ, ktt.ArgumentAccessType.ReadOnly) + aWId = tuner.AddArgumentVectorFloat(aW, ktt.ArgumentAccessType.ReadOnly) + aAllId = tuner.AddArgumentVectorFloat(aAll, ktt.ArgumentAccessType.ReadOnly) + numberOfAtomsId = tuner.AddArgumentScalarInt(numberOfAtoms) + gridSpacingId = tuner.AddArgumentScalarFloat(gridSpacing) + gridSizeId = tuner.AddArgumentScalarInt(gridSize) + energyGridId = tuner.AddArgumentVectorFloat( + energyGrid, ktt.ArgumentAccessType.WriteOnly + ) + tuner.SetArguments( + definition, + [ + aAllId, + aXId, + aYId, + aZId, + aWId, + numberOfAtomsId, + gridSpacingId, + gridSizeId, + energyGridId, + ], + ) + + kernel = tuner.CreateSimpleKernel('directCoulombSum', definition) + + tuner.AddParameter(kernel, 'WORK_GROUP_SIZE_X', [16, 32]) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Local, + ktt.ModifierDimension.X, + 'WORK_GROUP_SIZE_X', + ktt.ModifierAction.Multiply, + ) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Global, + ktt.ModifierDimension.X, + 'WORK_GROUP_SIZE_X', + ktt.ModifierAction.Divide, + ) + tuner.AddParameter(kernel, 'WORK_GROUP_SIZE_Y', [1, 2, 4, 8]) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Local, + ktt.ModifierDimension.Y, + 'WORK_GROUP_SIZE_Y', + ktt.ModifierAction.Multiply, + ) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Global, + ktt.ModifierDimension.Y, + 'WORK_GROUP_SIZE_Y', + ktt.ModifierAction.Divide, + ) + tuner.AddParameter(kernel, 'WORK_GROUP_SIZE_Z', [1]) + tuner.AddParameter(kernel, 'Z_ITERATIONS', [1, 2, 4, 8, 16, 32]) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Global, + ktt.ModifierDimension.Z, + 'Z_ITERATIONS', + ktt.ModifierAction.Divide, + ) + tuner.AddParameter(kernel, 'INNER_UNROLL_FACTOR', [0, 1, 2, 4, 8, 16, 32]) + tuner.AddParameter(kernel, 'USE_CONSTANT_MEMORY', [0]) + tuner.AddParameter(kernel, 'USE_SOA', [0, 1]) + tuner.AddParameter(kernel, 'VECTOR_SIZE', [1]) + tuner.AddConstraint( + kernel, + ['INNER_UNROLL_FACTOR', 'Z_ITERATIONS'], + lambda vector: vector[0] < vector[1], + ) + + tuner.AddConstraint( + kernel, + ['WORK_GROUP_SIZE_X', 'WORK_GROUP_SIZE_Y'], + lambda vector: vector[0] * vector[1] >= 64, + ) + + # Make tuner use the profiling searcher + searcher = ProfileBasedSearcher() + tuner.SetSearcher(kernel, searcher) + + modelInfo = ModelInfo( + deltaPath='./models/1070_all_XGBRegressor.sav', + spacePath='./models/1070_coulomb_XGBRegressor.sav', + counterPath='./models/2080-1070_all_XGBRegressor.sav', + ) + batchInfo = BatchInfo(batchSize=10, neighborSize=40, randomSize=100) + searcher.Configure(tuner, modelInfo, batchInfo, LoggingLevel.DEBUG) + + # Begin tuning utilizing the stop condition implemented in Python + results = tuner.Tune(kernel, ktt.ConfigurationCount(50)) + + logPath = getLogPath(modelInfo, batchInfo) + os.makedirs(Path(logPath).parent, exist_ok=True) + + tuner.SaveResults(results, logPath, ktt.OutputFormat.XML) + + +if __name__ == '__main__': + deviceIndex = int(sys.argv[1]) if len(sys.argv) >= 2 else 0 + kernelFile = sys.argv[2] if len(sys.argv) >= 3 else './CudaKernel.cu' + + runTuning(deviceIndex, kernelFile) diff --git a/Scripts/NewProfileSearcher/ProfileBasedSearcher.py b/Scripts/NewProfileSearcher/ProfileBasedSearcher.py new file mode 100644 index 00000000..2a7735b6 --- /dev/null +++ b/Scripts/NewProfileSearcher/ProfileBasedSearcher.py @@ -0,0 +1,365 @@ +from modules.logging import Logger, LoggingLevel +import numpy +from numpy.typing import NDArray +from pandas import DataFrame, Series + +from modules.counter_mappings import ( + CounterType, + GetCounterType, + CounterHeader, + ParallelismHeader, + ProfilingCounter, +) +from lib.pyktt import KernelConfiguration, Searcher, KernelResult + +from modules.info import BatchInfo, ModelInfo +from modules.tuning_space import TuningSpace +from modules.model import loadModel + +# Profiler configuration (might move into the class?) +SCORE_EXPONENT = 7 +SCORE_THRESHOLD = 0.425 + +NEIGHBOUR_DISTANCE = 2 + +Batch = list[KernelConfiguration] + + +class ProfileBasedSearcher(Searcher): + batch: Batch = [] + currentConfiguration: KernelConfiguration = KernelConfiguration() + + # Best configuration information for the current batch + bestConfiguration: KernelConfiguration | None = None + bestDuration = -1 + + def __init__(self) -> None: + super().__init__() + + def Configure( + self, + tuner, + modelInfo: ModelInfo, + batchInfo: BatchInfo, + loggingLevel: LoggingLevel, + ): + self.tuner = tuner + self.batchInfo = batchInfo + self.logger = Logger(loggingLevel, 'Searcher:') + + self.spaceModel = loadModel(modelInfo.spacePath) + self.counterModel = loadModel(modelInfo.counterPath) + self.deltaModel = loadModel(modelInfo.deltaPath) + + def OnInitialize(self): + candidateBatch = [] + self._FillBatchRandom(candidateBatch, self.batchInfo.randomSize) + + tuningSpace = self._BatchToSpacePredicted(candidateBatch) + scores = self._ScoreTuningSpace(tuningSpace, tuningSpace.counters[0]) + self.batch = self._SelectBatchWeighted(candidateBatch, scores) + + self.currentConfiguration = self.batch.pop() + + def CalculateNextConfiguration(self, previousResult: KernelResult) -> bool: + self._UpdateBestConfiguration(previousResult) + + if len(self.batch) != 0: + self.currentConfiguration = self.batch.pop() + return True + + # unlikely, the batch is emptied but no configuration ran properly + if self.bestConfiguration is None: + self.logger.Warning( + 'Batch was emptied but no configuration ran properly' + ) + + self._FillBatchRandom(self.batch, self.batchInfo.batchSize) + self.currentConfiguration = self.batch.pop() + return True + + if self.bestDuration != -1: + self.logger.Info( + 'Rerunning the best configuration of the batch with profiling on' + ) + self.currentConfiguration = self.bestConfiguration + self.bestDuration = -1 + + self.tuner.SetProfiling(True) + return True + + if not previousResult.IsValid(): + self.logger.Error('Profiling run failed, bailing out') + self.tuner.SetProfiling(False) + return False + + # made from neighbouring and random configurations + candidateBatch = self._GetCandidateBatch() + + # we only do the profiling in case the batch is bigger than the batch size + if len(candidateBatch) <= self.batchInfo.batchSize: + self.logger.Info( + 'Too little configurations in the candidate batch. ' + + 'Skipping profiling the batch' + ) + + # TODO(?) do the profiling anyway, sort from best to worst or something + self.batch = candidateBatch + self.currentConfiguration = self.batch.pop() + self.bestConfiguration = None + self.tuner.SetProfiling(False) + + return True + + candidateSpace = self._BatchToSpacePredicted(candidateBatch) + + counters = self._GetCounters(previousResult) + predictedCounters = self.counterModel.predict(counters) + + candidateScores = self._ScoreTuningSpace( + candidateSpace, predictedCounters + ) + + self.batch = self._SelectBatchWeighted(candidateBatch, candidateScores) + self.currentConfiguration = self.batch.pop() + + self.bestConfiguration = None + self.tuner.SetProfiling(False) + + return True + + def GetCurrentConfiguration(self) -> KernelConfiguration: + return self.currentConfiguration + + # Private functions + + def _SelectBatchWeighted(self, batch: Batch, scores: NDArray) -> Batch: + selected = [] + + for _ in range(self.batchInfo.batchSize): + index = self._WeightedRandomStep(scores) + selected.append(batch[index]) + + scores[index] = 0.0 + + selected.reverse() # for pops to work efficiently, taking the best configs + return selected + + def _ScoreTuningSpace( + self, space: TuningSpace, currentCounters: NDArray + ) -> NDArray: + counterDeltas = currentCounters - space.counters + timeDeltas = self.deltaModel.predict(counterDeltas).reshape(-1, 1) + + minDelta, maxDelta = timeDeltas.min(), timeDeltas.max() + scores = (timeDeltas - minDelta) / (maxDelta - minDelta) + + scores[numpy.isnan(scores)] = 1.0 # edge case if the model is bad + scores = numpy.power(scores, SCORE_EXPONENT) + scores[scores < SCORE_THRESHOLD] = 0.00001 + + return scores + + def _GetCounters(self, results: KernelResult) -> NDArray: + kernelResults = results.GetResults() + result = kernelResults[0] + + if len(kernelResults) != 1: + self.logger.Warning( + 'Seems like the tuner is configured to run multiple kernels. ' + + "The profile-based searcher doesn't multiple " + + 'kernels, using only results from kernel 0.' + ) + + counters = self._ExtractCounters(result) + self.logger.Debug(f'Found raw counters: {counters.shape[1]}') + + artificialCounters = self._GenerateArtificialCounters(counters) + self.logger.Debug( + f'Generated artificial counters: {artificialCounters.shape[1]}' + ) + + stressCounters = counters.loc[ + :, + [GetCounterType(c) == CounterType.Stress for c in counters.columns], + ] + self.logger.Debug(f'Stress counters: {stressCounters.shape[1]}') + + relevantCounters = stressCounters.join(artificialCounters) + relevantCounters = relevantCounters.reindex( + sorted(relevantCounters.columns), axis=1 + ) + + self.logger.Debug( + f'Extracted relevant counters: {relevantCounters.shape[1]}' + ) + return relevantCounters.to_numpy() + + def _GenerateArtificialCounters(self, counters: DataFrame) -> DataFrame: + dramUtilization = _getRWUtilization( + counters, + ProfilingCounter.DRAM_RT, + ProfilingCounter.DRAM_WT, + ProfilingCounter.DRAM_U, + ) + + l2Utilization = _getRWUtilization( + counters, + ProfilingCounter.L2_RT, + ProfilingCounter.L2_WT, + ProfilingCounter.L2_U, + ) + + smUtilCounter = ( + ProfilingCounter.SHR_U + if ProfilingCounter.SHR_U in counters.columns + else ProfilingCounter.SM_E + ) + smUtilization = _getRWUtilization( + counters, + ProfilingCounter.SHR_LT, + ProfilingCounter.SHR_WT, + smUtilCounter, + ) + + ccMajor = ( + self.tuner.GetCurrentDeviceInfo().GetCudaComputeCapabilityMajor() + ) + ccMinor = ( + self.tuner.GetCurrentDeviceInfo().GetCudaComputeCapabilityMinor() + ) + + converter = ParallelismHeader(ccMajor, ccMinor).ConvertValue + parallelism = counters[ProfilingCounter.GLOBAL_SIZE].apply(converter) + + # TODO: make these optional, since some counters might not exist + return DataFrame( + { + ProfilingCounter.DRAM_RT_U: dramUtilization['read'], + ProfilingCounter.DRAM_WT_U: dramUtilization['write'], + ProfilingCounter.L2_RT_U: l2Utilization['read'], + ProfilingCounter.L2_WT_U: l2Utilization['write'], + ProfilingCounter.SHR_RT_U: smUtilization['read'], + ProfilingCounter.SHR_WT_U: smUtilization['write'], + ProfilingCounter.PARALLELISM: parallelism, + } + ) + + def _ExtractCounters(self, result) -> DataFrame: + counters = {} + + for counter in result.GetProfilingData().GetCounters(): + counterType = counter.GetType().name + if counterType != 'Double': + continue + + header = CounterHeader(counter.GetName()) + if header.name == ProfilingCounter.UNKNOWN: + continue + + counters[header.name] = [ + header.ConvertValue(counter.GetValueDouble()) + ] + + globalSize = result.GetGlobalSize().GetTotalSize() + localSize = result.GetLocalSize().GetTotalSize() + + # globalSize * localSize, huh ? okay + counters[ProfilingCounter.GLOBAL_SIZE] = globalSize * localSize + counters[ProfilingCounter.LOCAL_SIZE] = localSize + return DataFrame(counters) + + def _BatchToSpacePredicted(self, batch: Batch) -> TuningSpace: + parameterNames: list[str] = [p.GetName() for p in batch[0].GetPairs()] + parameterData = numpy.empty((len(batch), len(parameterNames))) + + for row, configuration in enumerate(batch): + for col, pair in enumerate(configuration.GetPairs()): + parameterData[row, col] = pair.GetValue() + + # Sort the parameter names for consistency with the models + parameterSpace = DataFrame(data=parameterData, columns=parameterNames) + parameterSpace = parameterSpace.reindex(sorted(parameterNames), axis=1) + + counterSpace = self.spaceModel.predict(parameterSpace.to_numpy()) + return TuningSpace(parameterSpace, counterSpace) + + def _GetCandidateBatch(self) -> Batch: + self.logger.Debug('Generating candidate batch') + + batch = self.GetNeighbourConfigurations( + self.bestConfiguration, + NEIGHBOUR_DISTANCE, + self.batchInfo.neighborSize, + ) + batch = self._GetUniqueConfigurations(batch) + self.logger.Debug(f'Found neighbouring configurations: {len(batch)}') + + size = self.batchInfo.neighborSize + self.batchInfo.randomSize + self._FillBatchRandom(batch, size) + + self.logger.Debug(f'Generated candidate batch of size: {len(batch)}') + return batch + + def _UpdateBestConfiguration(self, previousResult: KernelResult): + if not previousResult.IsValid(): + return + + duration = previousResult.GetKernelDuration() + + if self.bestConfiguration is None or duration < self.bestDuration: + self.bestConfiguration = self.currentConfiguration + self.bestDuration = duration + + def _FillBatchRandom(self, batch: Batch, expectedSize: int) -> None: + size = min(expectedSize, self.GetUnexploredConfigurationsCount()) + + while len(batch) < size: + for _ in range(len(batch), size): + batch.append(self.GetRandomConfiguration()) + + batch = self._GetUniqueConfigurations(batch) + + def _GetUniqueConfigurations(self, configurations: Batch) -> Batch: + uniqueIndices = set([self.GetIndex(c) for c in configurations]) + return [self.GetConfiguration(i) for i in uniqueIndices] + + def _WeightedRandomStep(self, scores: NDArray) -> int: + """ + Returns an index of where in the tuning space the next step is. + The value of the index is random, influenced by the weights in + `score_distribution` + """ + + # .sum() and .cumsum()[-1] are different, so + # cumulative sum is used for the random value + scoreCumsum = numpy.cumsum(scores) + randomValue = numpy.random.random() * scoreCumsum[-1] + indices = numpy.argwhere(randomValue < scoreCumsum) + if indices.shape[0] == 0: # should be unreachable but left in here + self.logger.Error('Floating point addition bug happened again') + exit(-1) # TODO: just take a random point instead + + return indices[0, 0] + + +# Other helper functions + + +def _getRWUtilization( + counters: DataFrame, + readCounter: ProfilingCounter, + writeCounter: ProfilingCounter, + utilizationCounter: ProfilingCounter, +) -> dict[str, Series]: + reads = counters[readCounter] + writes = counters[writeCounter] + total = reads + writes + total[total == 0] = 1 # prevent NaNs + + utilization = counters[utilizationCounter] + + readUtilization = (reads / total) * utilization + writeUtilization = (writes / total) * utilization + + return {'read': readUtilization, 'write': writeUtilization} diff --git a/Scripts/NewProfileSearcher/README.md b/Scripts/NewProfileSearcher/README.md new file mode 100644 index 00000000..18165857 --- /dev/null +++ b/Scripts/NewProfileSearcher/README.md @@ -0,0 +1,69 @@ +# Profile-based searcher + +This searcher uses profiling counters along with ML models to more effectively +navigate through the tuning space. See `./ExampleUsage.py` on how +to use the searcher. It's possible to compare it with the results +of the random search with `./GraphResults.py [output-graph]`. + +The searcher only supports tuning of CUDA single kernels. + +## Installing dependencies + +Obvious dependency is `pyktt`: compile ktt with profiling and the python module +(flags `--profiling=cupti[-legacy] --python`), put it into the folder with the script. + +### Other library dependencies + +> Before installing it is recommended to set up a virtual enviroment. + +Dependencies for the newer GPUs (starting from Turing): +```bash +pip isntall cupy-cuda13x +pip install -r requirements/common.txt +``` + + +### Older GPUs (Volta and older) + +> For these GPUs, the installed NVIDIA driver on linux **must** be +> of version `<= 575xx` for profiling to work. Latest driver supporting +> these architectures (`580xx`) can run CUDA, but cannot collect the +> profiling counters. On modern systems it's next to impossible +> to use the older driver.. + +Dependencies for Volta and older architectures: +```bash +pip isntall cupy-cuda12x +pip install -r requirements/common.txt +``` + +### Pytorch + +Pytorch is *not required* to run the code, buuut if you want to use the neural +models, uncomment code in `modules/model.py` and install the library: + +```bash +pip install -r requirements/cu130-torch.txt # new GPUs +pip install -r requirements/cu126-torch.txt # old GPUs (Volta and older) +``` + +## Batching + +Profiling is expensive, so a batching system is implemented. +The searcher takes in a `BatchInfo` object, with 3 parameters: +`batchSize`, `randomSize`, `neighborSize`. `randomSize + neighborSize` +is the amount of configurations scored every profiling pass. For +the profiling to happen this value **must** be larger than `batchSize`. +It can be relatively large, since the scoring process is a lot cheaper +in comparison to profiling itself. + +The code does the profiling every `batchSize` +configurations, smaller value introduces lots of profiling overhead, +but makes use of the profiling more, which might lead to faster +convergence (lower amount of iterations). + +## Models + +Generate the model files via the code from [this repo](https://gitlab.fi.muni.cz/xratushn/ktt-model). +Link them in the searcher (it takes a `ModelInfo` object in with the paths to the models). + diff --git a/Scripts/NewProfileSearcher/models/1070_all_XGBRegressor.sav b/Scripts/NewProfileSearcher/models/1070_all_XGBRegressor.sav new file mode 120000 index 00000000..b28657d6 --- /dev/null +++ b/Scripts/NewProfileSearcher/models/1070_all_XGBRegressor.sav @@ -0,0 +1 @@ +/home/kat/Code/kat-system/generated-models/delta/1070_all_XGBRegressor.sav \ No newline at end of file diff --git a/Scripts/NewProfileSearcher/models/1070_coulomb_XGBRegressor.sav b/Scripts/NewProfileSearcher/models/1070_coulomb_XGBRegressor.sav new file mode 120000 index 00000000..6833748c --- /dev/null +++ b/Scripts/NewProfileSearcher/models/1070_coulomb_XGBRegressor.sav @@ -0,0 +1 @@ +/home/kat/Code/kat-system/generated-models/space/1070_coulomb_XGBRegressor.sav \ No newline at end of file diff --git a/Scripts/NewProfileSearcher/models/2080-1070_all_XGBRegressor.sav b/Scripts/NewProfileSearcher/models/2080-1070_all_XGBRegressor.sav new file mode 120000 index 00000000..e0907a76 --- /dev/null +++ b/Scripts/NewProfileSearcher/models/2080-1070_all_XGBRegressor.sav @@ -0,0 +1 @@ +/home/kat/Code/kat-system/generated-models/counter/2080-1070_all_XGBRegressor.sav \ No newline at end of file diff --git a/Scripts/NewProfileSearcher/modules/__init__.py b/Scripts/NewProfileSearcher/modules/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/Scripts/NewProfileSearcher/modules/counter_mappings.py b/Scripts/NewProfileSearcher/modules/counter_mappings.py new file mode 100644 index 00000000..cf4d20ca --- /dev/null +++ b/Scripts/NewProfileSearcher/modules/counter_mappings.py @@ -0,0 +1,292 @@ +import re +from collections.abc import Callable +from enum import Enum + + +class CounterType(Enum): + Stress = 0 + Operations = 1 + + +class ProfilingCounter(Enum): + UNKNOWN = 'UNKNOWN' + + # Hardware counters + DRAM_RT = 'DRAM_RT' + DRAM_WT = 'DRAM_WT' + L2_RT = 'L2_RT' + L2_WT = 'L2_WT' + TEX_RWT = 'TEX_RWT' + LOC_O = 'LOC_O' + SHR_LT = 'SHR_LT' + SHR_WT = 'SHR_WT' + INST_F32 = 'INST_F32' + INST_F64 = 'INST_F64' + INST_INT = 'INST_INT' + INST_MISC = 'INST_MISC' + INST_LDST = 'INST_LDST' + INST_CONT = 'INST_CONT' + INST_BCONV = 'INST_BCONV' + INST_EXE = 'INST_EXE' + INST_ISSUE_U = 'INST_ISSUE_U' + DRAM_U = 'DRAM_U' + L2_U = 'L2_U' + TEX_U = 'TEX_U' + SHR_U = 'SHR_U' + SM_E = 'SM_E' + WARP_E = 'WARP_E' + WARP_NP_E = 'WARP_NP_E' + + # Additional counters + SM_WARP_U = 'SM_WARP_U' + FMA_U = 'FMA_U' + FP64_E = 'FP64_E' + XU_E = 'XU_E' + LSU_E = 'LSU_E' + TEX_E = 'TEX_E' + FU_CF_U = 'FU_CF_U' + FU_RW_U = 'FU_RW_U' + FU_TEX_U = 'FU_TEX_U' + SRM_E = 'SRM_E' + SP_E = 'SP_E' + DP_E = 'DP_E' + + # Compiler counters + GLOBAL_SIZE = 'GLOBAL_SIZE' + LOCAL_SIZE = 'LOCAL_SIZE' + LOCAL_MEMORY_SIZE = 'LOCAL_MEMORY_SIZE' + MAX_WORK_GROUP_SIZE = 'MAX_WORK_GROUP_SIZE' + PRIVATE_MEMORY_SIZE = 'PRIVATE_MEMORY_SIZE' + CONST_MEMORY_SIZE = 'CONST_MEMORY_SIZE' + REGISTERS_COUNT = 'REGISTERS_COUNT' + + # Artificial counters + PARALLELISM = 'PARALLELISM' + DRAM_WT_U = 'DRAM_WT_U' + DRAM_RT_U = 'DRAM_RT_U' + + L2_WT_U = 'L2_WT_U' + L2_RT_U = 'L2_RT_U' + + SHR_WT_U = 'SHR_WT_U' + SHR_RT_U = 'SHR_RT_U' + + def __lt__(self, other: 'ProfilingCounter'): # for sorting + return self.value < other.value + + +# Vim macros are GOOD +_counterNameMappings = { + 'Global size': ProfilingCounter.GLOBAL_SIZE, + 'Local size': ProfilingCounter.LOCAL_SIZE, + 'Local memory size': ProfilingCounter.LOCAL_MEMORY_SIZE, + 'Maximum work-group size': ProfilingCounter.MAX_WORK_GROUP_SIZE, + 'Private memory size': ProfilingCounter.PRIVATE_MEMORY_SIZE, + 'Constant memory size': ProfilingCounter.CONST_MEMORY_SIZE, + 'Registers count': ProfilingCounter.REGISTERS_COUNT, + 'dram_read_transactions': ProfilingCounter.DRAM_RT, + 'dram__sectors_read.sum': ProfilingCounter.DRAM_RT, + 'dram_write_transactions': ProfilingCounter.DRAM_WT, + 'dram__sectors_write.sum': ProfilingCounter.DRAM_WT, + 'l2_read_transactions': ProfilingCounter.L2_RT, + 'lts__t_sectors_op_read.sum': ProfilingCounter.L2_RT, + 'l2_write_transactions': ProfilingCounter.L2_WT, + 'lts__t_sectors_op_write.sum': ProfilingCounter.L2_WT, + 'tex_cache_transactions': ProfilingCounter.TEX_RWT, + 'l1tex__t_requests_pipe_lsu_mem_global_op_ld.sum': ProfilingCounter.TEX_RWT, + 'local_memory_overhead': ProfilingCounter.LOC_O, + 'l1tex__t_sectors_pipe_lsu_mem_local_op_st.sum': ProfilingCounter.LOC_O, + 'shared_load_transactions': ProfilingCounter.SHR_LT, + 'l1tex__data_pipe_lsu_wavefronts_mem_shared_op_ld.sum': ProfilingCounter.SHR_LT, + 'shared_store_transactions': ProfilingCounter.SHR_WT, + 'l1tex__data_pipe_lsu_wavefronts_mem_shared_op_st.sum': ProfilingCounter.SHR_WT, + 'inst_fp_32': ProfilingCounter.INST_F32, + 'smsp__sass_thread_inst_executed_op_fp32_pred_on.sum': ProfilingCounter.INST_F32, + 'inst_fp_64': ProfilingCounter.INST_F64, + 'smsp__sass_thread_inst_executed_op_fp64_pred_on.sum': ProfilingCounter.INST_F64, + 'inst_integer': ProfilingCounter.INST_INT, + 'smsp__sass_thread_inst_executed_op_integer_pred_on.sum': ProfilingCounter.INST_INT, + 'inst_misc': ProfilingCounter.INST_MISC, + 'smsp__sass_thread_inst_executed_op_misc_pred_on.sum': ProfilingCounter.INST_MISC, + 'inst_compute_ld_st': ProfilingCounter.INST_LDST, + 'smsp__sass_thread_inst_executed_op_memory_pred_on.sum': ProfilingCounter.INST_LDST, + 'inst_control': ProfilingCounter.INST_CONT, + 'smsp__sass_thread_inst_executed_op_control_pred_on.sum': ProfilingCounter.INST_CONT, + 'inst_bit_convert': ProfilingCounter.INST_BCONV, + 'smsp__sass_thread_inst_executed_op_conversion_pred_on.sum': ProfilingCounter.INST_BCONV, + 'inst_executed': ProfilingCounter.INST_EXE, + 'smsp__inst_executed.sum': ProfilingCounter.INST_EXE, + 'issue_slot_utilization': ProfilingCounter.INST_ISSUE_U, + 'smsp__issue_active.avg.pct_of_peak_sustained_active': ProfilingCounter.INST_ISSUE_U, + 'dram_utilization': ProfilingCounter.DRAM_U, + 'dram__throughput.avg.pct_of_peak_sustained_elapsed': ProfilingCounter.DRAM_U, + 'l2_utilization': ProfilingCounter.L2_U, + 'lts__t_sectors.avg.pct_of_peak_sustained_elapsed': ProfilingCounter.L2_U, + 'tex_utilization': ProfilingCounter.TEX_U, + 'l1tex__t_requests_pipe_lsu_mem_global_op_ld' + + '.avg.pct_of_peak_sustained_active': ProfilingCounter.TEX_U, + 'shared_utilization': ProfilingCounter.SHR_U, + 'l1tex__data_pipe_lsu_wavefronts_mem_shared' + + '.avg.pct_of_peak_sustained_elapsed': ProfilingCounter.SHR_U, + 'sm_efficiency': ProfilingCounter.SM_E, + 'smsp__cycles_active.avg.pct_of_peak_sustained_elapsed': ProfilingCounter.SM_E, + 'warp_execution_efficiency': ProfilingCounter.WARP_E, + 'smsp__thread_inst_executed_per_inst_executed.ratio': ProfilingCounter.WARP_E, + 'warp_nonpred_execution_efficiency': ProfilingCounter.WARP_NP_E, + 'smsp__thread_inst_executed_per_inst_executed.pct': ProfilingCounter.WARP_NP_E, + # Additional counters (not from the paper) + 'sm__warps_active.avg.pct_of_peak_sustained_active': ProfilingCounter.SM_WARP_U, + 'smsp__pipe_fma_cycles_active.avg.pct_of_peak_sustained_active': ProfilingCounter.FMA_U, + 'smsp__inst_executed_pipe_fp64.avg.pct_of_peak_sustained_active': ProfilingCounter.FP64_E, + 'smsp__inst_executed_pipe_xu.avg.pct_of_peak_sustained_active': ProfilingCounter.XU_E, + 'smsp__inst_executed_pipe_lsu.avg.pct_of_peak_sustained_active': ProfilingCounter.LSU_E, + 'smsp__inst_executed_pipe_tex.avg.pct_of_peak_sustained_active': ProfilingCounter.TEX_E, + 'cf_fu_utilization': ProfilingCounter.FU_CF_U, + 'ldst_fu_utilization': ProfilingCounter.FU_RW_U, + 'tex_fu_utilization': ProfilingCounter.FU_TEX_U, + 'shared_efficiency': ProfilingCounter.SRM_E, + 'flop_sp_efficiency': ProfilingCounter.SP_E, + 'flop_dp_efficiency': ProfilingCounter.DP_E, + # Artificial + 'parallelism': ProfilingCounter.PARALLELISM, +} + + +_counterTypeMappings: dict[ProfilingCounter, CounterType] = { + # Doesn't matter, really + ProfilingCounter.UNKNOWN: CounterType.Operations, + # Hardware counters + ProfilingCounter.DRAM_RT: CounterType.Operations, + ProfilingCounter.DRAM_WT: CounterType.Operations, + ProfilingCounter.L2_RT: CounterType.Operations, + ProfilingCounter.L2_WT: CounterType.Operations, + ProfilingCounter.TEX_RWT: CounterType.Operations, + ProfilingCounter.LOC_O: CounterType.Operations, + ProfilingCounter.SHR_LT: CounterType.Operations, + ProfilingCounter.SHR_WT: CounterType.Operations, + ProfilingCounter.INST_F32: CounterType.Operations, + ProfilingCounter.INST_F64: CounterType.Operations, + ProfilingCounter.INST_INT: CounterType.Operations, + ProfilingCounter.INST_MISC: CounterType.Operations, + ProfilingCounter.INST_LDST: CounterType.Operations, + ProfilingCounter.INST_CONT: CounterType.Operations, + ProfilingCounter.INST_BCONV: CounterType.Operations, + ProfilingCounter.INST_EXE: CounterType.Operations, + ProfilingCounter.INST_ISSUE_U: CounterType.Stress, + ProfilingCounter.DRAM_U: CounterType.Stress, + ProfilingCounter.L2_U: CounterType.Stress, + ProfilingCounter.TEX_U: CounterType.Stress, + ProfilingCounter.SHR_U: CounterType.Stress, + ProfilingCounter.SM_E: CounterType.Stress, + ProfilingCounter.WARP_E: CounterType.Stress, + ProfilingCounter.WARP_NP_E: CounterType.Stress, + # Compiler counters + ProfilingCounter.GLOBAL_SIZE: CounterType.Operations, + ProfilingCounter.LOCAL_SIZE: CounterType.Operations, + ProfilingCounter.LOCAL_MEMORY_SIZE: CounterType.Operations, + ProfilingCounter.MAX_WORK_GROUP_SIZE: CounterType.Operations, + ProfilingCounter.PRIVATE_MEMORY_SIZE: CounterType.Operations, + ProfilingCounter.CONST_MEMORY_SIZE: CounterType.Operations, + ProfilingCounter.REGISTERS_COUNT: CounterType.Operations, + # Additional counters (not from the paper) + ProfilingCounter.SM_WARP_U: CounterType.Stress, + ProfilingCounter.FMA_U: CounterType.Stress, + ProfilingCounter.FP64_E: CounterType.Stress, + ProfilingCounter.XU_E: CounterType.Stress, + ProfilingCounter.LSU_E: CounterType.Stress, + ProfilingCounter.TEX_E: CounterType.Stress, + ProfilingCounter.FU_CF_U: CounterType.Stress, + ProfilingCounter.FU_RW_U: CounterType.Stress, + ProfilingCounter.FU_TEX_U: CounterType.Stress, + ProfilingCounter.SRM_E: CounterType.Stress, + ProfilingCounter.SP_E: CounterType.Stress, + ProfilingCounter.DP_E: CounterType.Stress, + # Artificial counters + ProfilingCounter.PARALLELISM: CounterType.Stress, +} + + +# Regular expressions and their converters +_counterValueMappings: dict[str, Callable[[float], float]] = { + # Python dictionaries are ordered, so order is important + r'^issue_slot_utilization$': lambda x: x / 100, + r'^.*\.pct_of_.*$': lambda x: x / 100, + r'^.*\.pct$': lambda x: x / 100, + r'^.*_utilization$': lambda x: x / 10, + r'^.*_efficiency$': lambda x: x / 100, + r'smsp__thread_inst_executed_per_inst_executed\.ratio': lambda x: x / 32, + r'^unknown$': lambda _: 0, +} + + +def _GetCounterName(counter: str) -> ProfilingCounter: + return _counterNameMappings.get(counter, ProfilingCounter.UNKNOWN) + + +def GetCounterType(counter: ProfilingCounter) -> CounterType: + return _counterTypeMappings[counter] + + +def _FindMapping(counter: str) -> Callable[[float], float]: + for pattern, mapping in _counterValueMappings.items(): + if re.fullmatch(pattern, counter): + return mapping + + return lambda x: x + +def _streamingMultiprocessorsToCores(ccMajor:int, ccMinor: int): + smCoresMapping = { + 0x30: 192, + 0x32: 192, + 0x35: 192, + 0x37: 192, + 0x50: 128, + 0x52: 128, + 0x53: 128, + 0x60: 64, + 0x61: 128, + 0x62: 128, + 0x70: 64, + 0x72: 64, + 0x75: 64, + 0x80: 64, + 0x86: 64, + } + defaultSM = 64 + + compact = (ccMajor << 4) + ccMinor + if compact in smCoresMapping: + return smCoresMapping[compact] + + print( + 'Warning: unknown number of cores for SM', + f'{ccMajor}.{ccMinor},', + f'using default value of {defaultSM}', + ) + return defaultSM + +class CounterHeader: + def __init__(self, counter: str): + self.name = _GetCounterName(counter) + self.type = GetCounterType(self.name) + + self._converter = _FindMapping( + counter + if self.name != ProfilingCounter.UNKNOWN + else 'unknown' + ) + + def ConvertValue(self, value: float) -> float: + return self._converter(value) + + +class ParallelismHeader(CounterHeader): + def __init__(self, ccMajor: int, ccMinor: int): + super().__init__('parallelism') + + cores = _streamingMultiprocessorsToCores(ccMajor, ccMinor) + + def _converter(threads: float) -> float: + return min(1.0, threads / (5 * cores)) + + self._converter = _converter diff --git a/Scripts/NewProfileSearcher/modules/info.py b/Scripts/NewProfileSearcher/modules/info.py new file mode 100644 index 00000000..4daa8394 --- /dev/null +++ b/Scripts/NewProfileSearcher/modules/info.py @@ -0,0 +1,12 @@ +class ModelInfo: + def __init__(self, deltaPath: str, spacePath: str, counterPath: str): + self.deltaPath = deltaPath + self.spacePath = spacePath + self.counterPath = counterPath + + +class BatchInfo: + def __init__(self, batchSize: int, neighborSize: int, randomSize: int): + self.batchSize = batchSize + self.neighborSize = neighborSize + self.randomSize = randomSize diff --git a/Scripts/NewProfileSearcher/modules/logging.py b/Scripts/NewProfileSearcher/modules/logging.py new file mode 100644 index 00000000..84f6568c --- /dev/null +++ b/Scripts/NewProfileSearcher/modules/logging.py @@ -0,0 +1,53 @@ +from enum import Enum + + +class LoggingLevel(Enum): + OFF = 0 + ERROR = 1 + WARNING = 2 + INFO = 3 + DEBUG = 4 + + +# to be fair, I'd hook up KTT's Logger somehow instead +# but that would make the logger public API? +class Logger: + def __init__(self, level: LoggingLevel, prefix: str) -> None: + self.level = level + self.prefix = prefix + + def _Log(self, level: LoggingLevel, message: str): + if self.level.value < level.value: + return + + print(_getLoggingLevelString(level), self.prefix, message) + + def Error(self, message: str): + self._Log(LoggingLevel.ERROR, message) + + def Warning(self, message: str): + self._Log(LoggingLevel.WARNING, message) + + def Info(self, message: str): + self._Log(LoggingLevel.INFO, message) + + def Debug(self, message: str): + self._Log(LoggingLevel.DEBUG, message) + + +def _getLoggingLevelString(level: LoggingLevel): + match level: + case LoggingLevel.OFF: + return '[Off]' + case LoggingLevel.ERROR: + return '[Error]' + case LoggingLevel.WARNING: + return '[Warning]' + case LoggingLevel.INFO: + return '[Info]' + case LoggingLevel.DEBUG: + return '[Debug]' + + case _: + raise NameError('Unhandled logging level value') + return '' diff --git a/Scripts/NewProfileSearcher/modules/model.py b/Scripts/NewProfileSearcher/modules/model.py new file mode 100644 index 00000000..64efcdb6 --- /dev/null +++ b/Scripts/NewProfileSearcher/modules/model.py @@ -0,0 +1,95 @@ +from abc import ABC +from pathlib import Path +from typing import cast + +import cupy +from numpy.typing import NDArray + +import pickle + +# ---- Uncomment code in here if you want to use neural models. +# ---- I don't like having a pytorch dependency (not just for the types). +# ---- TODO: remove cupy dependency as well? + +# import torch +# import torch.nn as nn + + +class Model(ABC): + """ + An abstraction meant to make work with different kinds of models easier. + Currently unifies scikit and PyTorch API into a single class + """ + + def predict(self, X: NDArray) -> NDArray: + raise NotImplementedError + + +# class NeuralModelAdapter(Model): +# def __init__(self, model: nn.Module): +# self.model = model +# self.device = next(model.parameters()).device +# +# def predict(self, X: NDArray) -> NDArray: +# with torch.no_grad(): +# X_tensor = torch.from_numpy(X).to(self.device) +# +# predictions: torch.Tensor = self.model(X_tensor) +# return predictions.cpu().numpy() + + +class XGBModelAdapter(Model): + def __init__(self, model): + self.model = model + + def predict(self, X: NDArray) -> NDArray: + # TODO: test whether CuPy is not killing the profiler + if self.model.device == 'cuda': + return self.model.predict(cupy.array(X)) + + return self.model.predict(X) + + +# neuralModels = { 'DeltaNN': DeltaNN } + + +def loadModel(filepath: str) -> Model: + """ + Loads a model, infers the models type from the filename. The filename must be in format + `[gpu-info]_[algorithm]_[type](_[optional-info]).sav`. (e.g. `2080_all_XGBRegressor_counters.sav`). + Made to support loading both neural pytorch models and scikit-ones, now only supports scikit ones + and XGBRegressor. + """ + try: + modelType = Path(filepath).stem.split('_')[2] + except IndexError: + print("Model's filename is in an incompatible format") + print('The format: [gpu-info]_[algorithm]_[type](_[optional-info]).sav') + print('For example, 2080_all_XGBRegressor_counters.sav)') + + exit(-1) + + # if modelType in neuralModels: + # state_dictionary = torch.load(filepath, weights_only=True) + # + # input_length = -1 + # for key in state_dictionary: + # if 'input_layer.weight' in key: + # input_length = state_dictionary[key].shape[1] + # break + # + # model = neuralModels[modelType](input_length) + # model.load_state_dict(state_dictionary) + # + # accelerator = torch.accelerator.current_accelerator() + # device = accelerator.type if accelerator else 'cpu' + # + # model.to(device) + # + # return NeuralModelAdapter(model) + + model = pickle.load(open(filepath, 'rb')) + if modelType == 'XGBRegressor': + return XGBModelAdapter(model) + + return cast(Model, model) diff --git a/Scripts/NewProfileSearcher/modules/tuning_space.py b/Scripts/NewProfileSearcher/modules/tuning_space.py new file mode 100644 index 00000000..2a20bb6a --- /dev/null +++ b/Scripts/NewProfileSearcher/modules/tuning_space.py @@ -0,0 +1,8 @@ +from numpy.typing import NDArray +import pandas + + +class TuningSpace: + def __init__(self, parameters: pandas.DataFrame, counters: NDArray): + self.parameters = parameters + self.counters = counters diff --git a/Scripts/NewProfileSearcher/requirements/common.txt b/Scripts/NewProfileSearcher/requirements/common.txt new file mode 100644 index 00000000..007e1213 --- /dev/null +++ b/Scripts/NewProfileSearcher/requirements/common.txt @@ -0,0 +1,6 @@ +seaborn +scikit-learn +numpy +pandas +matplotlib +xgboost diff --git a/Scripts/NewProfileSearcher/requirements/cu126-torch.txt b/Scripts/NewProfileSearcher/requirements/cu126-torch.txt new file mode 100644 index 00000000..af4cf578 --- /dev/null +++ b/Scripts/NewProfileSearcher/requirements/cu126-torch.txt @@ -0,0 +1,4 @@ +--index-url https://download.pytorch.org/whl/cu126/ + +torch==2.10.0+cu126 +torchmetrics diff --git a/Scripts/NewProfileSearcher/requirements/cu13-torch.txt b/Scripts/NewProfileSearcher/requirements/cu13-torch.txt new file mode 100644 index 00000000..b2ea7e9a --- /dev/null +++ b/Scripts/NewProfileSearcher/requirements/cu13-torch.txt @@ -0,0 +1,4 @@ +--index-url https://download.pytorch.org/whl/cu130/ + +torch==2.11.0+cu130 +torchmetrics diff --git a/Scripts/PrepareModels/generate_decision_tree_model.py b/Scripts/OldProfileSearcher/PrepareModels/generate_decision_tree_model.py similarity index 100% rename from Scripts/PrepareModels/generate_decision_tree_model.py rename to Scripts/OldProfileSearcher/PrepareModels/generate_decision_tree_model.py diff --git a/Scripts/PrepareModels/generate_models.py b/Scripts/OldProfileSearcher/PrepareModels/generate_models.py similarity index 100% rename from Scripts/PrepareModels/generate_models.py rename to Scripts/OldProfileSearcher/PrepareModels/generate_models.py diff --git a/Scripts/OldProfileSearcher/ProfileBasedSearcher.h b/Scripts/OldProfileSearcher/ProfileBasedSearcher.h new file mode 100644 index 00000000..0cf084ad --- /dev/null +++ b/Scripts/OldProfileSearcher/ProfileBasedSearcher.h @@ -0,0 +1,882 @@ +std::string() + R"( +#!/usr/bin/env python -W ignore::DeprecationWarning + +''' +Searcher which explores configurations according to observed bottlenecks +and ML model created on historical data (on the same tuning space, but +possibly different HW and input size). For more information, see +J. Filipovic et al. Using hardware performance counters to speed up +autotuning convergence on GPUs. JPDC, vol. 160, 2021. +''' + +import random +import csv +import pickle +import numpy as np +import signal +import pdb +import json +import warnings + +import pyktt as ktt + +np.printoptions(precision=5, suppress=True) + +# verbosity level (0, 1, 2, 3) +# 0 - nothing +# 1 - info +# 2 - more info +# 3 - debug + +# all constant used by the searcher +# CORR_SHIFT: value added to correlation (positive forces to search parameters with weak correlation but strong variation) +# EXP: exponent used to prioritize configurations with high score (probab = score ^ EXP, where score is in <0, 1> ) +# REACT_TO_INST_BOTTLENECKS: minimal instructions bottlenecks, which affects scoring of tuning configurations +# CUTOFF: maximal score of configurations, which are discarded from tuning space +# BATCH: number of configuration from which the fastest one is profiled, set in KTT +# NEIGHBOR_SIZE: number of neighboring configurations that are used for batch selection, set in KTT +# RANDOM_SIZE: number of random configurations that are used for batch selection, set in KTT +# NEIGHBOR_DISTANCE: distance between configurations (how many TP have different values) that are still considered neighbors +CORR_SHIFT = 0.0 +EXP = 8 +REACT_TO_INST_BOTTLENECKS = 0.7 +CUTOFF = -0.25 +NEIGHBOR_DISTANCE = 2 + +########################### loading models functions ################################ + +def loadMLModel(trainedKnowledgeBase): + return pickle.load(open(trainedKnowledgeBase, 'rb')) + +def loadMLModelMetadata(filename) : + metadata = {} + with open(filename, 'r') as metadataFile: + metadata = json.load(metadataFile) + return metadata + +def loadCompleteMappingCounters(tuningSpace, rangeC) : + words = tuningSpace.readline().split(',') + counters = [] + #for i in range(tuningInt[1]+1, len(words)) : + for i in rangeC : + if i < len(words) : + counters.append(words[i].rstrip()) + for j in range(i+1, len(words)) : + counters.append(words[j].rstrip()) + + return counters + + +def loadCompleteMapping(tuningSpace, rangeT, rangeC) : + tuningSpace.seek(0) + wordsHead = tuningSpace.readline().split(',') + #pcInt = [tuningInt[1]+1, len(wordsHead)-1] + myRange = [] + for i in rangeC : + if i < len(wordsHead) : + myRange.append(i) + restPCs = list(range(rangeC[-1]+1, len(wordsHead))) + pcInt = myRange + restPCs + + space = [] + for line in tuningSpace.readlines() : + words = line.split(',') + if len(words) <= 1: break + + tunRow = [] + #for i in range(tuningInt[0], tuningInt[1]+1) : + for i in rangeT : + tunRow.append(float(words[i])) + #pcRow = {} + #for i in range(pcInt[0], pcInt[1]+1) : + # pcRow[wordsHead[i].rstrip()] = float(words[i]) + pcRow = [] + #for i in range(pcInt[0], pcInt[1]+1) : + for i in pcInt : + pcRow.append(float(words[i])) + + spaceRow = [tunRow, pcRow] + space.append(spaceRow) + + return space + + +####################### GPU arch. dependent functions ########################## + +# analyzeBottlenecks +# analysis of bottlenecks, observes profiling counters and scores bottlenecks +# in interval <0, 1> +# GPU dependent, implemented for CUDA compute capabilities 3.0 - 7.5 + +def analyzeBottlenecks (countersNames, countersData, cc, multiprocessors, cores, verbose): + bottlenecks = {} + # analyze global memory + if cc < 7.0 : + DRAMutil = countersData[countersNames.index("dram_utilization")] + DRAMldTrans = countersData[countersNames.index("dram_read_transactions")] + DRAMstTrans = countersData[countersNames.index("dram_write_transactions")] + else : + DRAMutil = countersData[countersNames.index("dram__throughput.avg.pct_of_peak_sustained_elapsed")]/10.0 + DRAMldTrans = countersData[countersNames.index("dram__sectors_read.sum")] + DRAMstTrans = countersData[countersNames.index("dram__sectors_write.sum")] + if DRAMldTrans + DRAMstTrans > 0 and DRAMutil > 0 : + bnDRAMRead = (DRAMldTrans / (DRAMldTrans + DRAMstTrans)) * (DRAMutil / 10.0) + bnDRAMWrite = (DRAMstTrans / (DRAMldTrans + DRAMstTrans)) * (DRAMutil / 10.0) + else : + bnDRAMRead = 0 + bnDRAMWrite = 0 + bottlenecks['bnDRAMRead'] = bnDRAMRead + bottlenecks['bnDRAMWrite'] = bnDRAMWrite + + # analyze cache system + if cc < 7.0 : + L2util = countersData[countersNames.index("l2_utilization")] + L2ldTrans = countersData[countersNames.index("l2_read_transactions")] + L2stTrans = countersData[countersNames.index("l2_write_transactions")] + texUtil = countersData[countersNames.index("tex_utilization")] + #texFuUtil = countersData[countersNames.index("tex_fu_utilization")] + texTrans = countersData[countersNames.index("tex_cache_transactions")] + else : + L2util = countersData[countersNames.index("lts__t_sectors.avg.pct_of_peak_sustained_elapsed")]/10.0 + L2ldTrans = countersData[countersNames.index("lts__t_sectors_op_read.sum")] + L2stTrans = countersData[countersNames.index("lts__t_sectors_op_write.sum")] + texUtil = countersData[countersNames.index("l1tex__t_requests_pipe_lsu_mem_global_op_ld.avg.pct_of_peak_sustained_active")]/10.0 + #texFuUtil = countersData[countersNames.index("tex_fu_utilization")] + texTrans = countersData[countersNames.index("l1tex__t_requests_pipe_lsu_mem_global_op_ld.sum")] + bnL2Read = (L2ldTrans / (L2ldTrans + L2stTrans)) * (L2util / 10.0) + bnL2Write = (L2stTrans / (L2ldTrans + L2stTrans)) * (L2util / 10.0) + #bnTex = max(texUtil / 10.0, texFuUtil / 10.0) + bnTex = texUtil / 10.0 + bottlenecks['bnL2Read'] = bnL2Read + bottlenecks['bnL2Write'] = bnL2Write + bottlenecks['bnTex'] = bnTex + + # analyze local (non-registers private in OpenCL) memory + if cc < 7.0 : + locOverhead = countersData[countersNames.index("local_memory_overhead")] + else : + #XXX this is highly experimental computation + locOverhead = 100.0 * countersNames.index("l1tex__t_sectors_pipe_lsu_mem_local_op_st.sum") / L2stTrans + bottlenecks['bnLocal'] = (locOverhead/100.0) * max(DRAMutil/10.0, L2util/10.0, texUtil/10.0)#, texFuUtil/10.0) + + # analyze shared memory + if cc < 7.0 : + if cc < 4.0 : + SMutil = countersData[countersNames.index("shared_efficiency")] + else : + SMutil = countersData[countersNames.index("shared_utilization")] + SMldTrans = countersData[countersNames.index("shared_load_transactions")] + SMstTrans = countersData[countersNames.index("shared_store_transactions")] + else : + SMutil = countersData[countersNames.index("l1tex__data_pipe_lsu_wavefronts_mem_shared.avg.pct_of_peak_sustained_elapsed")]/10.0 + SMldTrans = countersData[countersNames.index("l1tex__data_pipe_lsu_wavefronts_mem_shared_op_ld.sum")] + SMstTrans = countersData[countersNames.index("l1tex__data_pipe_lsu_wavefronts_mem_shared_op_st.sum")] + + if (SMldTrans + SMstTrans > 0): + bnSMRead = (SMldTrans / (SMldTrans + SMstTrans)) * (SMutil / 10.0) + bnSMWrite = (SMstTrans / (SMldTrans + SMstTrans)) * (SMutil / 10.0) + else: + bnSMRead = 0 + bnSMWrite = 0 + bottlenecks['bnSMRead'] = bnSMRead + bottlenecks['bnSMWrite'] = bnSMWrite + + # analyze multiprocessor parallelism + if cc < 7.0 : + occupancy = countersData[countersNames.index("achieved_occupancy")] + else : + occupancy = countersData[countersNames.index("sm__warps_active.avg.pct_of_peak_sustained_active")]/100.0 + bnMPparal = 1.0 - occupancy + bottlenecks['bnMPparal'] = bnMPparal + + # analyze global parallelism + if cc < 7.0 : + smEfficiency = 100.0 #countersData[countersNames.index("sm_efficiency")] #commented-out as with driver 515.65.01 and CUDA 11.7, sm_efficiency shows weird behaviour + else : + smEfficiency = countersData[countersNames.index("smsp__cycles_active.avg.pct_of_peak_sustained_elapsed")] + bnGparal = (100.0 - smEfficiency) / 100.0 + bottlenecks['bnGparal'] = bnGparal + + threadBlocks = countersData[countersNames.index("Global size")] / countersData[countersNames.index("Local size")] + bnTailEffect = 1 - (threadBlocks / (((threadBlocks + multiprocessors-1) / multiprocessors) * multiprocessors)) + bottlenecks['bnTailEffect'] = bnTailEffect + #print(bnTailEffect, threadBlocks, countersData[countersNames.index("Global size")], countersData[countersNames.index("Local size")]) + + bnThreads = max(0, (cores * 5 - countersData[countersNames.index("Global size")]) / (cores * 5)) + bottlenecks['bnThreads'] = bnThreads + + # analyze instructions + # insctruction counts + if cc < 7.0 : + spInstr = countersData[countersNames.index("inst_fp_32")] + dpInstr = countersData[countersNames.index("inst_fp_64")] + intInstr = countersData[countersNames.index("inst_integer")] + #commInstr = countersData[countersNames.index("inst_inter_thread_communication")] + miscInstr = countersData[countersNames.index("inst_misc")] + ldstInstr = countersData[countersNames.index("inst_compute_ld_st")] + ctrlInst = countersData[countersNames.index("inst_control")] + bconvInstr = countersData[countersNames.index("inst_bit_convert")] + execInstr = countersData[countersNames.index("inst_executed")] + else : + spInstr = countersData[countersNames.index("smsp__sass_thread_inst_executed_op_fp32_pred_on.sum")] + dpInstr = countersData[countersNames.index("smsp__sass_thread_inst_executed_op_fp64_pred_on.sum")] + intInstr = countersData[countersNames.index("smsp__sass_thread_inst_executed_op_integer_pred_on.sum")] + #commInstr = countersData[countersNames.index("inst_inter_thread_communication")] + miscInstr = countersData[countersNames.index("smsp__sass_thread_inst_executed_op_misc_pred_on.sum")] + ldstInstr = countersData[countersNames.index("smsp__sass_thread_inst_executed_op_memory_pred_on.sum")] + ctrlInst = countersData[countersNames.index("smsp__sass_thread_inst_executed_op_control_pred_on.sum")] + bconvInstr = countersData[countersNames.index("smsp__sass_thread_inst_executed_op_conversion_pred_on.sum")] + execInstr = countersData[countersNames.index("smsp__inst_executed.sum")] + + #instruction utilization + if cc < 7.0 : + if cc < 4.0 : + spUtil = countersData[countersNames.index("flop_sp_efficiency")] + dpUtil = countersData[countersNames.index("flop_dp_efficiency")] + sfuUtil = 0 #XXX we don't have this counter + else : + spUtil = countersData[countersNames.index("single_precision_fu_utilization")] + dpUtil = countersData[countersNames.index("double_precision_fu_utilization")] + sfuUtil = countersData[countersNames.index("special_fu_utilization")] + cfUtil = countersData[countersNames.index("cf_fu_utilization")] + ldstUtil = countersData[countersNames.index("ldst_fu_utilization")] + texFuUtil = countersData[countersNames.index("tex_fu_utilization")] + instrSlotUtil = countersData[countersNames.index("issue_slot_utilization")] + if cc >= 4.0 : + instrEffExec = countersData[countersNames.index("warp_execution_efficiency")] + instrEffPred = countersData[countersNames.index("warp_nonpred_execution_efficiency")] + else : + instrEffExec = 100 + instrEffPred = 100 + else : + spUtil = countersData[countersNames.index("smsp__pipe_fma_cycles_active.avg.pct_of_peak_sustained_active")]/10.0 + dpUtil = countersData[countersNames.index("smsp__inst_executed_pipe_fp64.avg.pct_of_peak_sustained_active")]/10.0 + sfuUtil = countersData[countersNames.index("smsp__inst_executed_pipe_xu.avg.pct_of_peak_sustained_active")]/10.0 + cfUtil = 0.0 #XXX we don't have this counter + ldstUtil = countersData[countersNames.index("smsp__inst_executed_pipe_lsu.avg.pct_of_peak_sustained_active")]/10.0 + texFuUtil = countersData[countersNames.index("smsp__inst_executed_pipe_tex.avg.pct_of_peak_sustained_active")]/10.0 + instrSlotUtil = countersData[countersNames.index("smsp__issue_active.avg.pct_of_peak_sustained_active")] + instrEffExec = countersData[countersNames.index("smsp__thread_inst_executed_per_inst_executed.ratio")]*100.0/32.0 + instrEffPred = countersData[countersNames.index("smsp__thread_inst_executed_per_inst_executed.pct")] + + instrExecFitted = execInstr*32.0 * (100.0/instrEffExec) * (100.0/instrEffPred) #XXX this should be equal to spInstr+dpInstr+intInstr+miscInstr+ldstInstr+ctrlInst+bconvInstr + if cc < 7.0 : + instrUtilFitted = instrSlotUtil/100.0 + else : + instrUtilFitted = min(1.0, instrSlotUtil/50.0) # dual-issue causes max 50% utilization of instruction of single type + + spUtilApprox = (spInstr/instrExecFitted) * instrUtilFitted + dpUtilApprox = (dpInstr/instrExecFitted) * instrUtilFitted + ldstUtilApprox = (ldstInstr/instrExecFitted) * instrUtilFitted + cfUtilApprox = (ctrlInst/instrExecFitted) * instrUtilFitted + intUtilApprox = (intInstr/instrExecFitted) * instrUtilFitted + miscUtilApprox = (miscInstr/instrExecFitted) * instrUtilFitted + bconvUtilApprox = (bconvInstr/instrExecFitted) * instrUtilFitted + + #print("single_precision_fu_utilization reported/computed: ", spUtil, (spInstr/instrExecFitted) * instrUtilFitted) +# #workaround is to bottleneck instructions only if utilization is significant +# maxUtil = max(spUtil, dpUtil, cfUtil) +# maxUtilInst = max(spInstr, dpInstr, ctrlInst) #XXX should select the same category as the line above +# if maxUtil > 6: +# intUtilApprox = intInstr/maxUtilInst * maxUtil +# miscUtilApprox = miscInstr/maxUtilInst * maxUtil +# bconvUtilApprox = bconvInstr/maxUtilInst * maxUtil +# else: +# intUtilApprox = 0.0 +# miscUtilApprox = 0.0 +# bconvUtilApprox = 0.0 + +# bnSP = spUtil/10.0 + bnSP = spUtilApprox +# bnDP = dpUtil/10.0 + bnDP = dpUtilApprox + bnSFU = sfuUtil/10.0 +# bnCF = cfUtil/10.0 + bnCF = cfUtilApprox +# bnLDST = ldstUtil/10.0 + bnLDST = ldstUtilApprox + bnTexFu = texFuUtil/10.0 + bnInt = intUtilApprox + bnMisc = miscUtilApprox + bnBconv = bconvUtilApprox + + bottlenecks['bnSP'] = bnSP + bottlenecks['bnDP'] = bnDP + bottlenecks['bnSFU'] = bnSFU + bottlenecks['bnCF'] = bnCF + bottlenecks['bnLDST'] = bnLDST + bottlenecks['bnTexFu'] = bnTexFu + bottlenecks['bnInt'] = bnInt + bottlenecks['bnMisc'] = bnMisc + bottlenecks['bnBconv'] = bnBconv + + issueWeight = 0.0 + maxInstrUtil = max(spUtilApprox/instrUtilFitted, dpUtilApprox/instrUtilFitted, sfuUtil/10.0, cfUtilApprox/instrUtilFitted, ldstUtilApprox/instrUtilFitted, intUtilApprox/instrUtilFitted, miscUtilApprox/instrUtilFitted, bconvUtilApprox/instrUtilFitted) + if maxInstrUtil > REACT_TO_INST_BOTTLENECKS : + issueWeight = (maxInstrUtil - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + bnInstIssue = (100.0 - instrSlotUtil) / 100 * issueWeight + #bnInstIssue = (100.0 - instrSlotUtil) / 100 * max(spUtilApprox/instrUtilFitted, dpUtilApprox/instrUtilFitted, sfuUtil/instrUtilFitted/10.0, cfUtilApprox/instrUtilFitted, ldstUtilApprox/instrUtilFitted, texFuUtil/instrUtilFitted/10.0, intUtilApprox/instrUtilFitted, miscUtilApprox/instrUtilFitted, bconvUtilApprox/instrUtilFitted) + bottlenecks['bnInstIssue'] = bnInstIssue + + if verbose > 1 : + print("[Profile-based searcher details] bottlenecks:", bottlenecks) + + return bottlenecks + +# computeChanges +# computes how to change profiling counters according to bottlenecks +# absolute value of computed changes means its importance, the sign means +# required direction (increase/decrease the counter) +# GPU dependent, implemented for CUDA compute capabilities 3.0 - 7.5 +# Note: this function is separated from analyzeBottlenecks in order to manage +# portability across arch. easily (computed bottlenecks are arch. independent) + +def computeChanges(bottlenecks, countersNames, cc, verbose): + # set how important is to change particular profiling counters + changeImportance = [0.0]*len(countersNames) + + # memory-subsystem related counters + if cc < 7.0 : + changeImportance[countersNames.index('dram_read_transactions')] = - bottlenecks['bnDRAMRead'] + changeImportance[countersNames.index('dram_write_transactions')] = - bottlenecks['bnDRAMWrite'] + changeImportance[countersNames.index('l2_read_transactions')] = - bottlenecks['bnL2Read'] + changeImportance[countersNames.index('l2_write_transactions')] = - bottlenecks['bnL2Write'] + changeImportance[countersNames.index('tex_cache_transactions')] = - bottlenecks['bnTex'] + changeImportance[countersNames.index('local_memory_overhead')] = - bottlenecks['bnLocal'] + changeImportance[countersNames.index('shared_load_transactions')] = - bottlenecks['bnSMRead'] + changeImportance[countersNames.index('shared_store_transactions')] = - bottlenecks['bnSMWrite'] + else: + changeImportance[countersNames.index('dram__sectors_read.sum')] = - bottlenecks['bnDRAMRead'] + changeImportance[countersNames.index('dram__sectors_write.sum')] = - bottlenecks['bnDRAMWrite'] + changeImportance[countersNames.index('lts__t_sectors_op_read.sum')] = - bottlenecks['bnL2Read'] + changeImportance[countersNames.index('lts__t_sectors_op_write.sum')] = - bottlenecks['bnL2Write'] + #TODO solve additive counters more elegantly? + changeImportance[countersNames.index('l1tex__t_requests_pipe_lsu_mem_global_op_ld.sum')] = - bottlenecks['bnTex'] + changeImportance[countersNames.index('l1tex__t_sectors_pipe_lsu_mem_local_op_ld.sum')] = - bottlenecks['bnLocal'] + changeImportance[countersNames.index('l1tex__t_sectors_pipe_lsu_mem_local_op_st.sum')] = - bottlenecks['bnLocal'] + changeImportance[countersNames.index('l1tex__data_pipe_lsu_wavefronts_mem_shared_op_ld.sum')] = - bottlenecks['bnSMRead'] + changeImportance[countersNames.index('l1tex__data_pipe_lsu_wavefronts_mem_shared_op_st.sum')] = - bottlenecks['bnSMWrite'] + + # instructions related counters + if cc < 7.0 : + if bottlenecks['bnSP'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('inst_fp_32')] = - (bottlenecks['bnSP'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + changeImportance[countersNames.index('flop_sp_efficiency')] = (bottlenecks['bnSP'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + if bottlenecks['bnDP'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('inst_fp_64')] = - (bottlenecks['bnDP']- REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + #changeImportance[countersNames.index('special_fu_utilization')] = + bottlenecks['bnSFU'] #TODO how to count SFU instructions? + if bottlenecks['bnCF'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('inst_control')] = - (bottlenecks['bnCF'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + if bottlenecks['bnLDST'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('inst_compute_ld_st')] = - (bottlenecks['bnLDST'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + #changeImportance[countersNames.index('tex_fu_utilization')] = + bottlenecks['bnTexFu'] + if bottlenecks['bnInt'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('inst_integer')] = - (bottlenecks['bnInt'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + if bottlenecks['bnMisc'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('inst_misc')] = - (bottlenecks['bnMisc'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + if bottlenecks['bnBconv'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('inst_bit_convert')] = - (bottlenecks['bnBconv'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + #if bottlenecks['bnInstIssue'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('issue_slot_utilization')] = bottlenecks['bnInstIssue'] #(bottlenecks['bnInstIssue'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + else : + if bottlenecks['bnSP'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_fp32_pred_on.sum')] = - bottlenecks['bnSP'] + if bottlenecks['bnDP'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_fp64_pred_on.sum')] = - bottlenecks['bnDP'] + #changeImportance[countersNames.index('special_fu_utilization')] = + bottlenecks['bnSFU'] #TODO how to count SFU instructions? + if bottlenecks['bnCF'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_control_pred_on.sum')] = - (bottlenecks['bnCF'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + if bottlenecks['bnLDST'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_memory_pred_on.sum')] = - (bottlenecks['bnLDST'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + #changeImportance[countersNames.index('tex_fu_utilization')] = + bottlenecks['bnTexFu'] + if bottlenecks['bnInt'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_integer_pred_on.sum')] = - (bottlenecks['bnInt'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + if bottlenecks['bnMisc'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_misc_pred_on.sum')] = - (bottlenecks['bnMisc'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + if bottlenecks['bnBconv'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_conversion_pred_on.sum')] = - (bottlenecks['bnBconv'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + #if bottlenecks['bnInstIssue'] > REACT_TO_INST_BOTTLENECKS : + changeImportance[countersNames.index('smsp__issue_active.avg.pct_of_peak_sustained_active')] = bottlenecks['bnInstIssue'] #(bottlenecks['bnInstIssue'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS) + + #parallelism related counters + if cc < 7.0 : + changeImportance[countersNames.index('sm_efficiency')] = bottlenecks['bnGparal'] + else : + changeImportance[countersNames.index('smsp__cycles_active.avg.pct_of_peak_sustained_elapsed')] = bottlenecks['bnGparal'] + + changeImportance[countersNames.index('Global size')] = bottlenecks['bnThreads']#bottlenecks['bnTailEffect'] + bottlenecks['bnThreads'] + #changeImportance[countersNames.index('Local size')] = - bottlenecks['bnTailEffect'] / 2 + + if verbose > 1 : + print("[Profile-based searcher details] changeImportance:", changeImportance) + + return changeImportance + +###################### GPU arch. independent functions ######################### + +# scoreTuningConfigurationsExact +# scores all tuning configurations according to required changes of profiling +# counters and expected effect of the tuning parameters to profiling counters +# GPU independent +# This version uses completely computed offline space + +def scoreTuningConfigurationsExact(changeImportance, tuningparamsNames, actualConf, tuningSpace, completeMapping, scoreDistrib, verbose): + newScoreDistrib = [0.0] * len(tuningSpace) + #search index of actualConf in completeMapping (some conf. can be missing, therefore, we need to check tuning parameters) + actualPC = [] + for conf in completeMapping : + if actualConf == conf[0] : + actualPC = conf[1] + if len(actualPC) == 0 : + # the configuration is not known in the completeMapping, return uniform distrib + for i in range(0, len(tuningSpace)) : + uniformScoreDistrib = [1.0] * len(tuningSpace) + if scoreDistrib[i] == 0.0 : + uniformScoreDistrib[i] = 0.0 + return uniformScoreDistrib + + cmIdx = 0 + # for each tuning configuration + for i in range(0, len(tuningSpace)) : + #seek for equivalent tuning configuration in the completeMapping + #TODO this implementation assumes the same order of tuning configurations, create mapping between indexes instead + myPC = [] + for j in range(cmIdx, len(completeMapping)) : + if (tuningSpace[i] == completeMapping[j][0]) : + myPC = completeMapping[j][1] + cmIdx = j+1 + break + if (len(myPC) == 0) : + newScoreDistrib[i] = 0.0 + else : + #score configuration + for j in range(0, len(changeImportance)) : + try: + newScoreDistrib[i] = newScoreDistrib[i] + changeImportance[j] * (myPC[j] - actualPC[j]) / (myPC[j]+actualPC[j]) + except ZeroDivisionError : + newScoreDistrib[i] = newScoreDistrib[i] + 0.0 + + minScore = min(newScoreDistrib) + maxScore = max(newScoreDistrib) + if verbose > 1 : + print("[Profile-based searcher details] scoreDistrib interval: ", minScore, maxScore) + for i in range(0, len(tuningSpace)) : + if newScoreDistrib[i] < CUTOFF : + newScoreDistrib[i] = 0.0 + else : + if newScoreDistrib[i] < 0.0 : + newScoreDistrib[i] = 1.0 - (newScoreDistrib[i] / minScore) + else : + if newScoreDistrib[i] > 0.0 : + newScoreDistrib[i] = 1.0 + (newScoreDistrib[i] / maxScore) + newScoreDistrib[i] = newScoreDistrib[i]**EXP + if newScoreDistrib[i] < 0.0001 : + newScoreDistrib[i] = 0.0001 + + # if was 0, set to 0 (explored) + if scoreDistrib[i] == 0.0 : + newScoreDistrib[i] = 0.0 + + if verbose > 2 : + print("[Profile-based searcher debug] newScoreDistrib", newScoreDistrib) + + return newScoreDistrib + + +# scoreTuningConfigurationsPredictor +# scores all tuning configurations according to required changes of profiling +# counters and expected effect of the tuning parameters to profiling counters +# GPU independent +# This version uses predictor based on ML model +def scoreTuningConfigurationsPredictor(changeImportance, tuningParametersReorderingFromSearchSpaceToModel, actualConf, tuningSpace, scoreDistrib, loaded_model, verbose): + def mulfunc(a, b, c): + if (a * (b - c)) > 0.0: + return 1.0 + if (a * (b - c)) < 0.0: + return -1.0 + else: + return 0.0 + + newScoreDistrib = [0.0] * len(tuningSpace) + actualPC = [] + + # Using ML predictor + reorderedActualConf = reorderList(actualConf, tuningParametersReorderingFromSearchSpaceToModel) + predictedPC = loaded_model.predict([reorderedActualConf]) + actualPC = list(predictedPC.flatten()) + + if len(actualPC) == 0 : + for i in range(0, len(tuningSpace)) : + uniformScoreDistrib = [1.0] * len(tuningSpace) + if scoreDistrib[i] == 0.0 : + uniformScoreDistrib[i] = 0.0 + return uniformScoreDistrib + + + #################################################### Using ML predictor + #reorder the tuning space data so that they are in the correct order + # TP from tuning space and T from model might be in different order, thus reordering is necessary + reorderedTuningSpace = reorderTuningSpace(tuningSpace, tuningParametersReorderingFromSearchSpaceToModel) + predictedMyPC = loaded_model.predict(reorderedTuningSpace) + predictedMyPC1 = np.array(predictedMyPC) + actualPC1 = np.array(actualPC) + n = len(changeImportance) - len(actualPC1) + changeImportance = changeImportance[:len(changeImportance)-n] + changeImportance1 = np.array(changeImportance) + + vfunc = np.vectorize(mulfunc) + if verbose < 3: + # supressing the warning about dividing with zero + # nan that results from that is converted to number just below + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + mul = vfunc(changeImportance1, predictedMyPC1, actualPC1) + res = np.array(mul * abs(changeImportance1 * 2.0 * (predictedMyPC1 - actualPC1) / (predictedMyPC1+actualPC1))) + else: + mul = vfunc(changeImportance1, predictedMyPC1, actualPC1) + res = np.array(mul * abs(changeImportance1 * 2.0 * (predictedMyPC1 - actualPC1) / (predictedMyPC1+actualPC1))) + res = np.nan_to_num(res) + newScoreDistrib = res.sum(axis=1) + + minScore = min(newScoreDistrib) + maxScore = max(newScoreDistrib) + if verbose > 1 : + print("[Profile-based searcher details] scoreDistrib interval: ", minScore, maxScore) + for i in range(0, len(tuningSpace)) : + if newScoreDistrib[i] < CUTOFF : + newScoreDistrib[i] = 0.0001 + else : + if newScoreDistrib[i] < 0.0 : + newScoreDistrib[i] = 1.0 - (newScoreDistrib[i] / minScore) + else : + if newScoreDistrib[i] > 0.0 : + newScoreDistrib[i] = 1.0 + (newScoreDistrib[i] / maxScore) + newScoreDistrib[i] = newScoreDistrib[i]**EXP + if newScoreDistrib[i] < 0.0001 : + newScoreDistrib[i] = 0.0001 + + # if was 0, set to 0 (explored) + if scoreDistrib[i] == 0.0 : + newScoreDistrib[i] = 0.0 + + if verbose > 2 : + print("[Profile-based searcher debug] Predictor newScoreDistrib:", newScoreDistrib) + + return newScoreDistrib + +# randomSearchStep +# perform one step of random search (without memory) +def randomSearchStep(tuningSpaceSize) : + return int(random.random() * tuningSpaceSize) + +# weightedRandomSearchStep +# perform one step of random search using weighted probability based on +# profiling counters +def weightedRandomSearchStep(scoreDistrib, tuningSpaceSize) : + if (sum(scoreDistrib) == 0.0) : + print("Weighted search error: no more tuning configurations.") + return randomSearchStep(tuningSpaceSize) + + rnd = random.random() * sum(scoreDistrib) + idx = 0 + tmp = 0.0 + for j in range (0, tuningSpaceSize): + tmp = tmp + scoreDistrib[j] + if rnd < tmp : break + idx = idx + 1 + return idx + +####################### auxiliary functions ########################## + +def setComputeBound(): + global REACT_TO_INST_BOTTLENECKS + REACT_TO_INST_BOTTLENECKS = 0.5 + +def setMemoryBound(): + global REACT_TO_INST_BOTTLENECKS + REACT_TO_INST_BOTTLENECKS = 0.7 + +def reorderList(data, reorderingIndices) : + return [x for _, x in sorted(zip(reorderingIndices, data))] + +def reorderTuningSpace(data, reorderingIndices) : + reorderedData = [] + for row in data: + reorderedData.append(reorderList(row, reorderingIndices)) + return reorderedData + +def getConfigurationIndices(self, configurations) : + ind = [] + for c in configurations : + ind.append(self.GetIndex(c)) + return ind + + +####################### searcher class ########################## + +class PyProfilingSearcher(ktt.Searcher): + ccMajor = 0 + ccMinor = 0 + cc = 0 + multiprocessors = 0 + modelMetadata = 0 + bestDuration = -1 + bestConf = None + preselectedBatch = [] + tuningParamsNames = [] + currentConfiguration = ktt.KernelConfiguration() + tuner = None + model = None + batchSize = -1 + neighborSize = -1 + randomSize = -1 + verbose = 0 + # sometimes, the order of tuning parameters in the search space (as generated by KTT) differs from the order of tuning parameters in the saved ML model + #therefore, we need to reorder them to align, so that the model works with the correctly ordered data + tuningParametersReorderingFromSearchSpaceToModel = 0 + + def __init__(self): + ktt.Searcher.__init__(self) + + def OnInitialize(self): + + # initialize the batch, make sure it includes unique, i.e. non-repeating configurations + count = 0 + while count < self.batchSize: + for i in range (count, self.batchSize) : + self.preselectedBatch.append(self.GetRandomConfiguration()) + self.preselectedBatch = self.GetUniqueConfigurations(self.preselectedBatch) + count = len(self.preselectedBatch) + if self.verbose > 0: + print("[Profile-based searcher info] Batch initialized with configurations ", getConfigurationIndices(self, self.preselectedBatch)) + + # select configuration and remove it from he batch + self.currentConfiguration = self.preselectedBatch.pop(0) + if self.verbose > 0: + print("[Profile-based searcher info] Selected configuration " + str(self.GetIndex(self.currentConfiguration)), flush = True) + + # determine the difference in the order of TP from search space and from the model + tp = self.currentConfiguration.GetPairs() + for p in tp : + self.tuningParamsNames.append(p.GetName()) + self.tuningParametersReorderingFromSearchSpaceToModel = [] + for tp in self.tuningParamsNames: + self.tuningParametersReorderingFromSearchSpaceToModel.append(self.modelMetadata['tp'].index(tp)) + if self.verbose > 2: + print("[Profile-based searcher debug] Tuning parameters in the search space:", self.tuningParamsNames) + print("[Profile-based searcher debug] Tuning parameters in the model:", self.modelMetadata['tp']) + print("[Profile-based searcher debug] Tuning parameters reordering list", self.tuningParametersReorderingFromSearchSpaceToModel) + + def Configure(self, tuner, modelFile, batchSize, neighborSize, randomSize, logLevel): + self.tuner = tuner + self.ccMajor = tuner.GetCurrentDeviceInfo().GetCudaComputeCapabilityMajor() + self.ccMinor = tuner.GetCurrentDeviceInfo().GetCudaComputeCapabilityMinor() + self.cc = self.ccMajor + round(0.1 * self.ccMinor, 1) + self.multiprocessors = tuner.GetCurrentDeviceInfo().GetMaxComputeUnits() + + self.modelMetadata = loadMLModelMetadata(modelFile + ".metadata.json") + self.model = loadMLModel(modelFile) + self.batchSize = batchSize + self.neighborSize = neighborSize + self.randomSize = randomSize + + if (str(logLevel) == "LoggingLevel.Off"): + self.verbose = 0 + if (str(logLevel) == "LoggingLevel.Info"): + self.verbose = 1 + if (str(logLevel) == "LoggingLevel.Warning" or str(logLevel) == "LoggingLevel.Error"): + self.verbose = 2 + if (str(logLevel) == "LoggingLevel.Debug"): + self.verbose = 3 + + if self.verbose > 0: + print("[Profile-based searcher info] Loaded model file", modelFile) + print("[Profile-based searcher info] Batch size set to", batchSize) + print("[Profile-based searcher info] Neighbor size set to", neighborSize) + print("[Profile-based searcher info] Random size set to", randomSize) + print("[Profile-based searcher info] Log level set to", logLevel) + + +# GetUniqueConfigurations +# takes a list and returns a list that does not contain repeating configurations + def GetUniqueConfigurations(self, configurations): + uniqueConfigurations = [] + indicesConfigurations = [] + uniqueIndicesConfigurations = [] + for c in configurations: + indicesConfigurations.append(self.GetIndex(c)) + uniqueIndicesConfigurations = list(set(indicesConfigurations)) + + for i in uniqueIndicesConfigurations: + uniqueConfigurations.append(self.GetConfiguration(i)) + return uniqueConfigurations + +# CalculateNextConfiguration +# determines the next configuration that KTT subsequently runs or profiles + def CalculateNextConfiguration(self, previousResult): + if (previousResult.IsValid()) and ((self.bestConf == None) or (previousResult.GetKernelDuration() < self.bestDuration)) : + self.bestDuration = previousResult.GetKernelDuration() + self.bestConf = self.currentConfiguration + if self.verbose > 1: + print("[Profile-based searcher details] Found new best configuration", self.GetIndex(self.bestConf), "with kernel time", self.bestDuration/1000, "us", flush = True) + + # if we still have configurations in the batch + if len(self.preselectedBatch) > 0: + if self.verbose > 1: + print("[Profile-based searcher details] PreselectedBatch has", len(self.preselectedBatch), "remaining items:", getConfigurationIndices(self, self.preselectedBatch), flush = True) + # just take one from the top and run that + self.currentConfiguration = self.preselectedBatch.pop(0) + # if we have an empty batch and we don't have any best configuration from it (invalid configurations, failed compilation, runtime, or validation) + elif self.bestConf == None: + if self.verbose > 1: + print("[Profile-based searcher details] Preselected batch contained invalid configurations only, generating random one.") + # initialize the batch, make sure it includes unique, i.e. non-repeating configurations + count = 0 + maxBatchSize = min(self.batchSize, self.GetUnexploredConfigurationsCount()) + while count < maxBatchSize: + for i in range (count, maxBatchSize) : + self.preselectedBatch.append(self.GetRandomConfiguration()) + self.preselectedBatch = self.GetUniqueConfigurations(self.preselectedBatch) + count = len(self.preselectedBatch) + if self.verbose > 0: + print("[Profile-based searcher info] Batch generated with configurations ", getConfigurationIndices(self, self.preselectedBatch)) + # select configuration and remove it from batch + self.currentConfiguration = self.preselectedBatch.pop(0) + # if we have an empty batch and we have the fastest configuration from it + else: + if self.verbose > 1: + print("[Profile-based searcher details] Preselected batch empty", flush = True) + if self.bestDuration != -1 : + # we run the fastest one once again, but with profiling + self.currentConfiguration = self.bestConf + self.bestDuration = -1 + self.tuner.SetProfiling(True) + if self.verbose > 0 : + print("[Profile-based searcher info] Running profiling for the best configuration from the batch, configuration", str(self.GetIndex(self.currentConfiguration)), flush = True) + # this happens when the fastest configuration is the last one, e.g. with batchSize == 1, then we just take profiling info from the last run + else : + # get PCs from the last tuning run + if len(previousResult.GetResults()) > 1: + print("Profile-based searcher warning: this version of profile-based searcher does not support searching kernels collections. Using counters from kernels 0 only.") + globalSize = previousResult.GetResults()[0].GetGlobalSize() + localSize = previousResult.GetResults()[0].GetLocalSize() + profilingCountersRun = previousResult.GetResults()[0].GetProfilingData().GetCounters() #FIXME this supposes there is no composition profiled + pcNames = ["Global size", "Local size"] + pcVals = [globalSize.GetTotalSize()*localSize.GetTotalSize(), localSize.GetTotalSize()] + for pd in profilingCountersRun : + pcNames.append(pd.GetName()) + if (pd.GetType() == ktt.ProfilingCounterType.Int) : + pcVals.append(pd.GetValueInt()) + elif (pd.GetType() == ktt.ProfilingCounterType.UnsignedInt) or (pd.GetType() == ktt.ProfilingCounterType.Throughput) or (pd.GetType() == ktt.ProfilingCounterType.UtilizationLevel): + pcVals.append(pd.GetValueUint()) + elif (pd.GetType() == ktt.ProfilingCounterType.Double) or (pd.GetType() == ktt.ProfilingCounterType.Percent) : + pcVals.append(pd.GetValueDouble()) + else : + print("Fatal error, unsupported PC value passed to profile-based searcher!") + exit(1) + + # candidates pool generation + # select candidate configurations according to position of the best one plus some random sample + candidates = self.GetNeighbourConfigurations(self.bestConf, NEIGHBOR_DISTANCE, self.neighborSize) + # make sure we don't have repeating configurations in the candidates list + candidates = self.GetUniqueConfigurations(candidates) + # number of candidates needs to decrease at the end of the search, as we don't have enough unexplored configurations + maxPossibleCandidatesSize = min(len(candidates) + self.randomSize, self.GetUnexploredConfigurationsCount()) + # add random configurations to fill up the candidates pool + count = len(candidates) + while count < maxPossibleCandidatesSize: + for i in range (count, maxPossibleCandidatesSize) : + candidates.append(self.GetRandomConfiguration()) + candidates = self.GetUniqueConfigurations(candidates) + count = len(candidates) + + + if self.verbose > 1: + print("[Profile-based searcher details] Evaluating model for", str(len(candidates)), "candidates...", flush = True) + + # create a small tuning space from candidates + candidatesTuningSpace = [] + for c in candidates : + tp = c.GetPairs() + candidateParams = [] + for p in tp : + candidateParams.append(p.GetValue()) + candidatesTuningSpace.append(candidateParams) + myTuningSpace = [] + tp = self.bestConf.GetPairs() + for p in tp : + myTuningSpace.append(p.GetValue()) + + + # score the configurations + scoreDistrib = [1.0]*len(candidates) + bottlenecks = analyzeBottlenecks(pcNames, pcVals, self.cc, self.multiprocessors, self.convertSM2Cores() * self.multiprocessors, self.verbose) + changes = computeChanges(bottlenecks, self.modelMetadata['pc'], self.modelMetadata['cc'], self.verbose) + scoreDistrib = scoreTuningConfigurationsPredictor(changes, self.tuningParametersReorderingFromSearchSpaceToModel, myTuningSpace, candidatesTuningSpace, scoreDistrib, self.model, self.verbose) + + if self.verbose > 2: + print("[Profile-based searcher debug] Scoring of the candidates done.", flush = True) + + # select next batch + selectedIndices = [] + # if we have more candidates than batchSize, use weightedRandom to choose from them, biasing with score + if len(candidates) > self.batchSize : + numInBatch = 0 + while numInBatch < self.batchSize : + idx = weightedRandomSearchStep(scoreDistrib, len(candidates)) + #check if we have not chosen the same configuration in previous iterations + if selectedIndices == [] or idx not in selectedIndices: + self.preselectedBatch.append(candidates[idx]) + selectedIndices.append(idx) + numInBatch = numInBatch + 1 + scoreDistrib[idx] = 0.0 + # if we have less candidates than batchSize, just put them all in batch + else: + for i in range(0, len(candidates)): + self.preselectedBatch.append(candidates[i]) + + if self.verbose > 0: + print("[Profile-based searcher info] Turning off profiling, new batch selected with length", len(self.preselectedBatch), "containing configurations:", getConfigurationIndices(self, self.preselectedBatch), flush = True) + + # select configuration and remove it from batch + self.currentConfiguration = self.preselectedBatch.pop(0) + self.bestConf = None + self.tuner.SetProfiling(False) + + return True + + def GetCurrentConfiguration(self): + return self.currentConfiguration + + def convertSM2Cores(self): + smToCoresDict = { + 0x30: 192, + 0x32: 192, + 0x35: 192, + 0x37: 192, + 0x50: 128, + 0x52: 128, + 0x53: 128, + 0x60: 64, + 0x61: 128, + 0x62: 128, + 0x70: 64, + 0x72: 64, + 0x75: 64, + 0x80: 64, + 0x86: 64 + } + defaultSM = 64 + + compact = (self.ccMajor << 4) + self.ccMinor + if compact in smToCoresDict: + return smToCoresDict[compact] + else: + print("Warning: unknown number of cores for SM " + str(self.ccMajor) + "." + str(self.ccMinor) + ", using default value of " + str(defaultSM)) + return defaultSM + +def executeSearcher(tuner, kernel, model, batchSize, neighborSize, randomSize, logLevel): + searcher = PyProfilingSearcher() + tuner.SetSearcher(kernel, searcher) + searcher.Configure(tuner, model, batchSize, neighborSize, randomSize, logLevel) +)"; \ No newline at end of file diff --git a/Scripts/ProfileBasedSearcher.py b/Scripts/OldProfileSearcher/ProfileBasedSearcher.py similarity index 100% rename from Scripts/ProfileBasedSearcher.py rename to Scripts/OldProfileSearcher/ProfileBasedSearcher.py diff --git a/Scripts/StringifyOutput.h b/Scripts/StringifyOutput.h deleted file mode 100644 index afb8bead..00000000 --- a/Scripts/StringifyOutput.h +++ /dev/null @@ -1,882 +0,0 @@ -std::string() + -"#!/usr/bin/env python -W ignore::DeprecationWarning\n" + -"\n" + -"'''\n" + -"Searcher which explores configurations according to observed bottlenecks\n" + -"and ML model created on historical data (on the same tuning space, but\n" + -"possibly different HW and input size). For more information, see\n" + -"J. Filipovic et al. Using hardware performance counters to speed up\n" + -"autotuning convergence on GPUs. JPDC, vol. 160, 2021.\n" + -"'''\n" + -"\n" + -"import random\n" + -"import csv\n" + -"import pickle\n" + -"import numpy as np\n" + -"import signal\n" + -"import pdb\n" + -"import json\n" + -"import warnings\n" + -"\n" + -"import pyktt as ktt\n" + -"\n" + -"np.printoptions(precision=5, suppress=True)\n" + -"\n" + -"# verbosity level (0, 1, 2, 3)\n" + -"# 0 - nothing\n" + -"# 1 - info\n" + -"# 2 - more info\n" + -"# 3 - debug\n" + -"\n" + -"# all constant used by the searcher\n" + -"# CORR_SHIFT: value added to correlation (positive forces to search parameters with weak correlation but strong variation)\n" + -"# EXP: exponent used to prioritize configurations with high score (probab = score ^ EXP, where score is in <0, 1> )\n" + -"# REACT_TO_INST_BOTTLENECKS: minimal instructions bottlenecks, which affects scoring of tuning configurations\n" + -"# CUTOFF: maximal score of configurations, which are discarded from tuning space\n" + -"# BATCH: number of configuration from which the fastest one is profiled, set in KTT\n" + -"# NEIGHBOR_SIZE: number of neighboring configurations that are used for batch selection, set in KTT\n" + -"# RANDOM_SIZE: number of random configurations that are used for batch selection, set in KTT\n" + -"# NEIGHBOR_DISTANCE: distance between configurations (how many TP have different values) that are still considered neighbors\n" + -"CORR_SHIFT = 0.0\n" + -"EXP = 8\n" + -"REACT_TO_INST_BOTTLENECKS = 0.7\n" + -"CUTOFF = -0.25\n" + -"NEIGHBOR_DISTANCE = 2\n" + -"\n" + -"########################### loading models functions ################################\n" + -"\n" + -"def loadMLModel(trainedKnowledgeBase):\n" + -" return pickle.load(open(trainedKnowledgeBase, 'rb'))\n" + -"\n" + -"def loadMLModelMetadata(filename) :\n" + -" metadata = {}\n" + -" with open(filename, 'r') as metadataFile:\n" + -" metadata = json.load(metadataFile)\n" + -" return metadata\n" + -"\n" + -"def loadCompleteMappingCounters(tuningSpace, rangeC) :\n" + -" words = tuningSpace.readline().split(',')\n" + -" counters = []\n" + -" #for i in range(tuningInt[1]+1, len(words)) :\n" + -" for i in rangeC :\n" + -" if i < len(words) :\n" + -" counters.append(words[i].rstrip())\n" + -" for j in range(i+1, len(words)) :\n" + -" counters.append(words[j].rstrip())\n" + -"\n" + -" return counters\n" + -"\n" + -"\n" + -"def loadCompleteMapping(tuningSpace, rangeT, rangeC) :\n" + -" tuningSpace.seek(0)\n" + -" wordsHead = tuningSpace.readline().split(',')\n" + -" #pcInt = [tuningInt[1]+1, len(wordsHead)-1]\n" + -" myRange = []\n" + -" for i in rangeC :\n" + -" if i < len(wordsHead) :\n" + -" myRange.append(i)\n" + -" restPCs = list(range(rangeC[-1]+1, len(wordsHead)))\n" + -" pcInt = myRange + restPCs\n" + -"\n" + -" space = []\n" + -" for line in tuningSpace.readlines() :\n" + -" words = line.split(',')\n" + -" if len(words) <= 1: break\n" + -"\n" + -" tunRow = []\n" + -" #for i in range(tuningInt[0], tuningInt[1]+1) :\n" + -" for i in rangeT :\n" + -" tunRow.append(float(words[i]))\n" + -" #pcRow = {}\n" + -" #for i in range(pcInt[0], pcInt[1]+1) :\n" + -" # pcRow[wordsHead[i].rstrip()] = float(words[i])\n" + -" pcRow = []\n" + -" #for i in range(pcInt[0], pcInt[1]+1) :\n" + -" for i in pcInt :\n" + -" pcRow.append(float(words[i]))\n" + -"\n" + -" spaceRow = [tunRow, pcRow]\n" + -" space.append(spaceRow)\n" + -"\n" + -" return space\n" + -"\n" + -"\n" + -"####################### GPU arch. dependent functions ##########################\n" + -"\n" + -"# analyzeBottlenecks\n" + -"# analysis of bottlenecks, observes profiling counters and scores bottlenecks\n" + -"# in interval <0, 1>\n" + -"# GPU dependent, implemented for CUDA compute capabilities 3.0 - 7.5\n" + -"\n" + -"def analyzeBottlenecks (countersNames, countersData, cc, multiprocessors, cores, verbose):\n" + -" bottlenecks = {}\n" + -" # analyze global memory\n" + -" if cc < 7.0 :\n" + -" DRAMutil = countersData[countersNames.index(\"dram_utilization\")]\n" + -" DRAMldTrans = countersData[countersNames.index(\"dram_read_transactions\")]\n" + -" DRAMstTrans = countersData[countersNames.index(\"dram_write_transactions\")]\n" + -" else :\n" + -" DRAMutil = countersData[countersNames.index(\"dram__throughput.avg.pct_of_peak_sustained_elapsed\")]/10.0\n" + -" DRAMldTrans = countersData[countersNames.index(\"dram__sectors_read.sum\")]\n" + -" DRAMstTrans = countersData[countersNames.index(\"dram__sectors_write.sum\")]\n" + -" if DRAMldTrans + DRAMstTrans > 0 and DRAMutil > 0 :\n" + -" bnDRAMRead = (DRAMldTrans / (DRAMldTrans + DRAMstTrans)) * (DRAMutil / 10.0)\n" + -" bnDRAMWrite = (DRAMstTrans / (DRAMldTrans + DRAMstTrans)) * (DRAMutil / 10.0)\n" + -" else :\n" + -" bnDRAMRead = 0\n" + -" bnDRAMWrite = 0\n" + -" bottlenecks['bnDRAMRead'] = bnDRAMRead\n" + -" bottlenecks['bnDRAMWrite'] = bnDRAMWrite\n" + -"\n" + -" # analyze cache system\n" + -" if cc < 7.0 :\n" + -" L2util = countersData[countersNames.index(\"l2_utilization\")]\n" + -" L2ldTrans = countersData[countersNames.index(\"l2_read_transactions\")]\n" + -" L2stTrans = countersData[countersNames.index(\"l2_write_transactions\")]\n" + -" texUtil = countersData[countersNames.index(\"tex_utilization\")]\n" + -" #texFuUtil = countersData[countersNames.index(\"tex_fu_utilization\")]\n" + -" texTrans = countersData[countersNames.index(\"tex_cache_transactions\")]\n" + -" else :\n" + -" L2util = countersData[countersNames.index(\"lts__t_sectors.avg.pct_of_peak_sustained_elapsed\")]/10.0\n" + -" L2ldTrans = countersData[countersNames.index(\"lts__t_sectors_op_read.sum\")]\n" + -" L2stTrans = countersData[countersNames.index(\"lts__t_sectors_op_write.sum\")]\n" + -" texUtil = countersData[countersNames.index(\"l1tex__t_requests_pipe_lsu_mem_global_op_ld.avg.pct_of_peak_sustained_active\")]/10.0\n" + -" #texFuUtil = countersData[countersNames.index(\"tex_fu_utilization\")]\n" + -" texTrans = countersData[countersNames.index(\"l1tex__t_requests_pipe_lsu_mem_global_op_ld.sum\")]\n" + -" bnL2Read = (L2ldTrans / (L2ldTrans + L2stTrans)) * (L2util / 10.0)\n" + -" bnL2Write = (L2stTrans / (L2ldTrans + L2stTrans)) * (L2util / 10.0)\n" + -" #bnTex = max(texUtil / 10.0, texFuUtil / 10.0)\n" + -" bnTex = texUtil / 10.0\n" + -" bottlenecks['bnL2Read'] = bnL2Read\n" + -" bottlenecks['bnL2Write'] = bnL2Write\n" + -" bottlenecks['bnTex'] = bnTex\n" + -"\n" + -" # analyze local (non-registers private in OpenCL) memory\n" + -" if cc < 7.0 :\n" + -" locOverhead = countersData[countersNames.index(\"local_memory_overhead\")]\n" + -" else :\n" + -" #XXX this is highly experimental computation\n" + -" locOverhead = 100.0 * countersNames.index(\"l1tex__t_sectors_pipe_lsu_mem_local_op_st.sum\") / L2stTrans\n" + -" bottlenecks['bnLocal'] = (locOverhead/100.0) * max(DRAMutil/10.0, L2util/10.0, texUtil/10.0)#, texFuUtil/10.0)\n" + -"\n" + -" # analyze shared memory\n" + -" if cc < 7.0 :\n" + -" if cc < 4.0 :\n" + -" SMutil = countersData[countersNames.index(\"shared_efficiency\")]\n" + -" else :\n" + -" SMutil = countersData[countersNames.index(\"shared_utilization\")]\n" + -" SMldTrans = countersData[countersNames.index(\"shared_load_transactions\")]\n" + -" SMstTrans = countersData[countersNames.index(\"shared_store_transactions\")]\n" + -" else :\n" + -" SMutil = countersData[countersNames.index(\"l1tex__data_pipe_lsu_wavefronts_mem_shared.avg.pct_of_peak_sustained_elapsed\")]/10.0\n" + -" SMldTrans = countersData[countersNames.index(\"l1tex__data_pipe_lsu_wavefronts_mem_shared_op_ld.sum\")]\n" + -" SMstTrans = countersData[countersNames.index(\"l1tex__data_pipe_lsu_wavefronts_mem_shared_op_st.sum\")]\n" + -"\n" + -" if (SMldTrans + SMstTrans > 0):\n" + -" bnSMRead = (SMldTrans / (SMldTrans + SMstTrans)) * (SMutil / 10.0)\n" + -" bnSMWrite = (SMstTrans / (SMldTrans + SMstTrans)) * (SMutil / 10.0)\n" + -" else:\n" + -" bnSMRead = 0\n" + -" bnSMWrite = 0\n" + -" bottlenecks['bnSMRead'] = bnSMRead\n" + -" bottlenecks['bnSMWrite'] = bnSMWrite\n" + -"\n" + -" # analyze multiprocessor parallelism\n" + -" if cc < 7.0 :\n" + -" occupancy = countersData[countersNames.index(\"achieved_occupancy\")]\n" + -" else :\n" + -" occupancy = countersData[countersNames.index(\"sm__warps_active.avg.pct_of_peak_sustained_active\")]/100.0\n" + -" bnMPparal = 1.0 - occupancy\n" + -" bottlenecks['bnMPparal'] = bnMPparal\n" + -"\n" + -" # analyze global parallelism\n" + -" if cc < 7.0 :\n" + -" smEfficiency = 100.0 #countersData[countersNames.index(\"sm_efficiency\")] #commented-out as with driver 515.65.01 and CUDA 11.7, sm_efficiency shows weird behaviour\n" + -" else :\n" + -" smEfficiency = countersData[countersNames.index(\"smsp__cycles_active.avg.pct_of_peak_sustained_elapsed\")]\n" + -" bnGparal = (100.0 - smEfficiency) / 100.0\n" + -" bottlenecks['bnGparal'] = bnGparal\n" + -"\n" + -" threadBlocks = countersData[countersNames.index(\"Global size\")] / countersData[countersNames.index(\"Local size\")]\n" + -" bnTailEffect = 1 - (threadBlocks / (((threadBlocks + multiprocessors-1) / multiprocessors) * multiprocessors))\n" + -" bottlenecks['bnTailEffect'] = bnTailEffect\n" + -" #print(bnTailEffect, threadBlocks, countersData[countersNames.index(\"Global size\")], countersData[countersNames.index(\"Local size\")])\n" + -"\n" + -" bnThreads = max(0, (cores * 5 - countersData[countersNames.index(\"Global size\")]) / (cores * 5))\n" + -" bottlenecks['bnThreads'] = bnThreads\n" + -"\n" + -" # analyze instructions\n" + -" # insctruction counts\n" + -" if cc < 7.0 :\n" + -" spInstr = countersData[countersNames.index(\"inst_fp_32\")]\n" + -" dpInstr = countersData[countersNames.index(\"inst_fp_64\")]\n" + -" intInstr = countersData[countersNames.index(\"inst_integer\")]\n" + -" #commInstr = countersData[countersNames.index(\"inst_inter_thread_communication\")]\n" + -" miscInstr = countersData[countersNames.index(\"inst_misc\")]\n" + -" ldstInstr = countersData[countersNames.index(\"inst_compute_ld_st\")]\n" + -" ctrlInst = countersData[countersNames.index(\"inst_control\")]\n" + -" bconvInstr = countersData[countersNames.index(\"inst_bit_convert\")]\n" + -" execInstr = countersData[countersNames.index(\"inst_executed\")]\n" + -" else :\n" + -" spInstr = countersData[countersNames.index(\"smsp__sass_thread_inst_executed_op_fp32_pred_on.sum\")]\n" + -" dpInstr = countersData[countersNames.index(\"smsp__sass_thread_inst_executed_op_fp64_pred_on.sum\")]\n" + -" intInstr = countersData[countersNames.index(\"smsp__sass_thread_inst_executed_op_integer_pred_on.sum\")]\n" + -" #commInstr = countersData[countersNames.index(\"inst_inter_thread_communication\")]\n" + -" miscInstr = countersData[countersNames.index(\"smsp__sass_thread_inst_executed_op_misc_pred_on.sum\")]\n" + -" ldstInstr = countersData[countersNames.index(\"smsp__sass_thread_inst_executed_op_memory_pred_on.sum\")]\n" + -" ctrlInst = countersData[countersNames.index(\"smsp__sass_thread_inst_executed_op_control_pred_on.sum\")]\n" + -" bconvInstr = countersData[countersNames.index(\"smsp__sass_thread_inst_executed_op_conversion_pred_on.sum\")]\n" + -" execInstr = countersData[countersNames.index(\"smsp__inst_executed.sum\")]\n" + -"\n" + -" #instruction utilization\n" + -" if cc < 7.0 :\n" + -" if cc < 4.0 :\n" + -" spUtil = countersData[countersNames.index(\"flop_sp_efficiency\")]\n" + -" dpUtil = countersData[countersNames.index(\"flop_dp_efficiency\")]\n" + -" sfuUtil = 0 #XXX we don't have this counter\n" + -" else :\n" + -" spUtil = countersData[countersNames.index(\"single_precision_fu_utilization\")]\n" + -" dpUtil = countersData[countersNames.index(\"double_precision_fu_utilization\")]\n" + -" sfuUtil = countersData[countersNames.index(\"special_fu_utilization\")]\n" + -" cfUtil = countersData[countersNames.index(\"cf_fu_utilization\")]\n" + -" ldstUtil = countersData[countersNames.index(\"ldst_fu_utilization\")]\n" + -" texFuUtil = countersData[countersNames.index(\"tex_fu_utilization\")]\n" + -" instrSlotUtil = countersData[countersNames.index(\"issue_slot_utilization\")]\n" + -" if cc >= 4.0 :\n" + -" instrEffExec = countersData[countersNames.index(\"warp_execution_efficiency\")]\n" + -" instrEffPred = countersData[countersNames.index(\"warp_nonpred_execution_efficiency\")]\n" + -" else :\n" + -" instrEffExec = 100\n" + -" instrEffPred = 100\n" + -" else :\n" + -" spUtil = countersData[countersNames.index(\"smsp__pipe_fma_cycles_active.avg.pct_of_peak_sustained_active\")]/10.0\n" + -" dpUtil = countersData[countersNames.index(\"smsp__inst_executed_pipe_fp64.avg.pct_of_peak_sustained_active\")]/10.0\n" + -" sfuUtil = countersData[countersNames.index(\"smsp__inst_executed_pipe_xu.avg.pct_of_peak_sustained_active\")]/10.0\n" + -" cfUtil = 0.0 #XXX we don't have this counter\n" + -" ldstUtil = countersData[countersNames.index(\"smsp__inst_executed_pipe_lsu.avg.pct_of_peak_sustained_active\")]/10.0\n" + -" texFuUtil = countersData[countersNames.index(\"smsp__inst_executed_pipe_tex.avg.pct_of_peak_sustained_active\")]/10.0\n" + -" instrSlotUtil = countersData[countersNames.index(\"smsp__issue_active.avg.pct_of_peak_sustained_active\")]\n" + -" instrEffExec = countersData[countersNames.index(\"smsp__thread_inst_executed_per_inst_executed.ratio\")]*100.0/32.0\n" + -" instrEffPred = countersData[countersNames.index(\"smsp__thread_inst_executed_per_inst_executed.pct\")]\n" + -"\n" + -" instrExecFitted = execInstr*32.0 * (100.0/instrEffExec) * (100.0/instrEffPred) #XXX this should be equal to spInstr+dpInstr+intInstr+miscInstr+ldstInstr+ctrlInst+bconvInstr\n" + -" if cc < 7.0 :\n" + -" instrUtilFitted = instrSlotUtil/100.0\n" + -" else :\n" + -" instrUtilFitted = min(1.0, instrSlotUtil/50.0) # dual-issue causes max 50% utilization of instruction of single type\n" + -"\n" + -" spUtilApprox = (spInstr/instrExecFitted) * instrUtilFitted\n" + -" dpUtilApprox = (dpInstr/instrExecFitted) * instrUtilFitted\n" + -" ldstUtilApprox = (ldstInstr/instrExecFitted) * instrUtilFitted\n" + -" cfUtilApprox = (ctrlInst/instrExecFitted) * instrUtilFitted\n" + -" intUtilApprox = (intInstr/instrExecFitted) * instrUtilFitted\n" + -" miscUtilApprox = (miscInstr/instrExecFitted) * instrUtilFitted\n" + -" bconvUtilApprox = (bconvInstr/instrExecFitted) * instrUtilFitted\n" + -"\n" + -" #print(\"single_precision_fu_utilization reported/computed: \", spUtil, (spInstr/instrExecFitted) * instrUtilFitted)\n" + -"# #workaround is to bottleneck instructions only if utilization is significant\n" + -"# maxUtil = max(spUtil, dpUtil, cfUtil)\n" + -"# maxUtilInst = max(spInstr, dpInstr, ctrlInst) #XXX should select the same category as the line above\n" + -"# if maxUtil > 6:\n" + -"# intUtilApprox = intInstr/maxUtilInst * maxUtil\n" + -"# miscUtilApprox = miscInstr/maxUtilInst * maxUtil\n" + -"# bconvUtilApprox = bconvInstr/maxUtilInst * maxUtil\n" + -"# else:\n" + -"# intUtilApprox = 0.0\n" + -"# miscUtilApprox = 0.0\n" + -"# bconvUtilApprox = 0.0\n" + -"\n" + -"# bnSP = spUtil/10.0\n" + -" bnSP = spUtilApprox\n" + -"# bnDP = dpUtil/10.0\n" + -" bnDP = dpUtilApprox\n" + -" bnSFU = sfuUtil/10.0\n" + -"# bnCF = cfUtil/10.0\n" + -" bnCF = cfUtilApprox\n" + -"# bnLDST = ldstUtil/10.0\n" + -" bnLDST = ldstUtilApprox\n" + -" bnTexFu = texFuUtil/10.0\n" + -" bnInt = intUtilApprox\n" + -" bnMisc = miscUtilApprox\n" + -" bnBconv = bconvUtilApprox\n" + -"\n" + -" bottlenecks['bnSP'] = bnSP\n" + -" bottlenecks['bnDP'] = bnDP\n" + -" bottlenecks['bnSFU'] = bnSFU\n" + -" bottlenecks['bnCF'] = bnCF\n" + -" bottlenecks['bnLDST'] = bnLDST\n" + -" bottlenecks['bnTexFu'] = bnTexFu\n" + -" bottlenecks['bnInt'] = bnInt\n" + -" bottlenecks['bnMisc'] = bnMisc\n" + -" bottlenecks['bnBconv'] = bnBconv\n" + -"\n" + -" issueWeight = 0.0\n" + -" maxInstrUtil = max(spUtilApprox/instrUtilFitted, dpUtilApprox/instrUtilFitted, sfuUtil/10.0, cfUtilApprox/instrUtilFitted, ldstUtilApprox/instrUtilFitted, intUtilApprox/instrUtilFitted, miscUtilApprox/instrUtilFitted, bconvUtilApprox/instrUtilFitted)\n" + -" if maxInstrUtil > REACT_TO_INST_BOTTLENECKS :\n" + -" issueWeight = (maxInstrUtil - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" bnInstIssue = (100.0 - instrSlotUtil) / 100 * issueWeight\n" + -" #bnInstIssue = (100.0 - instrSlotUtil) / 100 * max(spUtilApprox/instrUtilFitted, dpUtilApprox/instrUtilFitted, sfuUtil/instrUtilFitted/10.0, cfUtilApprox/instrUtilFitted, ldstUtilApprox/instrUtilFitted, texFuUtil/instrUtilFitted/10.0, intUtilApprox/instrUtilFitted, miscUtilApprox/instrUtilFitted, bconvUtilApprox/instrUtilFitted)\n" + -" bottlenecks['bnInstIssue'] = bnInstIssue\n" + -"\n" + -" if verbose > 1 :\n" + -" print(\"[Profile-based searcher details] bottlenecks:\", bottlenecks)\n" + -"\n" + -" return bottlenecks\n" + -"\n" + -"# computeChanges\n" + -"# computes how to change profiling counters according to bottlenecks\n" + -"# absolute value of computed changes means its importance, the sign means\n" + -"# required direction (increase/decrease the counter)\n" + -"# GPU dependent, implemented for CUDA compute capabilities 3.0 - 7.5\n" + -"# Note: this function is separated from analyzeBottlenecks in order to manage\n" + -"# portability across arch. easily (computed bottlenecks are arch. independent)\n" + -"\n" + -"def computeChanges(bottlenecks, countersNames, cc, verbose):\n" + -" # set how important is to change particular profiling counters\n" + -" changeImportance = [0.0]*len(countersNames)\n" + -"\n" + -" # memory-subsystem related counters\n" + -" if cc < 7.0 :\n" + -" changeImportance[countersNames.index('dram_read_transactions')] = - bottlenecks['bnDRAMRead']\n" + -" changeImportance[countersNames.index('dram_write_transactions')] = - bottlenecks['bnDRAMWrite']\n" + -" changeImportance[countersNames.index('l2_read_transactions')] = - bottlenecks['bnL2Read']\n" + -" changeImportance[countersNames.index('l2_write_transactions')] = - bottlenecks['bnL2Write']\n" + -" changeImportance[countersNames.index('tex_cache_transactions')] = - bottlenecks['bnTex']\n" + -" changeImportance[countersNames.index('local_memory_overhead')] = - bottlenecks['bnLocal']\n" + -" changeImportance[countersNames.index('shared_load_transactions')] = - bottlenecks['bnSMRead']\n" + -" changeImportance[countersNames.index('shared_store_transactions')] = - bottlenecks['bnSMWrite']\n" + -" else:\n" + -" changeImportance[countersNames.index('dram__sectors_read.sum')] = - bottlenecks['bnDRAMRead']\n" + -" changeImportance[countersNames.index('dram__sectors_write.sum')] = - bottlenecks['bnDRAMWrite']\n" + -" changeImportance[countersNames.index('lts__t_sectors_op_read.sum')] = - bottlenecks['bnL2Read']\n" + -" changeImportance[countersNames.index('lts__t_sectors_op_write.sum')] = - bottlenecks['bnL2Write']\n" + -" #TODO solve additive counters more elegantly?\n" + -" changeImportance[countersNames.index('l1tex__t_requests_pipe_lsu_mem_global_op_ld.sum')] = - bottlenecks['bnTex']\n" + -" changeImportance[countersNames.index('l1tex__t_sectors_pipe_lsu_mem_local_op_ld.sum')] = - bottlenecks['bnLocal']\n" + -" changeImportance[countersNames.index('l1tex__t_sectors_pipe_lsu_mem_local_op_st.sum')] = - bottlenecks['bnLocal']\n" + -" changeImportance[countersNames.index('l1tex__data_pipe_lsu_wavefronts_mem_shared_op_ld.sum')] = - bottlenecks['bnSMRead']\n" + -" changeImportance[countersNames.index('l1tex__data_pipe_lsu_wavefronts_mem_shared_op_st.sum')] = - bottlenecks['bnSMWrite']\n" + -"\n" + -" # instructions related counters\n" + -" if cc < 7.0 :\n" + -" if bottlenecks['bnSP'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('inst_fp_32')] = - (bottlenecks['bnSP'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" changeImportance[countersNames.index('flop_sp_efficiency')] = (bottlenecks['bnSP'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" if bottlenecks['bnDP'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('inst_fp_64')] = - (bottlenecks['bnDP']- REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" #changeImportance[countersNames.index('special_fu_utilization')] = + bottlenecks['bnSFU'] #TODO how to count SFU instructions?\n" + -" if bottlenecks['bnCF'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('inst_control')] = - (bottlenecks['bnCF'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" if bottlenecks['bnLDST'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('inst_compute_ld_st')] = - (bottlenecks['bnLDST'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" #changeImportance[countersNames.index('tex_fu_utilization')] = + bottlenecks['bnTexFu']\n" + -" if bottlenecks['bnInt'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('inst_integer')] = - (bottlenecks['bnInt'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" if bottlenecks['bnMisc'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('inst_misc')] = - (bottlenecks['bnMisc'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" if bottlenecks['bnBconv'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('inst_bit_convert')] = - (bottlenecks['bnBconv'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" #if bottlenecks['bnInstIssue'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('issue_slot_utilization')] = bottlenecks['bnInstIssue'] #(bottlenecks['bnInstIssue'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" else :\n" + -" if bottlenecks['bnSP'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_fp32_pred_on.sum')] = - bottlenecks['bnSP']\n" + -" if bottlenecks['bnDP'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_fp64_pred_on.sum')] = - bottlenecks['bnDP']\n" + -" #changeImportance[countersNames.index('special_fu_utilization')] = + bottlenecks['bnSFU'] #TODO how to count SFU instructions?\n" + -" if bottlenecks['bnCF'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_control_pred_on.sum')] = - (bottlenecks['bnCF'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" if bottlenecks['bnLDST'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_memory_pred_on.sum')] = - (bottlenecks['bnLDST'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" #changeImportance[countersNames.index('tex_fu_utilization')] = + bottlenecks['bnTexFu']\n" + -" if bottlenecks['bnInt'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_integer_pred_on.sum')] = - (bottlenecks['bnInt'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" if bottlenecks['bnMisc'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_misc_pred_on.sum')] = - (bottlenecks['bnMisc'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" if bottlenecks['bnBconv'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('smsp__sass_thread_inst_executed_op_conversion_pred_on.sum')] = - (bottlenecks['bnBconv'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -" #if bottlenecks['bnInstIssue'] > REACT_TO_INST_BOTTLENECKS :\n" + -" changeImportance[countersNames.index('smsp__issue_active.avg.pct_of_peak_sustained_active')] = bottlenecks['bnInstIssue'] #(bottlenecks['bnInstIssue'] - REACT_TO_INST_BOTTLENECKS) / (1.0 - REACT_TO_INST_BOTTLENECKS)\n" + -"\n" + -" #parallelism related counters\n" + -" if cc < 7.0 :\n" + -" changeImportance[countersNames.index('sm_efficiency')] = bottlenecks['bnGparal']\n" + -" else :\n" + -" changeImportance[countersNames.index('smsp__cycles_active.avg.pct_of_peak_sustained_elapsed')] = bottlenecks['bnGparal']\n" + -"\n" + -" changeImportance[countersNames.index('Global size')] = bottlenecks['bnThreads']#bottlenecks['bnTailEffect'] + bottlenecks['bnThreads']\n" + -" #changeImportance[countersNames.index('Local size')] = - bottlenecks['bnTailEffect'] / 2\n" + -"\n" + -" if verbose > 1 :\n" + -" print(\"[Profile-based searcher details] changeImportance:\", changeImportance)\n" + -"\n" + -" return changeImportance\n" + -"\n" + -"###################### GPU arch. independent functions #########################\n" + -"\n" + -"# scoreTuningConfigurationsExact\n" + -"# scores all tuning configurations according to required changes of profiling\n" + -"# counters and expected effect of the tuning parameters to profiling counters\n" + -"# GPU independent\n" + -"# This version uses completely computed offline space\n" + -"\n" + -"def scoreTuningConfigurationsExact(changeImportance, tuningparamsNames, actualConf, tuningSpace, completeMapping, scoreDistrib, verbose):\n" + -" newScoreDistrib = [0.0] * len(tuningSpace)\n" + -" #search index of actualConf in completeMapping (some conf. can be missing, therefore, we need to check tuning parameters)\n" + -" actualPC = []\n" + -" for conf in completeMapping :\n" + -" if actualConf == conf[0] :\n" + -" actualPC = conf[1]\n" + -" if len(actualPC) == 0 :\n" + -" # the configuration is not known in the completeMapping, return uniform distrib\n" + -" for i in range(0, len(tuningSpace)) :\n" + -" uniformScoreDistrib = [1.0] * len(tuningSpace)\n" + -" if scoreDistrib[i] == 0.0 :\n" + -" uniformScoreDistrib[i] = 0.0\n" + -" return uniformScoreDistrib\n" + -"\n" + -" cmIdx = 0\n" + -" # for each tuning configuration\n" + -" for i in range(0, len(tuningSpace)) :\n" + -" #seek for equivalent tuning configuration in the completeMapping\n" + -" #TODO this implementation assumes the same order of tuning configurations, create mapping between indexes instead\n" + -" myPC = []\n" + -" for j in range(cmIdx, len(completeMapping)) :\n" + -" if (tuningSpace[i] == completeMapping[j][0]) :\n" + -" myPC = completeMapping[j][1]\n" + -" cmIdx = j+1\n" + -" break\n" + -" if (len(myPC) == 0) :\n" + -" newScoreDistrib[i] = 0.0\n" + -" else :\n" + -" #score configuration\n" + -" for j in range(0, len(changeImportance)) :\n" + -" try:\n" + -" newScoreDistrib[i] = newScoreDistrib[i] + changeImportance[j] * (myPC[j] - actualPC[j]) / (myPC[j]+actualPC[j])\n" + -" except ZeroDivisionError :\n" + -" newScoreDistrib[i] = newScoreDistrib[i] + 0.0\n" + -"\n" + -" minScore = min(newScoreDistrib)\n" + -" maxScore = max(newScoreDistrib)\n" + -" if verbose > 1 :\n" + -" print(\"[Profile-based searcher details] scoreDistrib interval: \", minScore, maxScore)\n" + -" for i in range(0, len(tuningSpace)) :\n" + -" if newScoreDistrib[i] < CUTOFF :\n" + -" newScoreDistrib[i] = 0.0\n" + -" else :\n" + -" if newScoreDistrib[i] < 0.0 :\n" + -" newScoreDistrib[i] = 1.0 - (newScoreDistrib[i] / minScore)\n" + -" else :\n" + -" if newScoreDistrib[i] > 0.0 :\n" + -" newScoreDistrib[i] = 1.0 + (newScoreDistrib[i] / maxScore)\n" + -" newScoreDistrib[i] = newScoreDistrib[i]**EXP\n" + -" if newScoreDistrib[i] < 0.0001 :\n" + -" newScoreDistrib[i] = 0.0001\n" + -"\n" + -" # if was 0, set to 0 (explored)\n" + -" if scoreDistrib[i] == 0.0 :\n" + -" newScoreDistrib[i] = 0.0\n" + -"\n" + -" if verbose > 2 :\n" + -" print(\"[Profile-based searcher debug] newScoreDistrib\", newScoreDistrib)\n" + -"\n" + -" return newScoreDistrib\n" + -"\n" + -"\n" + -"# scoreTuningConfigurationsPredictor\n" + -"# scores all tuning configurations according to required changes of profiling\n" + -"# counters and expected effect of the tuning parameters to profiling counters\n" + -"# GPU independent\n" + -"# This version uses predictor based on ML model\n" + -"def scoreTuningConfigurationsPredictor(changeImportance, tuningParametersReorderingFromSearchSpaceToModel, actualConf, tuningSpace, scoreDistrib, loaded_model, verbose):\n" + -" def mulfunc(a, b, c):\n" + -" if (a * (b - c)) > 0.0:\n" + -" return 1.0\n" + -" if (a * (b - c)) < 0.0:\n" + -" return -1.0\n" + -" else:\n" + -" return 0.0\n" + -"\n" + -" newScoreDistrib = [0.0] * len(tuningSpace)\n" + -" actualPC = []\n" + -"\n" + -" # Using ML predictor\n" + -" reorderedActualConf = reorderList(actualConf, tuningParametersReorderingFromSearchSpaceToModel)\n" + -" predictedPC = loaded_model.predict([reorderedActualConf])\n" + -" actualPC = list(predictedPC.flatten())\n" + -"\n" + -" if len(actualPC) == 0 :\n" + -" for i in range(0, len(tuningSpace)) :\n" + -" uniformScoreDistrib = [1.0] * len(tuningSpace)\n" + -" if scoreDistrib[i] == 0.0 :\n" + -" uniformScoreDistrib[i] = 0.0\n" + -" return uniformScoreDistrib\n" + -"\n" + -"\n" + -" #################################################### Using ML predictor\n" + -" #reorder the tuning space data so that they are in the correct order\n" + -" # TP from tuning space and T from model might be in different order, thus reordering is necessary\n" + -" reorderedTuningSpace = reorderTuningSpace(tuningSpace, tuningParametersReorderingFromSearchSpaceToModel)\n" + -" predictedMyPC = loaded_model.predict(reorderedTuningSpace)\n" + -" predictedMyPC1 = np.array(predictedMyPC)\n" + -" actualPC1 = np.array(actualPC)\n" + -" n = len(changeImportance) - len(actualPC1)\n" + -" changeImportance = changeImportance[:len(changeImportance)-n]\n" + -" changeImportance1 = np.array(changeImportance)\n" + -"\n" + -" vfunc = np.vectorize(mulfunc)\n" + -" if verbose < 3:\n" + -" # supressing the warning about dividing with zero\n" + -" # nan that results from that is converted to number just below\n" + -" with warnings.catch_warnings():\n" + -" warnings.simplefilter(\"ignore\")\n" + -" mul = vfunc(changeImportance1, predictedMyPC1, actualPC1)\n" + -" res = np.array(mul * abs(changeImportance1 * 2.0 * (predictedMyPC1 - actualPC1) / (predictedMyPC1+actualPC1)))\n" + -" else:\n" + -" mul = vfunc(changeImportance1, predictedMyPC1, actualPC1)\n" + -" res = np.array(mul * abs(changeImportance1 * 2.0 * (predictedMyPC1 - actualPC1) / (predictedMyPC1+actualPC1)))\n" + -" res = np.nan_to_num(res)\n" + -" newScoreDistrib = res.sum(axis=1)\n" + -"\n" + -" minScore = min(newScoreDistrib)\n" + -" maxScore = max(newScoreDistrib)\n" + -" if verbose > 1 :\n" + -" print(\"[Profile-based searcher details] scoreDistrib interval: \", minScore, maxScore)\n" + -" for i in range(0, len(tuningSpace)) :\n" + -" if newScoreDistrib[i] < CUTOFF :\n" + -" newScoreDistrib[i] = 0.0001\n" + -" else :\n" + -" if newScoreDistrib[i] < 0.0 :\n" + -" newScoreDistrib[i] = 1.0 - (newScoreDistrib[i] / minScore)\n" + -" else :\n" + -" if newScoreDistrib[i] > 0.0 :\n" + -" newScoreDistrib[i] = 1.0 + (newScoreDistrib[i] / maxScore)\n" + -" newScoreDistrib[i] = newScoreDistrib[i]**EXP\n" + -" if newScoreDistrib[i] < 0.0001 :\n" + -" newScoreDistrib[i] = 0.0001\n" + -"\n" + -" # if was 0, set to 0 (explored)\n" + -" if scoreDistrib[i] == 0.0 :\n" + -" newScoreDistrib[i] = 0.0\n" + -"\n" + -" if verbose > 2 :\n" + -" print(\"[Profile-based searcher debug] Predictor newScoreDistrib:\", newScoreDistrib)\n" + -"\n" + -" return newScoreDistrib\n" + -"\n" + -"# randomSearchStep\n" + -"# perform one step of random search (without memory)\n" + -"def randomSearchStep(tuningSpaceSize) :\n" + -" return int(random.random() * tuningSpaceSize)\n" + -"\n" + -"# weightedRandomSearchStep\n" + -"# perform one step of random search using weighted probability based on\n" + -"# profiling counters\n" + -"def weightedRandomSearchStep(scoreDistrib, tuningSpaceSize) :\n" + -" if (sum(scoreDistrib) == 0.0) :\n" + -" print(\"Weighted search error: no more tuning configurations.\")\n" + -" return randomSearchStep(tuningSpaceSize)\n" + -"\n" + -" rnd = random.random() * sum(scoreDistrib)\n" + -" idx = 0\n" + -" tmp = 0.0\n" + -" for j in range (0, tuningSpaceSize):\n" + -" tmp = tmp + scoreDistrib[j]\n" + -" if rnd < tmp : break\n" + -" idx = idx + 1\n" + -" return idx\n" + -"\n" + -"####################### auxiliary functions ##########################\n" + -"\n" + -"def setComputeBound():\n" + -" global REACT_TO_INST_BOTTLENECKS\n" + -" REACT_TO_INST_BOTTLENECKS = 0.5\n" + -"\n" + -"def setMemoryBound():\n" + -" global REACT_TO_INST_BOTTLENECKS\n" + -" REACT_TO_INST_BOTTLENECKS = 0.7\n" + -"\n" + -"def reorderList(data, reorderingIndices) :\n" + -" return [x for _, x in sorted(zip(reorderingIndices, data))]\n" + -"\n" + -"def reorderTuningSpace(data, reorderingIndices) :\n" + -" reorderedData = []\n" + -" for row in data:\n" + -" reorderedData.append(reorderList(row, reorderingIndices))\n" + -" return reorderedData\n" + -"\n" + -"def getConfigurationIndices(self, configurations) :\n" + -" ind = []\n" + -" for c in configurations :\n" + -" ind.append(self.GetIndex(c))\n" + -" return ind\n" + -"\n" + -"\n" + -"####################### searcher class ##########################\n" + -"\n" + -"class PyProfilingSearcher(ktt.Searcher):\n" + -" ccMajor = 0\n" + -" ccMinor = 0\n" + -" cc = 0\n" + -" multiprocessors = 0\n" + -" modelMetadata = 0\n" + -" bestDuration = -1\n" + -" bestConf = None\n" + -" preselectedBatch = []\n" + -" tuningParamsNames = []\n" + -" currentConfiguration = ktt.KernelConfiguration()\n" + -" tuner = None\n" + -" model = None\n" + -" batchSize = -1\n" + -" neighborSize = -1\n" + -" randomSize = -1\n" + -" verbose = 0\n" + -" # sometimes, the order of tuning parameters in the search space (as generated by KTT) differs from the order of tuning parameters in the saved ML model\n" + -" #therefore, we need to reorder them to align, so that the model works with the correctly ordered data\n" + -" tuningParametersReorderingFromSearchSpaceToModel = 0\n" + -"\n" + -" def __init__(self):\n" + -" ktt.Searcher.__init__(self)\n" + -"\n" + -" def OnInitialize(self):\n" + -"\n" + -" # initialize the batch, make sure it includes unique, i.e. non-repeating configurations\n" + -" count = 0\n" + -" while count < self.batchSize:\n" + -" for i in range (count, self.batchSize) :\n" + -" self.preselectedBatch.append(self.GetRandomConfiguration())\n" + -" self.preselectedBatch = self.GetUniqueConfigurations(self.preselectedBatch)\n" + -" count = len(self.preselectedBatch)\n" + -" if self.verbose > 0:\n" + -" print(\"[Profile-based searcher info] Batch initialized with configurations \", getConfigurationIndices(self, self.preselectedBatch))\n" + -"\n" + -" # select configuration and remove it from he batch\n" + -" self.currentConfiguration = self.preselectedBatch.pop(0)\n" + -" if self.verbose > 0:\n" + -" print(\"[Profile-based searcher info] Selected configuration \" + str(self.GetIndex(self.currentConfiguration)), flush = True)\n" + -"\n" + -" # determine the difference in the order of TP from search space and from the model\n" + -" tp = self.currentConfiguration.GetPairs()\n" + -" for p in tp :\n" + -" self.tuningParamsNames.append(p.GetName())\n" + -" self.tuningParametersReorderingFromSearchSpaceToModel = []\n" + -" for tp in self.tuningParamsNames:\n" + -" self.tuningParametersReorderingFromSearchSpaceToModel.append(self.modelMetadata['tp'].index(tp))\n" + -" if self.verbose > 2:\n" + -" print(\"[Profile-based searcher debug] Tuning parameters in the search space:\", self.tuningParamsNames)\n" + -" print(\"[Profile-based searcher debug] Tuning parameters in the model:\", self.modelMetadata['tp'])\n" + -" print(\"[Profile-based searcher debug] Tuning parameters reordering list\", self.tuningParametersReorderingFromSearchSpaceToModel)\n" + -"\n" + -" def Configure(self, tuner, modelFile, batchSize, neighborSize, randomSize, logLevel):\n" + -" self.tuner = tuner\n" + -" self.ccMajor = tuner.GetCurrentDeviceInfo().GetCudaComputeCapabilityMajor()\n" + -" self.ccMinor = tuner.GetCurrentDeviceInfo().GetCudaComputeCapabilityMinor()\n" + -" self.cc = self.ccMajor + round(0.1 * self.ccMinor, 1)\n" + -" self.multiprocessors = tuner.GetCurrentDeviceInfo().GetMaxComputeUnits()\n" + -"\n" + -" self.modelMetadata = loadMLModelMetadata(modelFile + \".metadata.json\")\n" + -" self.model = loadMLModel(modelFile)\n" + -" self.batchSize = batchSize\n" + -" self.neighborSize = neighborSize\n" + -" self.randomSize = randomSize\n" + -"\n" + -" if (str(logLevel) == \"LoggingLevel.Off\"):\n" + -" self.verbose = 0\n" + -" if (str(logLevel) == \"LoggingLevel.Info\"):\n" + -" self.verbose = 1\n" + -" if (str(logLevel) == \"LoggingLevel.Warning\" or str(logLevel) == \"LoggingLevel.Error\"):\n" + -" self.verbose = 2\n" + -" if (str(logLevel) == \"LoggingLevel.Debug\"):\n" + -" self.verbose = 3\n" + -"\n" + -" if self.verbose > 0:\n" + -" print(\"[Profile-based searcher info] Loaded model file\", modelFile)\n" + -" print(\"[Profile-based searcher info] Batch size set to\", batchSize)\n" + -" print(\"[Profile-based searcher info] Neighbor size set to\", neighborSize)\n" + -" print(\"[Profile-based searcher info] Random size set to\", randomSize)\n" + -" print(\"[Profile-based searcher info] Log level set to\", logLevel)\n" + -"\n" + -"\n" + -"# GetUniqueConfigurations\n" + -"# takes a list and returns a list that does not contain repeating configurations\n" + -" def GetUniqueConfigurations(self, configurations):\n" + -" uniqueConfigurations = []\n" + -" indicesConfigurations = []\n" + -" uniqueIndicesConfigurations = []\n" + -" for c in configurations:\n" + -" indicesConfigurations.append(self.GetIndex(c))\n" + -" uniqueIndicesConfigurations = list(set(indicesConfigurations))\n" + -"\n" + -" for i in uniqueIndicesConfigurations:\n" + -" uniqueConfigurations.append(self.GetConfiguration(i))\n" + -" return uniqueConfigurations\n" + -"\n" + -"# CalculateNextConfiguration\n" + -"# determines the next configuration that KTT subsequently runs or profiles\n" + -" def CalculateNextConfiguration(self, previousResult):\n" + -" if (previousResult.IsValid()) and ((self.bestConf == None) or (previousResult.GetKernelDuration() < self.bestDuration)) :\n" + -" self.bestDuration = previousResult.GetKernelDuration()\n" + -" self.bestConf = self.currentConfiguration\n" + -" if self.verbose > 1:\n" + -" print(\"[Profile-based searcher details] Found new best configuration\", self.GetIndex(self.bestConf), \"with kernel time\", self.bestDuration/1000, \"us\", flush = True)\n" + -"\n" + -" # if we still have configurations in the batch\n" + -" if len(self.preselectedBatch) > 0:\n" + -" if self.verbose > 1:\n" + -" print(\"[Profile-based searcher details] PreselectedBatch has\", len(self.preselectedBatch), \"remaining items:\", getConfigurationIndices(self, self.preselectedBatch), flush = True)\n" + -" # just take one from the top and run that\n" + -" self.currentConfiguration = self.preselectedBatch.pop(0)\n" + -" # if we have an empty batch and we don't have any best configuration from it (invalid configurations, failed compilation, runtime, or validation)\n" + -" elif self.bestConf == None:\n" + -" if self.verbose > 1:\n" + -" print(\"[Profile-based searcher details] Preselected batch contained invalid configurations only, generating random one.\")\n" + -" # initialize the batch, make sure it includes unique, i.e. non-repeating configurations\n" + -" count = 0\n" + -" maxBatchSize = min(self.batchSize, self.GetUnexploredConfigurationsCount())\n" + -" while count < maxBatchSize:\n" + -" for i in range (count, maxBatchSize) :\n" + -" self.preselectedBatch.append(self.GetRandomConfiguration())\n" + -" self.preselectedBatch = self.GetUniqueConfigurations(self.preselectedBatch)\n" + -" count = len(self.preselectedBatch)\n" + -" if self.verbose > 0:\n" + -" print(\"[Profile-based searcher info] Batch generated with configurations \", getConfigurationIndices(self, self.preselectedBatch))\n" + -" # select configuration and remove it from batch\n" + -" self.currentConfiguration = self.preselectedBatch.pop(0)\n" + -" # if we have an empty batch and we have the fastest configuration from it\n" + -" else:\n" + -" if self.verbose > 1:\n" + -" print(\"[Profile-based searcher details] Preselected batch empty\", flush = True)\n" + -" if self.bestDuration != -1 :\n" + -" # we run the fastest one once again, but with profiling\n" + -" self.currentConfiguration = self.bestConf\n" + -" self.bestDuration = -1\n" + -" self.tuner.SetProfiling(True)\n" + -" if self.verbose > 0 :\n" + -" print(\"[Profile-based searcher info] Running profiling for the best configuration from the batch, configuration\", str(self.GetIndex(self.currentConfiguration)), flush = True)\n" + -" # this happens when the fastest configuration is the last one, e.g. with batchSize == 1, then we just take profiling info from the last run\n" + -" else :\n" + -" # get PCs from the last tuning run\n" + -" if len(previousResult.GetResults()) > 1:\n" + -" print(\"Profile-based searcher warning: this version of profile-based searcher does not support searching kernels collections. Using counters from kernels 0 only.\")\n" + -" globalSize = previousResult.GetResults()[0].GetGlobalSize()\n" + -" localSize = previousResult.GetResults()[0].GetLocalSize()\n" + -" profilingCountersRun = previousResult.GetResults()[0].GetProfilingData().GetCounters() #FIXME this supposes there is no composition profiled\n" + -" pcNames = [\"Global size\", \"Local size\"]\n" + -" pcVals = [globalSize.GetTotalSize()*localSize.GetTotalSize(), localSize.GetTotalSize()]\n" + -" for pd in profilingCountersRun :\n" + -" pcNames.append(pd.GetName())\n" + -" if (pd.GetType() == ktt.ProfilingCounterType.Int) :\n" + -" pcVals.append(pd.GetValueInt())\n" + -" elif (pd.GetType() == ktt.ProfilingCounterType.UnsignedInt) or (pd.GetType() == ktt.ProfilingCounterType.Throughput) or (pd.GetType() == ktt.ProfilingCounterType.UtilizationLevel):\n" + -" pcVals.append(pd.GetValueUint())\n" + -" elif (pd.GetType() == ktt.ProfilingCounterType.Double) or (pd.GetType() == ktt.ProfilingCounterType.Percent) :\n" + -" pcVals.append(pd.GetValueDouble())\n" + -" else :\n" + -" print(\"Fatal error, unsupported PC value passed to profile-based searcher!\")\n" + -" exit(1)\n" + -"\n" + -" # candidates pool generation\n" + -" # select candidate configurations according to position of the best one plus some random sample\n" + -" candidates = self.GetNeighbourConfigurations(self.bestConf, NEIGHBOR_DISTANCE, self.neighborSize)\n" + -" # make sure we don't have repeating configurations in the candidates list\n" + -" candidates = self.GetUniqueConfigurations(candidates)\n" + -" # number of candidates needs to decrease at the end of the search, as we don't have enough unexplored configurations\n" + -" maxPossibleCandidatesSize = min(len(candidates) + self.randomSize, self.GetUnexploredConfigurationsCount())\n" + -" # add random configurations to fill up the candidates pool\n" + -" count = len(candidates)\n" + -" while count < maxPossibleCandidatesSize:\n" + -" for i in range (count, maxPossibleCandidatesSize) :\n" + -" candidates.append(self.GetRandomConfiguration())\n" + -" candidates = self.GetUniqueConfigurations(candidates)\n" + -" count = len(candidates)\n" + -"\n" + -"\n" + -" if self.verbose > 1:\n" + -" print(\"[Profile-based searcher details] Evaluating model for\", str(len(candidates)), \"candidates...\", flush = True)\n" + -"\n" + -" # create a small tuning space from candidates\n" + -" candidatesTuningSpace = []\n" + -" for c in candidates :\n" + -" tp = c.GetPairs()\n" + -" candidateParams = []\n" + -" for p in tp :\n" + -" candidateParams.append(p.GetValue())\n" + -" candidatesTuningSpace.append(candidateParams)\n" + -" myTuningSpace = []\n" + -" tp = self.bestConf.GetPairs()\n" + -" for p in tp :\n" + -" myTuningSpace.append(p.GetValue())\n" + -"\n" + -"\n" + -" # score the configurations\n" + -" scoreDistrib = [1.0]*len(candidates)\n" + -" bottlenecks = analyzeBottlenecks(pcNames, pcVals, self.cc, self.multiprocessors, self.convertSM2Cores() * self.multiprocessors, self.verbose)\n" + -" changes = computeChanges(bottlenecks, self.modelMetadata['pc'], self.modelMetadata['cc'], self.verbose)\n" + -" scoreDistrib = scoreTuningConfigurationsPredictor(changes, self.tuningParametersReorderingFromSearchSpaceToModel, myTuningSpace, candidatesTuningSpace, scoreDistrib, self.model, self.verbose)\n" + -"\n" + -" if self.verbose > 2:\n" + -" print(\"[Profile-based searcher debug] Scoring of the candidates done.\", flush = True)\n" + -"\n" + -" # select next batch\n" + -" selectedIndices = []\n" + -" # if we have more candidates than batchSize, use weightedRandom to choose from them, biasing with score\n" + -" if len(candidates) > self.batchSize :\n" + -" numInBatch = 0\n" + -" while numInBatch < self.batchSize :\n" + -" idx = weightedRandomSearchStep(scoreDistrib, len(candidates))\n" + -" #check if we have not chosen the same configuration in previous iterations\n" + -" if selectedIndices == [] or idx not in selectedIndices:\n" + -" self.preselectedBatch.append(candidates[idx])\n" + -" selectedIndices.append(idx)\n" + -" numInBatch = numInBatch + 1\n" + -" scoreDistrib[idx] = 0.0\n" + -" # if we have less candidates than batchSize, just put them all in batch\n" + -" else:\n" + -" for i in range(0, len(candidates)):\n" + -" self.preselectedBatch.append(candidates[i])\n" + -"\n" + -" if self.verbose > 0:\n" + -" print(\"[Profile-based searcher info] Turning off profiling, new batch selected with length\", len(self.preselectedBatch), \"containing configurations:\", getConfigurationIndices(self, self.preselectedBatch), flush = True)\n" + -"\n" + -" # select configuration and remove it from batch\n" + -" self.currentConfiguration = self.preselectedBatch.pop(0)\n" + -" self.bestConf = None\n" + -" self.tuner.SetProfiling(False)\n" + -"\n" + -" return True\n" + -"\n" + -" def GetCurrentConfiguration(self):\n" + -" return self.currentConfiguration\n" + -"\n" + -" def convertSM2Cores(self):\n" + -" smToCoresDict = {\n" + -" 0x30: 192,\n" + -" 0x32: 192,\n" + -" 0x35: 192,\n" + -" 0x37: 192,\n" + -" 0x50: 128,\n" + -" 0x52: 128,\n" + -" 0x53: 128,\n" + -" 0x60: 64,\n" + -" 0x61: 128,\n" + -" 0x62: 128,\n" + -" 0x70: 64,\n" + -" 0x72: 64,\n" + -" 0x75: 64,\n" + -" 0x80: 64,\n" + -" 0x86: 64\n" + -" }\n" + -" defaultSM = 64\n" + -"\n" + -" compact = (self.ccMajor << 4) + self.ccMinor\n" + -" if compact in smToCoresDict:\n" + -" return smToCoresDict[compact]\n" + -" else:\n" + -" print(\"Warning: unknown number of cores for SM \" + str(self.ccMajor) + \".\" + str(self.ccMinor) + \", using default value of \" + str(defaultSM))\n" + -" return defaultSM\n" + -"\n" + -"def executeSearcher(tuner, kernel, model, batchSize, neighborSize, randomSize, logLevel):\n" + -" searcher = PyProfilingSearcher()\n" + -" tuner.SetSearcher(kernel, searcher)\n" + -" searcher.Configure(tuner, model, batchSize, neighborSize, randomSize, logLevel)\n" + -""; \ No newline at end of file diff --git a/Scripts/StringifyPython.py b/Scripts/StringifyPython.py old mode 100644 new mode 100755 index 8687aed1..97f4c8d0 --- a/Scripts/StringifyPython.py +++ b/Scripts/StringifyPython.py @@ -1,23 +1,24 @@ +#!/bin/env python3 +from pathlib import Path import sys -def main(): - if len(sys.argv) < 2 : - print("Error: Python file to stringify must be given as a command line argument") + +def stringify(input_file: str): + output_file = f'{Path(input_file).stem}.h' + + with ( + open(input_file, 'r') as input, + open(output_file, 'w') as output, + ): + output.write('std::string() + ') + output.write(f'R"(\n{input.read()})";') + + print(f'Stringified script stored into {output_file}') + + +if __name__ == '__main__': + if len(sys.argv) < 2: + print(f'Usage: {sys.argv[0]} [python-file-to-stringify]') exit(1) - - file = open(sys.argv[1], "r") - lines = file.read().splitlines() - output = open("StringifyOutput.h", "w") - output.write("std::string("") +\n") - - for line in lines: - modifiedLine = line.replace('"', '\\"') - output.write("\"" + modifiedLine + "\\n\" +\n") - - output.write("\"\";") - file.close() - output.close() - -if __name__ == "__main__": - main() - \ No newline at end of file + + stringify(sys.argv[1]) diff --git a/Tutorials/08ProfileBasedSearcher/TuningOutput.json b/Tutorials/08CustomPythonSearcher/Artifacts/TuningOutput-1.json similarity index 100% rename from Tutorials/08ProfileBasedSearcher/TuningOutput.json rename to Tutorials/08CustomPythonSearcher/Artifacts/TuningOutput-1.json diff --git a/Tutorials/08ProfileBasedSearcher/TuningOutput.json.exp1 b/Tutorials/08CustomPythonSearcher/Artifacts/TuningOutput-2.json similarity index 100% rename from Tutorials/08ProfileBasedSearcher/TuningOutput.json.exp1 rename to Tutorials/08CustomPythonSearcher/Artifacts/TuningOutput-2.json diff --git a/Tutorials/08ProfileBasedSearcher/TuningOutput.json.exp2 b/Tutorials/08CustomPythonSearcher/Artifacts/TuningOutput-3.json similarity index 100% rename from Tutorials/08ProfileBasedSearcher/TuningOutput.json.exp2 rename to Tutorials/08CustomPythonSearcher/Artifacts/TuningOutput-3.json diff --git a/Tutorials/08ProfileBasedSearcher/TuningOutput.json.exp3 b/Tutorials/08CustomPythonSearcher/Artifacts/TuningOutput-4.json similarity index 100% rename from Tutorials/08ProfileBasedSearcher/TuningOutput.json.exp3 rename to Tutorials/08CustomPythonSearcher/Artifacts/TuningOutput-4.json diff --git a/Tutorials/08ProfileBasedSearcher/log b/Tutorials/08CustomPythonSearcher/Artifacts/stdout.log similarity index 100% rename from Tutorials/08ProfileBasedSearcher/log rename to Tutorials/08CustomPythonSearcher/Artifacts/stdout.log diff --git a/Tutorials/08ProfileBasedSearcher/1070-coulomb_output_DT.sav b/Tutorials/08CustomPythonSearcher/Models/1070-coulomb_output_DT.sav similarity index 100% rename from Tutorials/08ProfileBasedSearcher/1070-coulomb_output_DT.sav rename to Tutorials/08CustomPythonSearcher/Models/1070-coulomb_output_DT.sav diff --git a/Tutorials/08ProfileBasedSearcher/1070-coulomb_output_DT.sav.pc b/Tutorials/08CustomPythonSearcher/Models/1070-coulomb_output_DT.sav.pc similarity index 100% rename from Tutorials/08ProfileBasedSearcher/1070-coulomb_output_DT.sav.pc rename to Tutorials/08CustomPythonSearcher/Models/1070-coulomb_output_DT.sav.pc diff --git a/Tutorials/08CustomPythonSearcher/ProfileSearcherExecutor.py b/Tutorials/08CustomPythonSearcher/ProfileSearcherExecutor.py new file mode 100755 index 00000000..4ba95899 --- /dev/null +++ b/Tutorials/08CustomPythonSearcher/ProfileSearcherExecutor.py @@ -0,0 +1,347 @@ +#!/bin/env python3 + +import sys +import numpy as np +import pyktt as ktt + +from base import * +from mlKTTPredictor import * + +BATCH = 5 + +# This example demonstrates how to create a more complex custom searcher. +# The searcher is based on an old version of a `ProfileBasedSearcher`. +# Make sure to compile KTT with `--profiling=cupti[-legacy] --python` and put +# compiled `pyktt.so` into this folder. + + +class PyProfilingSearcher(ktt.Searcher): + ccMajor = 0 + ccMinor = 0 + cc = 0 + multiprocessors = 0 + profilingCountersModel = 0 + bestDuration = -1 + bestConf = None + preselectedBatch = [] + tuningParamsNames = [] + currentConfiguration = ktt.KernelConfiguration() + + tuner = None + model = None + + def __init__(self): + ktt.Searcher.__init__(self) + + def OnInitialize(self): + for i in range(0, BATCH): + self.preselectedBatch.append(self.GetRandomConfiguration()) + self.currentConfiguration = self.preselectedBatch[0] + + tp = self.currentConfiguration.GetPairs() + for p in tp: + self.tuningParamsNames.append(p.GetName()) + + def Configure(self, tuner, modelFile): + self.tuner = tuner + self.ccMajor = ( + tuner.GetCurrentDeviceInfo().GetCUDAComputeCapabilityMajor() + ) + self.ccMinor = ( + tuner.GetCurrentDeviceInfo().GetCUDAComputeCapabilityMinor() + ) + self.cc = self.ccMajor + round(0.1 * self.ccMinor, 1) + self.multiprocessors = tuner.GetCurrentDeviceInfo().GetMaxComputeUnits() + + self.profilingCountersModel = readPCList(modelFile + '.pc') + self.model = loadMLModel(modelFile) + + def CalculateNextConfiguration(self, previousResult): + # select the new configuration + if len(self.preselectedBatch) > 0: + # we are testing current batch + if (self.bestConf == None) or ( + previousResult.GetKernelDuration() < self.bestDuration + ): + self.bestDuration = previousResult.GetKernelDuration() + self.bestConf = self.currentConfiguration + self.currentConfiguration = self.preselectedBatch.pop(0) + else: + if self.bestDuration != -1: + # we run the fastest one once again, but with profiling + self.currentConfiguration = self.bestConf + self.bestDuration = -1 + self.tuner.SetProfiling(True) + else: + # get PCs from the last tuning run + if len(previousResult.GetResults()) > 1: + print( + 'Warning: this version of profile-based searcher does not support searching kernels collections. Using counters from kernels 0 only.' + ) + globalSize = previousResult.GetResults()[0].GetGlobalSize() + localSize = previousResult.GetResults()[0].GetLocalSize() + profilingCountersRun = ( + previousResult.GetResults()[0] + .GetProfilingData() + .GetCounters() + ) # FIXME this supposes there is no composition profiled + pcNames = ['Global size', 'Local size'] + pcVals = [globalSize.GetTotalSize(), localSize.GetTotalSize()] + for pd in profilingCountersRun: + pcNames.append(pd.GetName()) + if pd.GetType() == ktt.ProfilingCounterType.Int: + pcVals.append(pd.GetValueInt()) + elif ( + (pd.GetType() == ktt.ProfilingCounterType.UnsignedInt) + or (pd.GetType() == ktt.ProfilingCounterType.Throughput) + or ( + pd.GetType() + == ktt.ProfilingCounterType.UtilizationLevel + ) + ): + pcVals.append(pd.GetValueUint()) + elif (pd.GetType() == ktt.ProfilingCounterType.Double) or ( + pd.GetType() == ktt.ProfilingCounterType.Percent + ): + pcVals.append(pd.GetValueDouble()) + else: + print( + 'Fatal error, unsupported PC value passed to profile-based searcher!' + ) + exit(1) + + # select candidate configurations according to position of the best one plus some random sample + candidates = self.GetNeighbourConfigurations( + self.bestConf, 2, 100 + ) + for i in range(0, 10): + candidates.append(self.GetRandomConfiguration()) + print( + 'Profile-based searcher: evaluating model for ' + + str(len(candidates)) + + ' candidates...' + ) + + # get tuning space from candidates + candidatesTuningSpace = [] + for c in candidates: + tp = c.GetPairs() + candidateParams = [] + for p in tp: + candidateParams.append(p.GetValue()) + candidatesTuningSpace.append(candidateParams) + myTuningSpace = [] + tp = self.bestConf.GetPairs() + for p in tp: + myTuningSpace.append(p.GetValue()) + + # score the configurations + scoreDistrib = [1.0] * len(candidates) + bottlenecks = analyzeBottlenecks( + pcNames, + pcVals, + 6.1, + self.multiprocessors, + self.convertSM2Cores() * self.multiprocessors, + ) + changes = computeChanges( + bottlenecks, self.profilingCountersModel, self.cc + ) + scoreDistrib = scoreTuningConfigurationsPredictor( + changes, + self.tuningParamsNames, + myTuningSpace, + candidatesTuningSpace, + scoreDistrib, + self.model, + ) + + # select next batch + for i in range(0, BATCH): + idx = weightedRandomSearchStep( + scoreDistrib, len(candidates) + ) + self.preselectedBatch.append(candidates[idx]) + self.currentConfiguration = self.preselectedBatch[0] + self.bestConf = None + self.tuner.SetProfiling(False) + + return True + + def GetCurrentConfiguration(self): + return self.currentConfiguration + + def convertSM2Cores(self): + smToCoresDict = { + 0x30: 192, + 0x32: 192, + 0x35: 192, + 0x37: 192, + 0x50: 128, + 0x52: 128, + 0x53: 128, + 0x60: 64, + 0x61: 128, + 0x62: 128, + 0x70: 64, + 0x72: 64, + 0x75: 64, + 0x80: 64, + 0x86: 64, + } + defaultSM = 64 + + compact = (self.ccMajor << 4) + self.ccMinor + if compact in smToCoresDict: + return smToCoresDict[compact] + else: + print( + 'Warning: unknown number of cores for SM ' + + str(self.ccMajor) + + '.' + + str(self.ccMinor) + + ', using default value of ' + + str(defaultSM) + ) + return defaultSM + + +def main(): + deviceIndex = 0 + kernelFile = './CudaKernel.cu' + + argc = len(sys.argv) + + if argc >= 2: + deviceIndex = sys.argv[1] + + if argc >= 3: + kernelFile = sys.argv[2] + + numberOfAtoms = 256 + gridSize = 256 + gridSpacing = 0.5 + gridDimensions = ktt.DimensionVector(gridSize, gridSize, gridSize) + blockDimensions = ktt.DimensionVector(1, 1) + + aX = 100.0 * np.random.rand(numberOfAtoms).astype('f') + aY = 100.0 * np.random.rand(numberOfAtoms).astype('f') + aZ = 100.0 * np.random.rand(numberOfAtoms).astype('f') + aW = 100.0 * np.random.rand(numberOfAtoms).astype('f') + aAll = np.zeros(numberOfAtoms * 4, dtype=np.single) + for i in range(numberOfAtoms): + aAll[4 * i] = aX[i] + aAll[4 * i + 1] = aY[i] + aAll[4 * i + 2] = aZ[i] + aAll[4 * i + 3] = aW[i] + energyGrid = np.zeros(gridSize * gridSize * gridSize, dtype=np.single) + + tuner = ktt.Tuner(0, deviceIndex, ktt.ComputeApi.CUDA) + tuner.SetCompilerOptions('-use_fast_math') + tuner.SetTimeUnit(ktt.TimeUnit.Microseconds) + tuner.SetProfiling(False) + + definition = tuner.AddKernelDefinitionFromFile( + 'directCoulombSum', kernelFile, gridDimensions, blockDimensions + ) + + aXId = tuner.AddArgumentVectorFloat(aX, ktt.ArgumentAccessType.ReadOnly) + aYId = tuner.AddArgumentVectorFloat(aY, ktt.ArgumentAccessType.ReadOnly) + aZId = tuner.AddArgumentVectorFloat(aZ, ktt.ArgumentAccessType.ReadOnly) + aWId = tuner.AddArgumentVectorFloat(aW, ktt.ArgumentAccessType.ReadOnly) + aAllId = tuner.AddArgumentVectorFloat(aAll, ktt.ArgumentAccessType.ReadOnly) + numberOfAtomsId = tuner.AddArgumentScalarInt(numberOfAtoms) + gridSpacingId = tuner.AddArgumentScalarFloat(gridSpacing) + gridSizeId = tuner.AddArgumentScalarInt(gridSize) + energyGridId = tuner.AddArgumentVectorFloat( + energyGrid, ktt.ArgumentAccessType.WriteOnly + ) + tuner.SetArguments( + definition, + [ + aAllId, + aXId, + aYId, + aZId, + aWId, + numberOfAtomsId, + gridSpacingId, + gridSizeId, + energyGridId, + ], + ) + + kernel = tuner.CreateSimpleKernel('directCoulombSum', definition) + + tuner.AddParameter(kernel, 'WORK_GROUP_SIZE_X', [16, 32]) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Local, + ktt.ModifierDimension.X, + 'WORK_GROUP_SIZE_X', + ktt.ModifierAction.Multiply, + ) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Global, + ktt.ModifierDimension.X, + 'WORK_GROUP_SIZE_X', + ktt.ModifierAction.Divide, + ) + tuner.AddParameter(kernel, 'WORK_GROUP_SIZE_Y', [1, 2, 4, 8]) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Local, + ktt.ModifierDimension.Y, + 'WORK_GROUP_SIZE_Y', + ktt.ModifierAction.Multiply, + ) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Global, + ktt.ModifierDimension.Y, + 'WORK_GROUP_SIZE_Y', + ktt.ModifierAction.Divide, + ) + tuner.AddParameter(kernel, 'WORK_GROUP_SIZE_Z', [1]) + tuner.AddParameter(kernel, 'Z_ITERATIONS', [1, 2, 4, 8, 16, 32]) + tuner.AddThreadModifier( + kernel, + [definition], + ktt.ModifierType.Global, + ktt.ModifierDimension.Z, + 'Z_ITERATIONS', + ktt.ModifierAction.Divide, + ) + tuner.AddParameter(kernel, 'INNER_UNROLL_FACTOR', [0, 1, 2, 4, 8, 16, 32]) + tuner.AddParameter(kernel, 'USE_SOA', [0, 1]) + tuner.AddParameter(kernel, 'VECTOR_SIZE', [1]) + tuner.AddConstraint( + kernel, + ['INNER_UNROLL_FACTOR', 'Z_ITERATIONS'], + lambda vector: vector[0] < vector[1], + ) + tuner.AddConstraint( + kernel, + ['WORK_GROUP_SIZE_X', 'WORK_GROUP_SIZE_Y'], + lambda vector: vector[0] * vector[1] >= 64, + ) + + # Make tuner user the searcher implemented in Python. + searcher = PyProfilingSearcher() + tuner.SetSearcher(kernel, searcher) + searcher.Configure(tuner, 'Models/1070-coulomb_output_DT.sav') + + # Begin tuning utilizing the stop condition implemented in Python. + results = tuner.Tune(kernel) + tuner.SaveResults(results, 'TuningOutput', ktt.OutputFormat.JSON) + + +def executeSearcher(tuner, kernel, model): + searcher = PyProfilingSearcher() + tuner.SetSearcher(kernel, searcher) + searcher.Configure(tuner, model) diff --git a/Tutorials/08ProfileBasedSearcher/base.py b/Tutorials/08CustomPythonSearcher/base.py similarity index 100% rename from Tutorials/08ProfileBasedSearcher/base.py rename to Tutorials/08CustomPythonSearcher/base.py diff --git a/Tutorials/08ProfileBasedSearcher/mlKTTPredictor.py b/Tutorials/08CustomPythonSearcher/mlKTTPredictor.py similarity index 100% rename from Tutorials/08ProfileBasedSearcher/mlKTTPredictor.py rename to Tutorials/08CustomPythonSearcher/mlKTTPredictor.py diff --git a/Tutorials/08ProfileBasedSearcher/ProfileSearcherExecutor.py b/Tutorials/08ProfileBasedSearcher/ProfileSearcherExecutor.py deleted file mode 100755 index e27447dc..00000000 --- a/Tutorials/08ProfileBasedSearcher/ProfileSearcherExecutor.py +++ /dev/null @@ -1,226 +0,0 @@ -import sys -import numpy as np -import pyktt as ktt - -from base import * -from mlKTTPredictor import * - -BATCH = 5 - -class PyProfilingSearcher(ktt.Searcher): - ccMajor = 0 - ccMinor = 0 - cc = 0 - multiprocessors = 0 - profilingCountersModel = 0 - bestDuration = -1 - bestConf = None - preselectedBatch = [] - tuningParamsNames = [] - currentConfiguration = ktt.KernelConfiguration() - tuner = None - model = None - - def __init__(self): - ktt.Searcher.__init__(self) - - def OnInitialize(self): - for i in range(0, BATCH) : - self.preselectedBatch.append(self.GetRandomConfiguration()) - self.currentConfiguration = self.preselectedBatch[0] - - tp = self.currentConfiguration.GetPairs() - for p in tp : - self.tuningParamsNames.append(p.GetName()) - - def Configure(self, tuner, modelFile): - self.tuner = tuner - self.ccMajor = tuner.GetCurrentDeviceInfo().GetCUDAComputeCapabilityMajor() - self.ccMinor = tuner.GetCurrentDeviceInfo().GetCUDAComputeCapabilityMinor() - self.cc = self.ccMajor + round(0.1 * self.ccMinor, 1) - self.multiprocessors = tuner.GetCurrentDeviceInfo().GetMaxComputeUnits() - - self.profilingCountersModel = readPCList(modelFile + ".pc") - self.model = loadMLModel(modelFile) - - def CalculateNextConfiguration(self, previousResult): - # select the new configuration - if len(self.preselectedBatch) > 0: - # we are testing current batch - if (self.bestConf == None) or (previousResult.GetKernelDuration() < self.bestDuration) : - self.bestDuration = previousResult.GetKernelDuration() - self.bestConf = self.currentConfiguration - self.currentConfiguration = self.preselectedBatch.pop(0) - else : - if self.bestDuration != -1 : - # we run the fastest one once again, but with profiling - self.currentConfiguration = self.bestConf - self.bestDuration = -1 - self.tuner.SetProfiling(True) - else : - # get PCs from the last tuning run - if len(previousResult.GetResults()) > 1: - print("Warning: this version of profile-based searcher does not support searching kernels collections. Using counters from kernels 0 only.") - globalSize = previousResult.GetResults()[0].GetGlobalSize() - localSize = previousResult.GetResults()[0].GetLocalSize() - profilingCountersRun = previousResult.GetResults()[0].GetProfilingData().GetCounters() #FIXME this supposes there is no composition profiled - pcNames = ["Global size", "Local size"] - pcVals = [globalSize.GetTotalSize(), localSize.GetTotalSize()] - for pd in profilingCountersRun : - pcNames.append(pd.GetName()) - if (pd.GetType() == ktt.ProfilingCounterType.Int) : - pcVals.append(pd.GetValueInt()) - elif (pd.GetType() == ktt.ProfilingCounterType.UnsignedInt) or (pd.GetType() == ktt.ProfilingCounterType.Throughput) or (pd.GetType() == ktt.ProfilingCounterType.UtilizationLevel): - pcVals.append(pd.GetValueUint()) - elif (pd.GetType() == ktt.ProfilingCounterType.Double) or (pd.GetType() == ktt.ProfilingCounterType.Percent) : - pcVals.append(pd.GetValueDouble()) - else : - print("Fatal error, unsupported PC value passed to profile-based searcher!") - exit(1) - - # select candidate configurations according to position of the best one plus some random sample - candidates = self.GetNeighbourConfigurations(self.bestConf, 2, 100) - for i in range (0, 10) : - candidates.append(self.GetRandomConfiguration()) - print("Profile-based searcher: evaluating model for " + str(len(candidates)) + " candidates...") - - # get tuning space from candidates - candidatesTuningSpace = [] - for c in candidates : - tp = c.GetPairs() - candidateParams = [] - for p in tp : - candidateParams.append(p.GetValue()) - candidatesTuningSpace.append(candidateParams) - myTuningSpace = [] - tp = self.bestConf.GetPairs() - for p in tp : - myTuningSpace.append(p.GetValue()) - - # score the configurations - scoreDistrib = [1.0]*len(candidates) - bottlenecks = analyzeBottlenecks(pcNames, pcVals, 6.1, self.multiprocessors, self.convertSM2Cores() * self.multiprocessors) - changes = computeChanges(bottlenecks, self.profilingCountersModel, self.cc) - scoreDistrib = scoreTuningConfigurationsPredictor(changes, self.tuningParamsNames, myTuningSpace, candidatesTuningSpace, scoreDistrib, self.model) - - # select next batch - for i in range(0, BATCH) : - idx = weightedRandomSearchStep(scoreDistrib, len(candidates)) - self.preselectedBatch.append(candidates[idx]) - self.currentConfiguration = self.preselectedBatch[0] - self.bestConf = None - self.tuner.SetProfiling(False) - - return True - - def GetCurrentConfiguration(self): - return self.currentConfiguration - - def convertSM2Cores(self): - smToCoresDict = { - 0x30: 192, - 0x32: 192, - 0x35: 192, - 0x37: 192, - 0x50: 128, - 0x52: 128, - 0x53: 128, - 0x60: 64, - 0x61: 128, - 0x62: 128, - 0x70: 64, - 0x72: 64, - 0x75: 64, - 0x80: 64, - 0x86: 64 - } - defaultSM = 64 - - compact = (self.ccMajor << 4) + self.ccMinor - if compact in smToCoresDict: - return smToCoresDict[compact] - else: - print("Warning: unknown number of cores for SM " + str(self.ccMajor) + "." + str(self.ccMinor) + ", using default value of " + str(defaultSM)) - return defaultSM - -def main(): - deviceIndex = 0 - kernelFile = "./CudaKernel.cu" - - argc = len(sys.argv) - - if argc >= 2: - deviceIndex = sys.argv[1] - - if argc >= 3: - kernelFile = sys.argv[2] - - numberOfAtoms = 256 - gridSize = 256 - gridSpacing = 0.5 - gridDimensions = ktt.DimensionVector(gridSize, gridSize, gridSize) - blockDimensions = ktt.DimensionVector(1, 1) - - aX = 100.0 * np.random.rand(numberOfAtoms).astype('f') - aY = 100.0 * np.random.rand(numberOfAtoms).astype('f') - aZ = 100.0 * np.random.rand(numberOfAtoms).astype('f') - aW = 100.0 * np.random.rand(numberOfAtoms).astype('f') - aAll = np.zeros(numberOfAtoms*4, dtype = np.single) - for i in range(numberOfAtoms): - aAll[4 * i] = aX[i] - aAll[4 * i + 1] = aY[i] - aAll[4 * i + 2] = aZ[i] - aAll[4 * i + 3] = aW[i] - energyGrid = np.zeros(gridSize*gridSize*gridSize, dtype = np.single) - - tuner = ktt.Tuner(0, deviceIndex, ktt.ComputeApi.CUDA) - tuner.SetCompilerOptions("-use_fast_math") - tuner.SetTimeUnit(ktt.TimeUnit.Microseconds) - tuner.SetProfiling(False) - - definition = tuner.AddKernelDefinitionFromFile("directCoulombSum", kernelFile, gridDimensions, blockDimensions) - - aXId = tuner.AddArgumentVectorFloat(aX, ktt.ArgumentAccessType.ReadOnly) - aYId = tuner.AddArgumentVectorFloat(aY, ktt.ArgumentAccessType.ReadOnly) - aZId = tuner.AddArgumentVectorFloat(aZ, ktt.ArgumentAccessType.ReadOnly) - aWId = tuner.AddArgumentVectorFloat(aW, ktt.ArgumentAccessType.ReadOnly) - aAllId = tuner.AddArgumentVectorFloat(aAll, ktt.ArgumentAccessType.ReadOnly) - numberOfAtomsId = tuner.AddArgumentScalarInt(numberOfAtoms) - gridSpacingId = tuner.AddArgumentScalarFloat(gridSpacing) - gridSizeId = tuner.AddArgumentScalarInt(gridSize) - energyGridId = tuner.AddArgumentVectorFloat(energyGrid, ktt.ArgumentAccessType.WriteOnly) - tuner.SetArguments(definition, [aAllId, aXId, aYId, aZId, aWId, numberOfAtomsId, gridSpacingId, gridSizeId, energyGridId]) - - kernel = tuner.CreateSimpleKernel("directCoulombSum", definition) - - tuner.AddParameter(kernel, "WORK_GROUP_SIZE_X", [16, 32]) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Local, ktt.ModifierDimension.X, "WORK_GROUP_SIZE_X", ktt.ModifierAction.Multiply) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Global, ktt.ModifierDimension.X, "WORK_GROUP_SIZE_X", ktt.ModifierAction.Divide) - tuner.AddParameter(kernel, "WORK_GROUP_SIZE_Y", [1, 2, 4, 8]) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Local, ktt.ModifierDimension.Y, "WORK_GROUP_SIZE_Y", ktt.ModifierAction.Multiply) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Global, ktt.ModifierDimension.Y, "WORK_GROUP_SIZE_Y", ktt.ModifierAction.Divide) - tuner.AddParameter(kernel, "WORK_GROUP_SIZE_Z", [1]) - tuner.AddParameter(kernel, "Z_ITERATIONS", [1, 2, 4, 8, 16, 32]) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Global, ktt.ModifierDimension.Z, "Z_ITERATIONS", ktt.ModifierAction.Divide) - tuner.AddParameter(kernel, "INNER_UNROLL_FACTOR", [0, 1, 2, 4, 8, 16, 32]) - tuner.AddParameter(kernel, "USE_SOA", [0, 1]) - tuner.AddParameter(kernel, "VECTOR_SIZE", [1]) - unrollLimit = lambda vector: vector[0] < vector[1] - tuner.AddConstraint(kernel, ["INNER_UNROLL_FACTOR", "Z_ITERATIONS"], unrollLimit) - parallelBound = lambda vector: vector[0] * vector[1] >= 64 - tuner.AddConstraint(kernel, ["WORK_GROUP_SIZE_X", "WORK_GROUP_SIZE_Y"], parallelBound) - - # Make tuner user the searcher implemented in Python. - searcher = PyProfilingSearcher() - tuner.SetSearcher(kernel, searcher) - searcher.Configure(tuner, "1070-coulomb_output_DT.sav") - - # Begin tuning utilizing the stop condition implemented in Python. - results = tuner.Tune(kernel) - tuner.SaveResults(results, "TuningOutput", ktt.OutputFormat.JSON) - -def executeSearcher(tuner, kernel, model): - searcher = PyProfilingSearcher() - tuner.SetSearcher(kernel, searcher) - searcher.Configure(tuner, model) - diff --git a/Tutorials/08ProfileBasedSearcher/TuningOutput.json.exp4 b/Tutorials/08ProfileBasedSearcher/TuningOutput.json.exp4 deleted file mode 100644 index f7229194..00000000 --- a/Tutorials/08ProfileBasedSearcher/TuningOutput.json.exp4 +++ /dev/null @@ -1,46803 +0,0 @@ -{ - "Metadata": { - "ComputeApi": "CUDA", - "Device": "GeForce GTX 1070", - "GlobalSizeType": "CUDA", - "KttVersion": "2.1.0", - "Platform": "NVIDIA CUDA", - "TimeUnit": "Microseconds", - "Timestamp": "2022-06-01 13:55:7 UTC" - }, - "Results": [ - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 109440.0, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 76862.535 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6621.675, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.57, - "Status": "Ok", - "TotalDuration": 109440.0, - "TotalOverhead": 83521.785, - "ValidationOverhead": 2.005 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 107776.032, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.175 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7908.592, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.484, - "Status": "Ok", - "TotalDuration": 107776.032, - "TotalOverhead": 7968.712, - "ValidationOverhead": 1.461 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 43851.584, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 68726.16 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7727.744, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 52.695, - "Status": "Ok", - "TotalDuration": 43851.584, - "TotalOverhead": 76508.712, - "ValidationOverhead": 2.113 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 48 - }, - "Duration": 5281.568, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 78178.791 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7680.844, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.756, - "Status": "Ok", - "TotalDuration": 5281.568, - "TotalOverhead": 85916.143, - "ValidationOverhead": 2.752 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 106829.888, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 73466.617 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8412.544, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.439, - "Status": "Ok", - "TotalDuration": 106829.888, - "TotalOverhead": 81934.75, - "ValidationOverhead": 2.15 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 48 - }, - "Duration": 5089.088, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 78534.468 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7631.194, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.763, - "Status": "Ok", - "TotalDuration": 5089.088, - "TotalOverhead": 86202.322, - "ValidationOverhead": 2.897 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 48 - }, - "Duration": 5152.672, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 6697.671, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2389929 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2069041 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 6583647 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 69206016 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.6097747789232306 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 83.4727630429039 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17733517312 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 680525824 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 134217728 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 167772160 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 293076992 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 594149376 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 49.98306139389744 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 78.09675711319531 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.9889697771895 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7705.84, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4685.162, - "Status": "Ok", - "TotalDuration": 5152.672, - "TotalOverhead": 19090.024, - "ValidationOverhead": 1.351 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 140342.688, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 78544.333 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6415.138, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.142, - "Status": "Ok", - "TotalDuration": 140342.688, - "TotalOverhead": 84996.125, - "ValidationOverhead": 2.512 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 142727.616, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 18.064 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7627.804, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.562, - "Status": "Ok", - "TotalDuration": 142727.616, - "TotalOverhead": 7678.622, - "ValidationOverhead": 1.192 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 48 - }, - "Duration": 5050.944, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 77924.309 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7598.75, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.868, - "Status": "Ok", - "TotalDuration": 5050.944, - "TotalOverhead": 85579.921, - "ValidationOverhead": 1.994 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 37621.696, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 70997.134 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7667.59, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.75, - "Status": "Ok", - "TotalDuration": 37621.696, - "TotalOverhead": 78720.457, - "ValidationOverhead": 1.983 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 18 - }, - "Duration": 27779.68, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 69845.118 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7897.08, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.417, - "Status": "Ok", - "TotalDuration": 27779.68, - "TotalOverhead": 77800.108, - "ValidationOverhead": 2.493 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 18 - }, - "Duration": 28022.624, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.723 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7610.126, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.194, - "Status": "Ok", - "TotalDuration": 28022.624, - "TotalOverhead": 7628.282, - "ValidationOverhead": 1.239 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 48 - }, - "Duration": 5232.8, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 6486.357, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2243287 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068511 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 6437282 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097448 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 69206016 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.6099511781193818 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 56.31077294437485 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17733517312 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 680525824 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 134217728 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 167772160 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 293076992 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 594149376 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 34.82821956661076 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 80.66718681788173 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.9889697771895 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8299.467, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4228.755, - "Status": "Ok", - "TotalDuration": 5232.8, - "TotalOverhead": 19015.987, - "ValidationOverhead": 1.408 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 169463.872, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 84212.195 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6335.448, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.212, - "Status": "Ok", - "TotalDuration": 169463.872, - "TotalOverhead": 90584.729, - "ValidationOverhead": 2.874 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 169483.072, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.72 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7617.221, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.863, - "Status": "Ok", - "TotalDuration": 169483.072, - "TotalOverhead": 7653.074, - "ValidationOverhead": 1.27 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5244.672, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 77066.709 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7581.786, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.266, - "Status": "Ok", - "TotalDuration": 5244.672, - "TotalOverhead": 84704.709, - "ValidationOverhead": 1.948 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171708.48, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 81438.055 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7618.901, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.45, - "Status": "Ok", - "TotalDuration": 171708.48, - "TotalOverhead": 89113.964, - "ValidationOverhead": 2.558 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 37699.936, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 72667.46 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7625.145, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.826, - "Status": "Ok", - "TotalDuration": 37699.936, - "TotalOverhead": 80348.522, - "ValidationOverhead": 2.091 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 19019.808, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 73386.029 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7651.321, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.681, - "Status": "Ok", - "TotalDuration": 19019.808, - "TotalOverhead": 81073.058, - "ValidationOverhead": 2.027 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5244.064, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 7525.151, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097298 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064439 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 18874700 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 270532608 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9751098581697255 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 82.81041356652 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19344130048 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 721420288 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 570425344 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 465567744 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 664207360 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 56.40259685203339 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 93.07484185895183 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.95066600888012 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7713.239, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4612.662, - "Status": "Ok", - "TotalDuration": 5244.064, - "TotalOverhead": 19852.492, - "ValidationOverhead": 1.44 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9667.232, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 74376.238 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6422.465, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.618, - "Status": "Ok", - "TotalDuration": 9667.232, - "TotalOverhead": 80835.25, - "ValidationOverhead": 1.929 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9690.4, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.545 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7607.168, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.303, - "Status": "Ok", - "TotalDuration": 9690.4, - "TotalOverhead": 7642.183, - "ValidationOverhead": 1.167 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9674.624, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.27 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7541.602, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.675, - "Status": "Ok", - "TotalDuration": 9674.624, - "TotalOverhead": 7567.275, - "ValidationOverhead": 1.728 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9681.504, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.182 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7519.926, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.585, - "Status": "Ok", - "TotalDuration": 9681.504, - "TotalOverhead": 7543.925, - "ValidationOverhead": 1.232 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9683.872, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.116 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7521.793, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.562, - "Status": "Ok", - "TotalDuration": 9683.872, - "TotalOverhead": 7545.749, - "ValidationOverhead": 1.278 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9669.376, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.124 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7586.575, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 11.891, - "Status": "Ok", - "TotalDuration": 9669.376, - "TotalOverhead": 7601.829, - "ValidationOverhead": 1.239 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9681.344, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 6834.353, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2389508 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064455 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 35943854 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.995361614310167 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 90.20550648790193 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 21491613696 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1308622848 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 272629760 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 1107296256 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 897581056 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 784728064 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 38.603731215036056 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 56.86717199469513 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.91648571905796 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7749.476, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 5059.872, - "Status": "Ok", - "TotalDuration": 9681.344, - "TotalOverhead": 19645.134, - "ValidationOverhead": 1.433 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12113.632, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 74232.263 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6350.136, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.117, - "Status": "Ok", - "TotalDuration": 12113.632, - "TotalOverhead": 80620.501, - "ValidationOverhead": 1.985 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12275.744, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.689 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7637.034, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.51, - "Status": "Ok", - "TotalDuration": 12275.744, - "TotalOverhead": 7673.462, - "ValidationOverhead": 1.229 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 44334.112, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 72865.682 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7683.231, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.349, - "Status": "Ok", - "TotalDuration": 44334.112, - "TotalOverhead": 80605.254, - "ValidationOverhead": 1.992 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 103328.96, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 74513.417 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8161.322, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.895, - "Status": "Ok", - "TotalDuration": 103328.96, - "TotalOverhead": 82732.755, - "ValidationOverhead": 2.121 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 15 - }, - "Duration": 102895.744, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 73428.644 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7681.156, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.108, - "Status": "Ok", - "TotalDuration": 102895.744, - "TotalOverhead": 81165.841, - "ValidationOverhead": 1.933 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 90964.832, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 74584.176 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7657.919, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.706, - "Status": "Ok", - "TotalDuration": 90964.832, - "TotalOverhead": 82277.793, - "ValidationOverhead": 1.992 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 11606.432, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 7170.815, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388780 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064463 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 136606422 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9579970469393211 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 94.34738601913118 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 21491613696 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 3451912192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 272629760 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 4328521728 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1698693120 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 977403904 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 31.272123106566745 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 48.75892278187905 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.93294890706719 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7731.831, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4451.661, - "Status": "Ok", - "TotalDuration": 11606.432, - "TotalOverhead": 19355.704, - "ValidationOverhead": 1.397 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9709.408, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 74864.688 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6459.172, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.866, - "Status": "Ok", - "TotalDuration": 9709.408, - "TotalOverhead": 81360.745, - "ValidationOverhead": 2.019 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9742.592, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.59 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7701.47, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.261, - "Status": "Ok", - "TotalDuration": 9742.592, - "TotalOverhead": 7736.505, - "ValidationOverhead": 1.184 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9695.328, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.376 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7601.284, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.478, - "Status": "Ok", - "TotalDuration": 9695.328, - "TotalOverhead": 7626.56, - "ValidationOverhead": 1.422 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 18 - }, - "Duration": 27931.424, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 71240.288 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7613.853, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.786, - "Status": "Ok", - "TotalDuration": 27931.424, - "TotalOverhead": 78912.227, - "ValidationOverhead": 2.3 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 30994.432, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 71908.384 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7700.128, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.263, - "Status": "Ok", - "TotalDuration": 30994.432, - "TotalOverhead": 79665.787, - "ValidationOverhead": 2.012 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 10023.456, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 3.026 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7610.311, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 16.161, - "Status": "Ok", - "TotalDuration": 10023.456, - "TotalOverhead": 7630.777, - "ValidationOverhead": 1.279 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 10045.152, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 7415.585, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388781 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068463 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 35943130 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.996269120670586 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 90.1762023577548 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 21491613696 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1308622848 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 272629760 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 1107296256 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 897581056 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 784728064 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 38.651830899239776 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 56.956391743392665 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.91648571905796 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7766.617, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4100.911, - "Status": "Ok", - "TotalDuration": 10045.152, - "TotalOverhead": 19284.563, - "ValidationOverhead": 1.45 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 28713.248, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 73248.973 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6485.477, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.029, - "Status": "Ok", - "TotalDuration": 28713.248, - "TotalOverhead": 79771.619, - "ValidationOverhead": 2.14 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 29087.68, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 19.981 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7672.426, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.849, - "Status": "Ok", - "TotalDuration": 29087.68, - "TotalOverhead": 7725.391, - "ValidationOverhead": 1.135 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 169686.24, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 82022.356 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 9991.02, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.752, - "Status": "Ok", - "TotalDuration": 169686.24, - "TotalOverhead": 92071.375, - "ValidationOverhead": 2.247 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12236.352, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 73279.29 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7676.205, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.191, - "Status": "Ok", - "TotalDuration": 12236.352, - "TotalOverhead": 81012.638, - "ValidationOverhead": 1.952 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 15 - }, - "Duration": 30729.344, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 71083.473 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7667.484, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.28, - "Status": "Ok", - "TotalDuration": 30729.344, - "TotalOverhead": 78807.406, - "ValidationOverhead": 2.169 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12599.52, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.655 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7701.782, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.36, - "Status": "Ok", - "TotalDuration": 12599.52, - "TotalOverhead": 7719.966, - "ValidationOverhead": 1.169 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12804.608, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 6212.85, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097299 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2069032 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 136460706 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.969770128308096 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 92.11872343371401 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 21491613696 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 3451912192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 272629760 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 4328521728 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1698693120 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 977403904 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 30.507036812815848 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 48.71658894402097 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.93294890706719 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7734.447, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4145.039, - "Status": "Ok", - "TotalDuration": 12804.608, - "TotalOverhead": 18093.779, - "ValidationOverhead": 1.443 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 43597.632, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 72145.962 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6329.704, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.314, - "Status": "Ok", - "TotalDuration": 43597.632, - "TotalOverhead": 78512.018, - "ValidationOverhead": 2.038 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 43717.952, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.724 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7641.763, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.071, - "Status": "Ok", - "TotalDuration": 43717.952, - "TotalOverhead": 7677.724, - "ValidationOverhead": 1.166 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 18 - }, - "Duration": 28467.2, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 70159.458 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7721.229, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.301, - "Status": "Ok", - "TotalDuration": 28467.2, - "TotalOverhead": 77938.111, - "ValidationOverhead": 2.123 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 38061.44, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 71392.64 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7697.207, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.704, - "Status": "Ok", - "TotalDuration": 38061.44, - "TotalOverhead": 79145.579, - "ValidationOverhead": 2.028 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 19178.432, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 72487.814 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7697.019, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.588, - "Status": "Ok", - "TotalDuration": 19178.432, - "TotalOverhead": 80243.481, - "ValidationOverhead": 2.06 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 31716.192, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 69719.045 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7690.061, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.048, - "Status": "Ok", - "TotalDuration": 31716.192, - "TotalOverhead": 77446.415, - "ValidationOverhead": 2.261 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 19188.256, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 6829.623, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2389533 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068513 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 69644060 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1075838976 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9951566172791431 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 94.56151337234942 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 25786580992 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 2508193792 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 545259520 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2181038080 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 687865856 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 25165824 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 993001472 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 26.441078991646314 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 37.33991209623587 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.86800422386483 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7725.595, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3743.299, - "Status": "Ok", - "TotalDuration": 19188.256, - "TotalOverhead": 18299.899, - "ValidationOverhead": 1.382 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22496.256, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 75026.799 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6335.973, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.408, - "Status": "Ok", - "TotalDuration": 22496.256, - "TotalOverhead": 81401.428, - "ValidationOverhead": 2.248 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22819.488, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.634 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7680.254, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.271, - "Status": "Ok", - "TotalDuration": 22819.488, - "TotalOverhead": 7717.325, - "ValidationOverhead": 1.166 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 104382.912, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 77557.853 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7636.443, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.411, - "Status": "Ok", - "TotalDuration": 104382.912, - "TotalOverhead": 85251.846, - "ValidationOverhead": 2.139 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 48 - }, - "Duration": 5218.496, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 81658.843 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7589.091, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.997, - "Status": "Ok", - "TotalDuration": 5218.496, - "TotalOverhead": 89307.09, - "ValidationOverhead": 2.159 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22262.784, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 75032.622 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7599.316, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.78, - "Status": "Ok", - "TotalDuration": 22262.784, - "TotalOverhead": 82690.013, - "ValidationOverhead": 2.295 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5278.048, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 79842.481 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7656.862, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.68, - "Status": "Ok", - "TotalDuration": 5278.048, - "TotalOverhead": 87536.112, - "ValidationOverhead": 2.089 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 48 - }, - "Duration": 5234.912, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 7817.961, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2346880 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068507 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 6540038 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 69206016 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.6177004437996807 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 81.98531507558873 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17733517312 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 680525824 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 134217728 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 167772160 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 293076992 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 594149376 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 49.62776468369281 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 78.94877161055506 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.9889697771895 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7710.976, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4391.162, - "Status": "Ok", - "TotalDuration": 5234.912, - "TotalOverhead": 19921.508, - "ValidationOverhead": 1.409 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 18979.52, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 73803.421 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6437.712, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.018, - "Status": "Ok", - "TotalDuration": 18979.52, - "TotalOverhead": 80278.177, - "ValidationOverhead": 2.026 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 18963.264, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.649 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7667.649, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.87, - "Status": "Ok", - "TotalDuration": 18963.264, - "TotalOverhead": 7703.425, - "ValidationOverhead": 1.257 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 169109.376, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 83012.81 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7621.431, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.864, - "Status": "Ok", - "TotalDuration": 169109.376, - "TotalOverhead": 90691.474, - "ValidationOverhead": 2.369 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 18991.232, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 18.733 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7572.746, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 23.365, - "Status": "Ok", - "TotalDuration": 18991.232, - "TotalOverhead": 7616.078, - "ValidationOverhead": 1.234 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5405.664, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 73775.377 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7653.191, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.166, - "Status": "Ok", - "TotalDuration": 5405.664, - "TotalOverhead": 81485.839, - "ValidationOverhead": 2.105 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 18994.688, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.791 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7674.111, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.232, - "Status": "Ok", - "TotalDuration": 18994.688, - "TotalOverhead": 7692.301, - "ValidationOverhead": 1.167 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5401.536, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 6717.057, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097298 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064447 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 10631566 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9796152540889057 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 81.86802068338072 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18270388224 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1226833920 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 268435456 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 301989888 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 300941312 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 636747776 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 49.73283611102272 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 82.62130588019824 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.97941539728284 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7692.831, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4297.62, - "Status": "Ok", - "TotalDuration": 5401.536, - "TotalOverhead": 18708.954, - "ValidationOverhead": 1.446 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5453.952, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 74899.329 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6454.782, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.981, - "Status": "Ok", - "TotalDuration": 5453.952, - "TotalOverhead": 81392.179, - "ValidationOverhead": 2.087 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5465.28, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 3.254 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7687.87, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.028, - "Status": "Ok", - "TotalDuration": 5465.28, - "TotalOverhead": 7724.372, - "ValidationOverhead": 1.22 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5473.344, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 73102.507 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7669.048, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.704, - "Status": "Ok", - "TotalDuration": 5473.344, - "TotalOverhead": 80827.371, - "ValidationOverhead": 2.112 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 15 - }, - "Duration": 102870.272, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 73664.106 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7743.561, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.589, - "Status": "Ok", - "TotalDuration": 102870.272, - "TotalOverhead": 81463.691, - "ValidationOverhead": 2.435 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5481.568, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 73100.46 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7771.792, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.789, - "Status": "Ok", - "TotalDuration": 5481.568, - "TotalOverhead": 80929.423, - "ValidationOverhead": 2.382 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 15 - }, - "Duration": 29899.52, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 71336.071 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7719.888, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.303, - "Status": "Ok", - "TotalDuration": 29899.52, - "TotalOverhead": 79091.52, - "ValidationOverhead": 2.258 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5802.112, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 6313.164, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2243030 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068509 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 10631878 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9767657519516632 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 84.61834225206759 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18270388224 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1226833920 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 268435456 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 301989888 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 300941312 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 636747776 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 51.48513398519206 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 82.75225484764718 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.97941539728284 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7772.646, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4319.801, - "Status": "Ok", - "TotalDuration": 5802.112, - "TotalOverhead": 18407.029, - "ValidationOverhead": 1.418 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 30945.92, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 70422.917 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7602.161, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.518, - "Status": "Ok", - "TotalDuration": 30945.92, - "TotalOverhead": 78061.714, - "ValidationOverhead": 2.118 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 31239.968, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.52 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7711.165, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 29.743, - "Status": "Ok", - "TotalDuration": 31239.968, - "TotalOverhead": 7744.638, - "ValidationOverhead": 1.21 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9666.272, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 74011.174 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7696.699, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.776, - "Status": "Ok", - "TotalDuration": 9666.272, - "TotalOverhead": 81763.76, - "ValidationOverhead": 2.111 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 37796.64, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 72436.31 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8486.67, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.392, - "Status": "Ok", - "TotalDuration": 37796.64, - "TotalOverhead": 80981.491, - "ValidationOverhead": 2.119 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 30925.12, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.838 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7622.804, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 23.063, - "Status": "Ok", - "TotalDuration": 30925.12, - "TotalOverhead": 7649.908, - "ValidationOverhead": 1.203 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9922.176, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 19.651 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7598.321, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 13.169, - "Status": "Ok", - "TotalDuration": 9922.176, - "TotalOverhead": 7632.542, - "ValidationOverhead": 1.401 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 10021.504, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 7805.017, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388805 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064435 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 35943154 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097749 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9970046143574786 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 89.45212803966936 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 21491613696 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1308622848 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 272629760 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 1107296256 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 897581056 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 784728064 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 38.423686953044694 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 57.07854436060643 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.91648571905796 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7722.562, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4073.434, - "Status": "Ok", - "TotalDuration": 10021.504, - "TotalOverhead": 19602.516, - "ValidationOverhead": 1.503 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 150465.344, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 80099.259 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6994.855, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.827, - "Status": "Ok", - "TotalDuration": 150465.344, - "TotalOverhead": 87132.099, - "ValidationOverhead": 2.158 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 140187.552, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.547 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7661.664, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.723, - "Status": "Ok", - "TotalDuration": 140187.552, - "TotalOverhead": 7697.015, - "ValidationOverhead": 1.081 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 32101.09, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 70965.322 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7629.761, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.705, - "Status": "Ok", - "TotalDuration": 32101.09, - "TotalOverhead": 78651.913, - "ValidationOverhead": 2.125 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 44032.224, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 69616.179 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7698.694, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.305, - "Status": "Ok", - "TotalDuration": 44032.224, - "TotalOverhead": 77370.216, - "ValidationOverhead": 2.038 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 34221.536, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 20.17 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7718.832, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 24.374, - "Status": "Ok", - "TotalDuration": 34221.536, - "TotalOverhead": 7764.588, - "ValidationOverhead": 1.212 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 44810.112, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.404 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7694.574, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.677, - "Status": "Ok", - "TotalDuration": 44810.112, - "TotalOverhead": 7713.098, - "ValidationOverhead": 1.443 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 34219.712, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 4928.302, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2889988 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 19349313 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 676076040 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065535 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 88.62068965517241 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9918874850876696 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.84043070802072 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 22565355520 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 19541262336 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 2155872256 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 8644460544 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 4349493248 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1823866880 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 13.033698517196393 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 39.254702246687806 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.12432626661875 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7835.212, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4068.786, - "Status": "Ok", - "TotalDuration": 34219.712, - "TotalOverhead": 16833.71, - "ValidationOverhead": 1.41 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 42534.432, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 69674.709 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8125.448, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.25, - "Status": "Ok", - "TotalDuration": 42534.432, - "TotalOverhead": 77836.641, - "ValidationOverhead": 2.234 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 44782.88, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.75 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7716.409, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 30.592, - "Status": "Ok", - "TotalDuration": 44782.88, - "TotalOverhead": 7750.963, - "ValidationOverhead": 1.212 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 44416.352, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.297 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7660.73, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.689, - "Status": "Ok", - "TotalDuration": 44416.352, - "TotalOverhead": 7685.169, - "ValidationOverhead": 1.453 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 44366.368, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.3 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7666.152, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 19.281, - "Status": "Ok", - "TotalDuration": 44366.368, - "TotalOverhead": 7689.134, - "ValidationOverhead": 1.401 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 44881.536, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.217 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 10469.798, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 19.823, - "Status": "Ok", - "TotalDuration": 44881.536, - "TotalOverhead": 10493.216, - "ValidationOverhead": 1.378 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 44528.832, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.248 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7740.56, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 12.079, - "Status": "Ok", - "TotalDuration": 44528.832, - "TotalOverhead": 7756.256, - "ValidationOverhead": 1.369 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 44031.008, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 9333.333, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2680272 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2090622 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 810231185 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065229 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1614807040 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 79.8136645962733 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9886268008231196 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 98.24470246073794 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 27934064640 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 38948306944 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4311744512 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 17238589440 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 8707375104 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 25165824 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 3104833536 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 13.17136397750538 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 51.10425111443307 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 97.79635258358662 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7670.744, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3693.079, - "Status": "Ok", - "TotalDuration": 44031.008, - "TotalOverhead": 20698.613, - "ValidationOverhead": 1.457 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 37464.128, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 70790.862 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6291.095, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.502, - "Status": "Ok", - "TotalDuration": 37464.128, - "TotalOverhead": 77118.351, - "ValidationOverhead": 1.892 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 37729.952, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.794 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7605.21, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.849, - "Status": "Ok", - "TotalDuration": 37729.952, - "TotalOverhead": 7641.062, - "ValidationOverhead": 1.209 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 38338.976, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.49 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7575.289, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.649, - "Status": "Ok", - "TotalDuration": 38338.976, - "TotalOverhead": 7600.873, - "ValidationOverhead": 1.445 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 37888.384, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 70747.67 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7659.144, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.601, - "Status": "Ok", - "TotalDuration": 37888.384, - "TotalOverhead": 78463.567, - "ValidationOverhead": 2.152 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 38975.872, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.79 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7620.716, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 24.094, - "Status": "Ok", - "TotalDuration": 38975.872, - "TotalOverhead": 7648.839, - "ValidationOverhead": 1.239 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 38531.296, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.739 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8452.281, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 15.347, - "Status": "Ok", - "TotalDuration": 38531.296, - "TotalOverhead": 8471.942, - "ValidationOverhead": 1.575 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 38306.656, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 9069.946, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2973714 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2081231 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 609069381 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065526 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1614807040 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 93.7956204379562 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9896515104459924 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 97.20633485122755 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 27934064640 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 23941087232 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4311744512 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 10796138496 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 4395630592 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 25165824 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 2299789312 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 14.777943214248115 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 45.16601429394262 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 97.02496295451955 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7749.446, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3866.116, - "Status": "Ok", - "TotalDuration": 38306.656, - "TotalOverhead": 20686.988, - "ValidationOverhead": 1.48 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 34082.784, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 72352.053 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7702.897, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.5, - "Status": "Ok", - "TotalDuration": 34082.784, - "TotalOverhead": 80090.645, - "ValidationOverhead": 2.195 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 35391.744, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.563 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7731.305, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.546, - "Status": "Ok", - "TotalDuration": 35391.744, - "TotalOverhead": 7766.614, - "ValidationOverhead": 1.2 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 35877.504, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.301 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7736.024, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.07, - "Status": "Ok", - "TotalDuration": 35877.504, - "TotalOverhead": 7760.887, - "ValidationOverhead": 1.492 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 35883.328, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.378 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7712.353, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.167, - "Status": "Ok", - "TotalDuration": 35883.328, - "TotalOverhead": 7736.398, - "ValidationOverhead": 1.5 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 36031.264, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.427 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7656.373, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.11, - "Status": "Ok", - "TotalDuration": 36031.264, - "TotalOverhead": 7680.258, - "ValidationOverhead": 1.348 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 36438.72, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.349 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7696.744, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 12.38, - "Status": "Ok", - "TotalDuration": 36438.72, - "TotalOverhead": 7712.785, - "ValidationOverhead": 1.312 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 36452.0, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 4430.389, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2680288 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 22360329 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 676011746 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065302 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 88.62068965517241 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9939776685409752 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.95327068465468 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 22565355520 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 25983713280 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4303355904 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 12939427840 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 4349493248 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 2226520064 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 12.417406515016832 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 44.417504448432965 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.4635309354212 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7693.133, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4120.134, - "Status": "Ok", - "TotalDuration": 36452.0, - "TotalOverhead": 16245.077, - "ValidationOverhead": 1.421 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171585.792, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 79994.823 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6429.916, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.589, - "Status": "Ok", - "TotalDuration": 171585.792, - "TotalOverhead": 86461.856, - "ValidationOverhead": 2.528 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171441.184, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 20.121 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7664.408, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.923, - "Status": "Ok", - "TotalDuration": 171441.184, - "TotalOverhead": 7718.582, - "ValidationOverhead": 1.13 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 169564.864, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 81775.545 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7658.567, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.295, - "Status": "Ok", - "TotalDuration": 169564.864, - "TotalOverhead": 89491.448, - "ValidationOverhead": 2.041 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 85994.88, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 74680.301 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7676.964, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.866, - "Status": "Ok", - "TotalDuration": 85994.88, - "TotalOverhead": 82415.37, - "ValidationOverhead": 2.239 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5678.752, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 78267.308 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7701.155, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.874, - "Status": "Ok", - "TotalDuration": 5678.752, - "TotalOverhead": 86026.874, - "ValidationOverhead": 2.537 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 29703.392, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 71252.795 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7769.125, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.106, - "Status": "Ok", - "TotalDuration": 29703.392, - "TotalOverhead": 79058.132, - "ValidationOverhead": 2.106 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 6039.2, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 6277.727, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097427 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064439 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 19020178 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 69206016 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.4953275693050723 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 84.02489902422872 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17733517312 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1485832192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 134217728 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 570425344 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1504182272 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 669745152 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 47.4325018919664 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 85.05592332357841 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.99021478545917 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7764.418, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4582.592, - "Status": "Ok", - "TotalDuration": 6039.2, - "TotalOverhead": 18626.142, - "ValidationOverhead": 1.405 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171183.744, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 80065.208 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6396.344, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.939, - "Status": "Ok", - "TotalDuration": 171183.744, - "TotalOverhead": 86498.589, - "ValidationOverhead": 2.098 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171236.992, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.778 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7670.924, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.599, - "Status": "Ok", - "TotalDuration": 171236.992, - "TotalOverhead": 7707.523, - "ValidationOverhead": 1.222 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 168397.184, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 83047.999 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7632.329, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.08, - "Status": "Ok", - "TotalDuration": 168397.184, - "TotalOverhead": 90736.301, - "ValidationOverhead": 2.893 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 25 - }, - "Duration": 172474.624, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 80829.27 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7633.038, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 57.075, - "Status": "Ok", - "TotalDuration": 172474.624, - "TotalOverhead": 88521.558, - "ValidationOverhead": 2.175 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6511.424, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 74594.014 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7648.539, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.142, - "Status": "Ok", - "TotalDuration": 6511.424, - "TotalOverhead": 82299.809, - "ValidationOverhead": 2.114 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171187.168, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 18.655 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7615.209, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 16.999, - "Status": "Ok", - "TotalDuration": 171187.168, - "TotalOverhead": 7652.142, - "ValidationOverhead": 1.279 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6503.392, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 6814.279, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388780 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064443 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 35943174 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.7340339574797439 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 85.95931438348336 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18270388224 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 2837446656 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 268435456 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 1107296256 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2991587328 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 796327936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 43.7152268263477 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 91.13877193221884 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.98354044934574 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7759.927, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4223.099, - "Status": "Ok", - "TotalDuration": 6503.392, - "TotalOverhead": 18798.756, - "ValidationOverhead": 1.451 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22310.08, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 72890.178 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6341.311, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.419, - "Status": "Ok", - "TotalDuration": 22310.08, - "TotalOverhead": 79268.907, - "ValidationOverhead": 1.999 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22284.416, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.719 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7642.342, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.047, - "Status": "Ok", - "TotalDuration": 22284.416, - "TotalOverhead": 7679.371, - "ValidationOverhead": 1.263 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 22 - }, - "Duration": 172372.704, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 80528.924 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7649.525, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.728, - "Status": "Ok", - "TotalDuration": 172372.704, - "TotalOverhead": 88235.381, - "ValidationOverhead": 2.204 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 103206.784, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 73436.871 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7648.62, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.361, - "Status": "Ok", - "TotalDuration": 103206.784, - "TotalOverhead": 81141.73, - "ValidationOverhead": 1.878 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5448.832, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 78481.357 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7681.743, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.027, - "Status": "Ok", - "TotalDuration": 5448.832, - "TotalOverhead": 86219.121, - "ValidationOverhead": 1.994 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 32344.8, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 70612.379 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7713.346, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.313, - "Status": "Ok", - "TotalDuration": 32344.8, - "TotalOverhead": 78363.465, - "ValidationOverhead": 2.427 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5678.624, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 6444.562, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097427 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064439 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 19020186 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 69206016 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.552177202583204 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 84.22371434839422 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17733517312 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1485832192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 134217728 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 570425344 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1504182272 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 669745152 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 49.08102946998715 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 87.80424581718114 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.99021478545917 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7867.533, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4318.59, - "Status": "Ok", - "TotalDuration": 5678.624, - "TotalOverhead": 18632.245, - "ValidationOverhead": 1.56 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5428.8, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 81131.719 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6375.917, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.41, - "Status": "Ok", - "TotalDuration": 5428.8, - "TotalOverhead": 87545.097, - "ValidationOverhead": 2.051 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5430.88, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.607 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7725.877, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.274, - "Status": "Ok", - "TotalDuration": 5430.88, - "TotalOverhead": 7760.95, - "ValidationOverhead": 1.192 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 105135.104, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 77002.591 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7684.122, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.373, - "Status": "Ok", - "TotalDuration": 105135.104, - "TotalOverhead": 84743.449, - "ValidationOverhead": 2.363 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171736.576, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 82831.1 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7666.525, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.789, - "Status": "Ok", - "TotalDuration": 171736.576, - "TotalOverhead": 90553.905, - "ValidationOverhead": 2.491 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 105344.704, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.762 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7653.476, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.212, - "Status": "Ok", - "TotalDuration": 105344.704, - "TotalOverhead": 7682.739, - "ValidationOverhead": 1.289 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171682.752, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.478 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7623.698, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.077, - "Status": "Ok", - "TotalDuration": 171682.752, - "TotalOverhead": 7641.713, - "ValidationOverhead": 1.46 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5428.224, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 6700.255, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388788 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064419 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 19166142 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 69206016 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.5507180360960545 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 82.93772572765978 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17733517312 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1485832192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 134217728 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 570425344 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1504182272 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 669745152 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 48.3492176778363 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 87.83625697423581 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.99021478545917 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7688.144, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3847.637, - "Status": "Ok", - "TotalDuration": 5428.224, - "TotalOverhead": 18237.451, - "ValidationOverhead": 1.415 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 18 - }, - "Duration": 171867.552, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 85447.863 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6919.073, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.057, - "Status": "Ok", - "TotalDuration": 171867.552, - "TotalOverhead": 92405.049, - "ValidationOverhead": 2.056 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 18 - }, - "Duration": 171935.136, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.809 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7606.138, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.542, - "Status": "Ok", - "TotalDuration": 171935.136, - "TotalOverhead": 7643.687, - "ValidationOverhead": 1.198 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 22 - }, - "Duration": 172424.032, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 83965.643 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7591.049, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.615, - "Status": "Ok", - "TotalDuration": 172424.032, - "TotalOverhead": 91614.484, - "ValidationOverhead": 2.177 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 18 - }, - "Duration": 171737.056, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.818 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7588.219, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 24.961, - "Status": "Ok", - "TotalDuration": 171737.056, - "TotalOverhead": 7617.309, - "ValidationOverhead": 1.311 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5303.424, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 76469.72 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7745.317, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.47, - "Status": "Ok", - "TotalDuration": 5303.424, - "TotalOverhead": 84272.52, - "ValidationOverhead": 2.013 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9767.872, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 73828.739 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7695.641, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.578, - "Status": "Ok", - "TotalDuration": 9767.872, - "TotalOverhead": 81560.92, - "ValidationOverhead": 1.962 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5296.64, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 7771.912, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2198158 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064439 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 18975372 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 270532608 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9807554654888567 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 83.57492722414968 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19344130048 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 721420288 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 570425344 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 465567744 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 664207360 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 56.9628968635293 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 93.13936535449626 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.95066600888012 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7726.474, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3855.786, - "Status": "Ok", - "TotalDuration": 5296.64, - "TotalOverhead": 19355.614, - "ValidationOverhead": 1.442 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 27397.344, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 73132.618 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6371.875, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.91, - "Status": "Ok", - "TotalDuration": 27397.344, - "TotalOverhead": 79541.386, - "ValidationOverhead": 1.983 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 28357.472, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.523 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7800.878, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.437, - "Status": "Ok", - "TotalDuration": 28357.472, - "TotalOverhead": 7838.059, - "ValidationOverhead": 1.221 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 104780.064, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 75229.82 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7700.201, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.751, - "Status": "Ok", - "TotalDuration": 104780.064, - "TotalOverhead": 82985.831, - "ValidationOverhead": 2.059 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 28277.376, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 71282.014 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7648.044, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.926, - "Status": "Ok", - "TotalDuration": 28277.376, - "TotalOverhead": 78986.991, - "ValidationOverhead": 2.007 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 104668.608, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.966 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7642.985, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 24.202, - "Status": "Ok", - "TotalDuration": 104668.608, - "TotalOverhead": 7671.384, - "ValidationOverhead": 1.231 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5308.864, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 76393.94 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7649.514, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.094, - "Status": "Ok", - "TotalDuration": 5308.864, - "TotalOverhead": 84079.464, - "ValidationOverhead": 1.916 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 27392.544, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 8209.727, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2780687 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 167090912 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 558571674 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065227 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.09160305343511 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9900863451807338 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.00965211188952 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 6123683840 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2738880512 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1111490560 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 983957504 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 12.930279379750953 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 28.893326045610795 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.26162248568004 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7662.583, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3701.329, - "Status": "Ok", - "TotalDuration": 27392.544, - "TotalOverhead": 19575.14, - "ValidationOverhead": 1.501 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 28303.328, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 73614.361 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6318.978, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.532, - "Status": "Ok", - "TotalDuration": 28303.328, - "TotalOverhead": 79970.855, - "ValidationOverhead": 1.984 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 29450.528, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.555 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7674.817, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.758, - "Status": "Ok", - "TotalDuration": 29450.528, - "TotalOverhead": 7713.351, - "ValidationOverhead": 1.221 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 28967.488, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 73501.431 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7642.158, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.384, - "Status": "Ok", - "TotalDuration": 28967.488, - "TotalOverhead": 81200.997, - "ValidationOverhead": 2.024 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 27456.832, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 72673.975 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7621.688, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.978, - "Status": "Ok", - "TotalDuration": 27456.832, - "TotalOverhead": 80352.607, - "ValidationOverhead": 1.966 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6839.456, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 76486.786 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7693.447, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.425, - "Status": "Ok", - "TotalDuration": 6839.456, - "TotalOverhead": 84237.773, - "ValidationOverhead": 2.115 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6808.352, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 17.913 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7785.065, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 16.503, - "Status": "Ok", - "TotalDuration": 6808.352, - "TotalOverhead": 7820.635, - "ValidationOverhead": 1.154 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6826.624, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 6504.377, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097315 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064437 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 69351842 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 270532608 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9867612697773265 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 86.12396245700054 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19344130048 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1793064960 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2181038080 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 731906048 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 756350976 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 48.17858607052584 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 81.66723074796553 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.95667619790312 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7726.918, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3982.259, - "Status": "Ok", - "TotalDuration": 6826.624, - "TotalOverhead": 18214.968, - "ValidationOverhead": 1.414 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6642.08, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 76547.55 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7332.054, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.888, - "Status": "Ok", - "TotalDuration": 6642.08, - "TotalOverhead": 83915.48, - "ValidationOverhead": 1.988 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6603.104, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.719 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7712.028, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.448, - "Status": "Ok", - "TotalDuration": 6603.104, - "TotalOverhead": 7748.347, - "ValidationOverhead": 1.152 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6646.72, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 77102.745 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7663.979, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.848, - "Status": "Ok", - "TotalDuration": 6646.72, - "TotalOverhead": 84823.573, - "ValidationOverhead": 2.001 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 34565.472, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 70304.094 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7680.238, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.936, - "Status": "Ok", - "TotalDuration": 34565.472, - "TotalOverhead": 78041.338, - "ValidationOverhead": 2.07 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 31360.896, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 71658.426 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7689.532, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.632, - "Status": "Ok", - "TotalDuration": 31360.896, - "TotalOverhead": 79404.601, - "ValidationOverhead": 2.011 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6952.192, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 3.086 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7710.995, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.948, - "Status": "Ok", - "TotalDuration": 6952.192, - "TotalOverhead": 7730.241, - "ValidationOverhead": 1.212 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6903.84, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 7719.249, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388780 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064437 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 69497558 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 270532608 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9696911049381691 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 86.07489271859295 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19344130048 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1793064960 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2181038080 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 731906048 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 756350976 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 47.31960479831336 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 80.25715572284736 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.95667619790312 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7737.01, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4054.058, - "Status": "Ok", - "TotalDuration": 6903.84, - "TotalOverhead": 19511.766, - "ValidationOverhead": 1.449 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 32363.392, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 70600.556 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6337.939, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.377, - "Status": "Ok", - "TotalDuration": 32363.392, - "TotalOverhead": 76975.916, - "ValidationOverhead": 2.044 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 33232.674, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.496 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7964.074, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 48.483, - "Status": "Ok", - "TotalDuration": 33232.674, - "TotalOverhead": 8016.202, - "ValidationOverhead": 1.149 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6796.608, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 73937.018 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7723.875, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.582, - "Status": "Ok", - "TotalDuration": 6796.608, - "TotalOverhead": 81716.899, - "ValidationOverhead": 2.424 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 32713.826, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.619 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7813.873, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.249, - "Status": "Ok", - "TotalDuration": 32713.826, - "TotalOverhead": 7842.943, - "ValidationOverhead": 1.202 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 33748.192, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.544 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7638.28, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.703, - "Status": "Ok", - "TotalDuration": 33748.192, - "TotalOverhead": 7664.007, - "ValidationOverhead": 1.48 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 34184.8, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.294 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7692.493, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 13.963, - "Status": "Ok", - "TotalDuration": 34184.8, - "TotalOverhead": 7710.174, - "ValidationOverhead": 1.424 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6846.272, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 6331.82, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097317 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064966 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 35797806 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.7342143369208851 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 86.0478384808304 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18270388224 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 2837446656 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 268435456 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 1107296256 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2991587328 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 796327936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 43.77563572448622 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 91.17073311086149 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.98354044934574 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7742.363, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4159.088, - "Status": "Ok", - "TotalDuration": 6846.272, - "TotalOverhead": 18234.689, - "ValidationOverhead": 1.418 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 105510.528, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 74627.41 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6365.088, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.204, - "Status": "Ok", - "TotalDuration": 105510.528, - "TotalOverhead": 81028.743, - "ValidationOverhead": 2.041 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 105442.592, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.703 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7656.989, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.449, - "Status": "Ok", - "TotalDuration": 105442.592, - "TotalOverhead": 7694.337, - "ValidationOverhead": 1.196 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 103553.12, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 74876.733 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7653.609, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.374, - "Status": "Ok", - "TotalDuration": 103553.12, - "TotalOverhead": 82586.764, - "ValidationOverhead": 2.048 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 34047.936, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 69850.732 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7760.811, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.614, - "Status": "Ok", - "TotalDuration": 34047.936, - "TotalOverhead": 77670.353, - "ValidationOverhead": 2.196 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 20201.6, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 72438.884 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7642.054, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 58.759, - "Status": "Ok", - "TotalDuration": 20201.6, - "TotalOverhead": 80141.684, - "ValidationOverhead": 1.987 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 19667.936, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.456 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7764.895, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.988, - "Status": "Ok", - "TotalDuration": 19667.936, - "TotalOverhead": 7783.507, - "ValidationOverhead": 1.168 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 19179.104, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 6747.825, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2389340 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064459 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 69644248 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1075838976 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9949359928233351 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 94.79762520987047 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 25786580992 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 2508193792 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 545259520 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2181038080 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 687865856 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 25165824 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 993001472 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 26.55192783011382 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 37.40306643582099 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.86800422386483 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7775.085, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3741.023, - "Status": "Ok", - "TotalDuration": 19179.104, - "TotalOverhead": 18265.365, - "ValidationOverhead": 1.432 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 24 - }, - "Duration": 171971.232, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 78677.392 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6431.568, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.082, - "Status": "Ok", - "TotalDuration": 171971.232, - "TotalOverhead": 85145.74, - "ValidationOverhead": 2.698 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 24 - }, - "Duration": 171876.128, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 17.939 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7636.877, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.079, - "Status": "Ok", - "TotalDuration": 171876.128, - "TotalOverhead": 7690.18, - "ValidationOverhead": 1.285 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 92897.12, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 74837.371 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7658.125, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.588, - "Status": "Ok", - "TotalDuration": 92897.12, - "TotalOverhead": 82551.093, - "ValidationOverhead": 2.009 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 92456.896, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.412 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7673.842, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 23.15, - "Status": "Ok", - "TotalDuration": 92456.896, - "TotalOverhead": 7700.563, - "ValidationOverhead": 1.159 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 92485.6, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 19.078 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7610.499, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.607, - "Status": "Ok", - "TotalDuration": 92485.6, - "TotalOverhead": 7651.567, - "ValidationOverhead": 1.383 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 24 - }, - "Duration": 171925.216, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.656 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7634.534, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.445, - "Status": "Ok", - "TotalDuration": 171925.216, - "TotalOverhead": 7653.054, - "ValidationOverhead": 1.419 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 92698.112, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 6300.758, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 89966854 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 436590162 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 551206984 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 675282944 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.84615384615384 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.93821095703145 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 99.45676634199754 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18538823680 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 3106930688 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2470445056 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 550502400 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 796327936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 3.545208905692566 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 6.6304640333022276 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.92601431980907 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7796.305, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3740.036, - "Status": "Ok", - "TotalDuration": 92698.112, - "TotalOverhead": 17838.44, - "ValidationOverhead": 1.341 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 89868.128, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 77063.31 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6346.684, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.395, - "Status": "Ok", - "TotalDuration": 89868.128, - "TotalOverhead": 83446.707, - "ValidationOverhead": 2.318 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 90028.48, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.737 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7660.227, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.183, - "Status": "Ok", - "TotalDuration": 90028.48, - "TotalOverhead": 7697.363, - "ValidationOverhead": 1.216 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 86592.256, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 76720.715 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7669.294, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.023, - "Status": "Ok", - "TotalDuration": 86592.256, - "TotalOverhead": 84447.522, - "ValidationOverhead": 2.49 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 86850.592, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.406 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7668.039, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 23.562, - "Status": "Ok", - "TotalDuration": 86850.592, - "TotalOverhead": 7695.162, - "ValidationOverhead": 1.155 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171917.024, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 80037.744 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7726.035, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.587, - "Status": "Ok", - "TotalDuration": 171917.024, - "TotalOverhead": 87819.22, - "ValidationOverhead": 1.854 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 92200.896, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 74990.949 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7736.926, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.473, - "Status": "Ok", - "TotalDuration": 92200.896, - "TotalOverhead": 82763.254, - "ValidationOverhead": 1.906 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 87194.208, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 7849.896, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 75894431 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 419050110 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 576370408 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 675282944 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 96.61654135338345 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.910253994085721 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 99.11354799631808 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18538823680 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 4985978880 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 3275751424 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1087373312 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 896991232 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 3.7784688803088584 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 7.6048306169113316 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.04654051289545 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7767.629, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4087.205, - "Status": "Ok", - "TotalDuration": 87194.208, - "TotalOverhead": 19706.205, - "ValidationOverhead": 1.475 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 86336.608, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 76825.071 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6324.969, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.945, - "Status": "Ok", - "TotalDuration": 86336.608, - "TotalOverhead": 83186.002, - "ValidationOverhead": 2.017 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 85616.864, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.674 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7681.499, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.455, - "Status": "Ok", - "TotalDuration": 85616.864, - "TotalOverhead": 7717.928, - "ValidationOverhead": 1.3 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 86329.28, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.68 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7627.919, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 22.094, - "Status": "Ok", - "TotalDuration": 86329.28, - "TotalOverhead": 7654.243, - "ValidationOverhead": 1.55 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12006.72, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 74818.693 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7656.443, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.309, - "Status": "Ok", - "TotalDuration": 12006.72, - "TotalOverhead": 82532.408, - "ValidationOverhead": 1.963 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 86207.648, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.918 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7694.657, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 23.353, - "Status": "Ok", - "TotalDuration": 86207.648, - "TotalOverhead": 7722.158, - "ValidationOverhead": 1.23 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12225.312, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.43 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7618.399, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 13.016, - "Status": "Ok", - "TotalDuration": 12225.312, - "TotalOverhead": 7635.283, - "ValidationOverhead": 1.438 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 11943.584, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 6675.998, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388780 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064457 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 136606426 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9739432379385038 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 91.10044673086995 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 21491613696 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 3451912192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 272629760 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 4328521728 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1698693120 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 977403904 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 32.35830202725481 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 52.25035211634595 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.93294890706719 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8723.427, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3708.477, - "Status": "Ok", - "TotalDuration": 11943.584, - "TotalOverhead": 19109.391, - "ValidationOverhead": 1.489 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 105519.264, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 74429.631 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6336.05, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.843, - "Status": "Ok", - "TotalDuration": 105519.264, - "TotalOverhead": 80801.597, - "ValidationOverhead": 2.073 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 105405.152, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 19.935 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7658.279, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.152, - "Status": "Ok", - "TotalDuration": 105405.152, - "TotalOverhead": 7710.51, - "ValidationOverhead": 1.144 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 105390.56, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 19.878 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7658.707, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 22.326, - "Status": "Ok", - "TotalDuration": 105390.56, - "TotalOverhead": 7702.274, - "ValidationOverhead": 1.363 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6554.336, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 73199.424 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7682.067, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.287, - "Status": "Ok", - "TotalDuration": 6554.336, - "TotalOverhead": 80937.906, - "ValidationOverhead": 2.128 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 87114.88, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 75243.42 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7709.631, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 52.356, - "Status": "Ok", - "TotalDuration": 87114.88, - "TotalOverhead": 83008.08, - "ValidationOverhead": 2.673 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 86458.432, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.426 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7684.333, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 16.451, - "Status": "Ok", - "TotalDuration": 86458.432, - "TotalOverhead": 7704.383, - "ValidationOverhead": 1.173 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6567.584, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 6679.15, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097754 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064451 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 35652252 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.723171517369095 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 84.56873573492646 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18270388224 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 2837446656 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 268435456 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 1107296256 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2991587328 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 796327936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 42.79749697819305 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 90.6925011886449 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.98354044934574 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8626.695, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3857.479, - "Status": "Ok", - "TotalDuration": 6567.584, - "TotalOverhead": 19164.881, - "ValidationOverhead": 1.557 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 103465.888, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 88875.068 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6516.88, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 38.009, - "Status": "Ok", - "TotalDuration": 103465.888, - "TotalOverhead": 95432.247, - "ValidationOverhead": 2.29 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 103120.992, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.78 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7794.182, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.503, - "Status": "Ok", - "TotalDuration": 103120.992, - "TotalOverhead": 7831.695, - "ValidationOverhead": 1.23 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 104318.816, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 73495.05 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7702.363, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.003, - "Status": "Ok", - "TotalDuration": 104318.816, - "TotalOverhead": 81253.716, - "ValidationOverhead": 2.3 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6528.544, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 73485.026 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7647.711, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.531, - "Status": "Ok", - "TotalDuration": 6528.544, - "TotalOverhead": 81189.342, - "ValidationOverhead": 2.074 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 103179.456, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.652 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7643.142, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 23.892, - "Status": "Ok", - "TotalDuration": 103179.456, - "TotalOverhead": 7670.914, - "ValidationOverhead": 1.228 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 28109.088, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 71701.838 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7965.299, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.788, - "Status": "Ok", - "TotalDuration": 28109.088, - "TotalOverhead": 79703.004, - "ValidationOverhead": 2.079 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6654.656, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6713.413, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388780 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068509 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 35943126 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.7327946741882977 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 85.26584194186708 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18270388224 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 2837446656 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 268435456 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 1107296256 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2991587328 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 796327936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 43.287733546635614 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 90.98127691966373 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.98354044934574 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8466.683, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 4172.787, - "Status": "Ok", - "TotalDuration": 6654.656, - "TotalOverhead": 19354.344, - "ValidationOverhead": 1.461 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5316.096, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 78793.607 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6350.473, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 39.784, - "Status": "Ok", - "TotalDuration": 5316.096, - "TotalOverhead": 85185.888, - "ValidationOverhead": 2.024 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5306.976, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.768 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7688.474, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.524, - "Status": "Ok", - "TotalDuration": 5306.976, - "TotalOverhead": 7726.017, - "ValidationOverhead": 1.251 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5320.096, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 19.688 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7597.454, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.829, - "Status": "Ok", - "TotalDuration": 5320.096, - "TotalOverhead": 7639.419, - "ValidationOverhead": 1.448 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5314.112, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.334 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7619.614, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.015, - "Status": "Ok", - "TotalDuration": 5314.112, - "TotalOverhead": 7643.342, - "ValidationOverhead": 1.379 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5463.84, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 75689.315 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7730.25, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.104, - "Status": "Ok", - "TotalDuration": 5463.84, - "TotalOverhead": 83474.753, - "ValidationOverhead": 2.084 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5467.296, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.481 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7675.007, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.979, - "Status": "Ok", - "TotalDuration": 5467.296, - "TotalOverhead": 7693.694, - "ValidationOverhead": 1.227 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 5309.536, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 6869.577, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2389324 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068507 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 19166462 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 270532608 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9765976272017381 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 83.3073126743075 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19344130048 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 721420288 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 570425344 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 465567744 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 664207360 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 56.66991062956387 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 92.95811242889246 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.95066600888012 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7730.104, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3818.552, - "Status": "Ok", - "TotalDuration": 5309.536, - "TotalOverhead": 18419.685, - "ValidationOverhead": 1.452 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 15 - }, - "Duration": 30844.256, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 72249.861 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7434.185, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.183, - "Status": "Ok", - "TotalDuration": 30844.256, - "TotalOverhead": 79720.226, - "ValidationOverhead": 1.997 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 15 - }, - "Duration": 31930.112, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.797 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 9990.595, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.741, - "Status": "Ok", - "TotalDuration": 31930.112, - "TotalOverhead": 10026.383, - "ValidationOverhead": 1.25 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 48 - }, - "Duration": 5360.768, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 79738.979 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7749.847, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.437, - "Status": "Ok", - "TotalDuration": 5360.768, - "TotalOverhead": 87546.335, - "ValidationOverhead": 2.072 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 15 - }, - "Duration": 30839.2, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.708 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7690.394, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 24.474, - "Status": "Ok", - "TotalDuration": 30839.2, - "TotalOverhead": 7718.606, - "ValidationOverhead": 1.03 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 30640.896, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 74093.154 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7678.158, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.601, - "Status": "Ok", - "TotalDuration": 30640.896, - "TotalOverhead": 81826.972, - "ValidationOverhead": 2.059 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 29272.576, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.361 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7764.235, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 15.175, - "Status": "Ok", - "TotalDuration": 29272.576, - "TotalOverhead": 7782.896, - "ValidationOverhead": 1.125 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 48 - }, - "Duration": 5296.384, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6685.368, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2389044 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068509 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 6583002 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 69206016 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.6107335101885313 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 81.47311310208273 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17733517312 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 680525824 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 134217728 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 167772160 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 293076992 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 594149376 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 49.92039183709049 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 79.9135019573056 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.9889697771895 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7825.185, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3885.065, - "Status": "Ok", - "TotalDuration": 5296.384, - "TotalOverhead": 18396.997, - "ValidationOverhead": 1.379 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9780.48, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 76140.577 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6778.108, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.995, - "Status": "Ok", - "TotalDuration": 9780.48, - "TotalOverhead": 82957.708, - "ValidationOverhead": 2.028 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9780.896, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.839 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7673.032, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.696, - "Status": "Ok", - "TotalDuration": 9780.896, - "TotalOverhead": 7708.729, - "ValidationOverhead": 1.162 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 18 - }, - "Duration": 28568.512, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 72474.686 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7656.941, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.694, - "Status": "Ok", - "TotalDuration": 28568.512, - "TotalOverhead": 80190.501, - "ValidationOverhead": 2.18 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 38705.344, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 70392.128 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7789.751, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.127, - "Status": "Ok", - "TotalDuration": 38705.344, - "TotalOverhead": 78237.954, - "ValidationOverhead": 1.948 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 32494.37, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 71203.486 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7712.667, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.3, - "Status": "Ok", - "TotalDuration": 32494.37, - "TotalOverhead": 78972.472, - "ValidationOverhead": 2.019 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 32499.936, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 19.889 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7657.484, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.937, - "Status": "Ok", - "TotalDuration": 32499.936, - "TotalOverhead": 7693.447, - "ValidationOverhead": 1.137 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 9981.632, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6644.564, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388780 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068505 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 35943126 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9974161222510014 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 90.14212585903198 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 21491613696 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1308622848 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 272629760 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 1107296256 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 897581056 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 784728064 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 38.67084885344992 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 57.00580201558668 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.91648571905796 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7725.035, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3592.457, - "Status": "Ok", - "TotalDuration": 9981.632, - "TotalOverhead": 17963.502, - "ValidationOverhead": 1.446 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5480.768, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 78456.119 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6342.996, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.831, - "Status": "Ok", - "TotalDuration": 5480.768, - "TotalOverhead": 84835.996, - "ValidationOverhead": 2.05 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5478.624, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.609 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7685.382, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.981, - "Status": "Ok", - "TotalDuration": 5478.624, - "TotalOverhead": 7721.101, - "ValidationOverhead": 1.129 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 29055.84, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 71680.585 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 9200.182, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 51.505, - "Status": "Ok", - "TotalDuration": 29055.84, - "TotalOverhead": 80934.62, - "ValidationOverhead": 2.348 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 24 - }, - "Duration": 171195.04, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 79297.263 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7664.33, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.088, - "Status": "Ok", - "TotalDuration": 171195.04, - "TotalOverhead": 87018.791, - "ValidationOverhead": 2.11 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 104225.088, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 73988.393 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7652.284, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.752, - "Status": "Ok", - "TotalDuration": 104225.088, - "TotalOverhead": 81697.446, - "ValidationOverhead": 2.017 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 29029.792, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 20.525 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8643.452, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 17.527, - "Status": "Ok", - "TotalDuration": 29029.792, - "TotalOverhead": 8682.727, - "ValidationOverhead": 1.223 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5702.752, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 6549.39, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097394 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2069030 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 19020558 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 69206016 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.5507265041466275 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 83.58913261172053 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17733517312 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1485832192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 134217728 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 570425344 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1504182272 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 669745152 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 48.15314657110892 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 86.7984300240152 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.99021478545917 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7755.02, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3965.601, - "Status": "Ok", - "TotalDuration": 5702.752, - "TotalOverhead": 18271.358, - "ValidationOverhead": 1.347 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 38160.064, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 71765.166 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6400.286, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.84, - "Status": "Ok", - "TotalDuration": 38160.064, - "TotalOverhead": 78203.238, - "ValidationOverhead": 1.946 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 38141.184, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 3.001 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7647.488, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.156, - "Status": "Ok", - "TotalDuration": 38141.184, - "TotalOverhead": 7684.802, - "ValidationOverhead": 1.157 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 38158.816, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 20.158 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7577.449, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.922, - "Status": "Ok", - "TotalDuration": 38158.816, - "TotalOverhead": 7620.931, - "ValidationOverhead": 1.402 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 24 - }, - "Duration": 170984.672, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 78084.624 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7646.518, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.757, - "Status": "Ok", - "TotalDuration": 170984.672, - "TotalOverhead": 85788.091, - "ValidationOverhead": 2.192 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6690.656, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 76390.06 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7908.389, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.199, - "Status": "Ok", - "TotalDuration": 6690.656, - "TotalOverhead": 84353.698, - "ValidationOverhead": 2.05 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 38153.792, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 17.903 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7652.798, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 17.192, - "Status": "Ok", - "TotalDuration": 38153.792, - "TotalOverhead": 7689.03, - "ValidationOverhead": 1.137 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6644.736, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6759.802, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097298 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068507 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 69351822 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 270532608 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9830801215106161 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 86.04978972186366 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19344130048 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1793064960 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2181038080 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 731906048 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 756350976 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 47.20462900342178 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 80.08482989021313 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.95667619790312 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7638.472, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3670.59, - "Status": "Ok", - "TotalDuration": 6644.736, - "TotalOverhead": 18070.31, - "ValidationOverhead": 1.446 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6538.304, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 74658.822 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6964.332, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.879, - "Status": "Ok", - "TotalDuration": 6538.304, - "TotalOverhead": 81660.103, - "ValidationOverhead": 2.07 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6533.248, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.768 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7587.447, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.701, - "Status": "Ok", - "TotalDuration": 6533.248, - "TotalOverhead": 7624.102, - "ValidationOverhead": 1.186 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 22 - }, - "Duration": 172559.232, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 81329.922 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7618.936, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.715, - "Status": "Ok", - "TotalDuration": 172559.232, - "TotalOverhead": 89005.632, - "ValidationOverhead": 2.059 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6531.616, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.736 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7555.231, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 26.335, - "Status": "Ok", - "TotalDuration": 6531.616, - "TotalOverhead": 7585.476, - "ValidationOverhead": 1.174 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 34555.296, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 71223.489 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7576.321, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.534, - "Status": "Ok", - "TotalDuration": 34555.296, - "TotalOverhead": 78856.52, - "ValidationOverhead": 2.176 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 36094.88, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.565 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 9976.218, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 16.722, - "Status": "Ok", - "TotalDuration": 36094.88, - "TotalOverhead": 9996.618, - "ValidationOverhead": 1.113 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 40 - }, - "Duration": 6691.36, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 6578.761, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097298 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068509 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 35797394 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.734190590308767 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 75.04113254819926 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18270388224 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 2837446656 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 268435456 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 1107296256 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2991587328 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 796327936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 38.042946072545014 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 90.85264135995907 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.98354044934574 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8176.685, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3640.711, - "Status": "Ok", - "TotalDuration": 6691.36, - "TotalOverhead": 18397.619, - "ValidationOverhead": 1.462 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 31912.0, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 71953.881 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6326.723, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.629, - "Status": "Ok", - "TotalDuration": 31912.0, - "TotalOverhead": 78318.358, - "ValidationOverhead": 2.125 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 33743.424, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 20.487 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7663.508, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.627, - "Status": "Ok", - "TotalDuration": 33743.424, - "TotalOverhead": 7717.817, - "ValidationOverhead": 1.195 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 35249.12, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.297 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7755.717, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.56, - "Status": "Ok", - "TotalDuration": 35249.12, - "TotalOverhead": 7780.976, - "ValidationOverhead": 1.402 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 104987.328, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 74317.843 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7804.201, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.035, - "Status": "Ok", - "TotalDuration": 104987.328, - "TotalOverhead": 82179.216, - "ValidationOverhead": 2.137 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 104685.152, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 20.419 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7626.994, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 24.338, - "Status": "Ok", - "TotalDuration": 104685.152, - "TotalOverhead": 7672.887, - "ValidationOverhead": 1.136 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22439.456, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 72483.883 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7661.538, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.004, - "Status": "Ok", - "TotalDuration": 22439.456, - "TotalOverhead": 80182.566, - "ValidationOverhead": 2.141 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 31875.296, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 8168.878, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2838247 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 178781274 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 608903086 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065815 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 93.7956204379562 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9886734958876823 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.6104130905692 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 19501416448 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4299161600 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 10791944192 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2174746624 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1787559936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 11.248842053146944 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 37.27273027963345 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.04311482622086 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7651.444, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3614.745, - "Status": "Ok", - "TotalDuration": 31875.296, - "TotalOverhead": 19436.519, - "ValidationOverhead": 1.452 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 32165.344, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 73649.152 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6272.828, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.53, - "Status": "Ok", - "TotalDuration": 32165.344, - "TotalOverhead": 79959.547, - "ValidationOverhead": 2.037 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 32999.97, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.597 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7638.053, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.023, - "Status": "Ok", - "TotalDuration": 32999.97, - "TotalOverhead": 7674.85, - "ValidationOverhead": 1.177 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 33901.792, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 18.083 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7731.011, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.721, - "Status": "Ok", - "TotalDuration": 33901.792, - "TotalOverhead": 7771.123, - "ValidationOverhead": 1.308 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 34018.464, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.229 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7773.584, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.015, - "Status": "Ok", - "TotalDuration": 34018.464, - "TotalOverhead": 7797.007, - "ValidationOverhead": 1.179 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 34252.896, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.331 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7792.048, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 19.306, - "Status": "Ok", - "TotalDuration": 34252.896, - "TotalOverhead": 7814.908, - "ValidationOverhead": 1.223 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 34271.168, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 17.729 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7788.061, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 12.27, - "Status": "Ok", - "TotalDuration": 34271.168, - "TotalOverhead": 7819.301, - "ValidationOverhead": 1.241 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 32961.566, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 4899.685, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2761503 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 177924300 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 608903304 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065227 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 93.7956204379562 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9913832202455898 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.31966054120653 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 19501416448 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4299161600 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 10791944192 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2174746624 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1787559936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 11.462440195827059 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 38.09513845829821 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.04311482622086 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7837.64, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3721.662, - "Status": "Ok", - "TotalDuration": 32961.566, - "TotalOverhead": 16460.351, - "ValidationOverhead": 1.364 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 34270.336, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 70020.516 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6474.472, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.187, - "Status": "Ok", - "TotalDuration": 34270.336, - "TotalOverhead": 76532.227, - "ValidationOverhead": 2.052 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 34281.824, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.5 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7772.477, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.345, - "Status": "Ok", - "TotalDuration": 34281.824, - "TotalOverhead": 7808.462, - "ValidationOverhead": 1.14 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 151925.984, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 80998.762 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7833.508, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.117, - "Status": "Ok", - "TotalDuration": 151925.984, - "TotalOverhead": 88889.565, - "ValidationOverhead": 2.178 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 29003.616, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 72840.168 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7699.777, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.717, - "Status": "Ok", - "TotalDuration": 29003.616, - "TotalOverhead": 80595.761, - "ValidationOverhead": 2.099 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 15 - }, - "Duration": 31951.744, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.786 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8623.352, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.27, - "Status": "Ok", - "TotalDuration": 31951.744, - "TotalOverhead": 8652.593, - "ValidationOverhead": 1.185 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 15 - }, - "Duration": 103161.216, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 74569.723 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7702.246, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.705, - "Status": "Ok", - "TotalDuration": 103161.216, - "TotalOverhead": 82309.753, - "ValidationOverhead": 2.079 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 29017.536, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 6998.658, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2776907 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 174176553 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 608904829 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065227 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 93.7956204379562 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.989454893897253 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.3627408584375 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 9837740032 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 4349493248 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2174746624 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1183580160 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 12.291677617650691 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 31.467099114773742 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.55481727574751 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7804.355, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3784.131, - "Status": "Ok", - "TotalDuration": 29017.536, - "TotalOverhead": 18588.568, - "ValidationOverhead": 1.424 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 31828.992, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 72531.64 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6463.444, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.05, - "Status": "Ok", - "TotalDuration": 31828.992, - "TotalOverhead": 79032.116, - "ValidationOverhead": 1.982 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 31852.544, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.739 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7759.975, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.013, - "Status": "Ok", - "TotalDuration": 31852.544, - "TotalOverhead": 7795.874, - "ValidationOverhead": 1.147 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 15 - }, - "Duration": 31782.464, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 71223.252 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7737.701, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.624, - "Status": "Ok", - "TotalDuration": 31782.464, - "TotalOverhead": 79018.749, - "ValidationOverhead": 2.172 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 15 - }, - "Duration": 31803.456, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.878 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7911.326, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.121, - "Status": "Ok", - "TotalDuration": 31803.456, - "TotalOverhead": 7940.654, - "ValidationOverhead": 1.329 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 32047.744, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.503 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7817.875, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 22.077, - "Status": "Ok", - "TotalDuration": 32047.744, - "TotalOverhead": 7843.878, - "ValidationOverhead": 1.423 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 47836.192, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 72461.275 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7829.967, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.971, - "Status": "Ok", - "TotalDuration": 47836.192, - "TotalOverhead": 80328.246, - "ValidationOverhead": 2.033 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 15 - }, - "Duration": 30140.704, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 6701.943, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2758110 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 168384562 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 558426339 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065813 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.09160305343511 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.99314173873538 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.29069831095215 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 15787360256 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4299161600 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 9181331456 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1111490560 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1587937280 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 11.81497029748913 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 35.333257387685556 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.92282294676022 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8648.522, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3541.11, - "Status": "Ok", - "TotalDuration": 30140.704, - "TotalOverhead": 18893.019, - "ValidationOverhead": 1.444 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 140325.376, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 79094.134 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6377.118, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.309, - "Status": "Ok", - "TotalDuration": 140325.376, - "TotalOverhead": 85508.716, - "ValidationOverhead": 2.155 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 140339.072, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 18.116 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7661.493, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.726, - "Status": "Ok", - "TotalDuration": 140339.072, - "TotalOverhead": 7712.619, - "ValidationOverhead": 1.284 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 145778.752, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 20.125 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7625.237, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.134, - "Status": "Ok", - "TotalDuration": 145778.752, - "TotalOverhead": 7667.968, - "ValidationOverhead": 1.472 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 42544.64, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 70405.338 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7660.136, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.138, - "Status": "Ok", - "TotalDuration": 42544.64, - "TotalOverhead": 78123.678, - "ValidationOverhead": 2.066 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 36374.656, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 70488.774 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7765.314, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.197, - "Status": "Ok", - "TotalDuration": 36374.656, - "TotalOverhead": 78311.29, - "ValidationOverhead": 2.005 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 43584.0, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.94 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 12628.128, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 16.693, - "Status": "Ok", - "TotalDuration": 43584.0, - "TotalOverhead": 12649.115, - "ValidationOverhead": 1.354 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 36097.024, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 5002.171, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2975533 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 22363801 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 676162328 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065512 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 88.62068965517241 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9966903482536473 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.80570671432056 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 22565355520 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 25983713280 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4303355904 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 12939427840 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 4349493248 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 2226520064 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 12.394768844187686 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 44.403983375551334 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.4635309354212 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7760.353, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3484.46, - "Status": "Ok", - "TotalDuration": 36097.024, - "TotalOverhead": 16248.408, - "ValidationOverhead": 1.424 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 32345.92, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 72004.585 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8642.605, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.474, - "Status": "Ok", - "TotalDuration": 32345.92, - "TotalOverhead": 80684.493, - "ValidationOverhead": 2.829 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 32803.776, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.732 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8320.871, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 47.616, - "Status": "Ok", - "TotalDuration": 32803.776, - "TotalOverhead": 8372.478, - "ValidationOverhead": 1.259 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 25 - }, - "Duration": 172255.232, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 79704.969 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7740.513, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.05, - "Status": "Ok", - "TotalDuration": 172255.232, - "TotalOverhead": 87502.01, - "ValidationOverhead": 2.478 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 25 - }, - "Duration": 172512.288, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.675 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7649.004, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.71, - "Status": "Ok", - "TotalDuration": 172512.288, - "TotalOverhead": 7678.589, - "ValidationOverhead": 1.2 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 31356.672, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 70667.342 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7649.869, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.052, - "Status": "Ok", - "TotalDuration": 31356.672, - "TotalOverhead": 78373.399, - "ValidationOverhead": 2.136 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 47739.328, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 71868.603 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7663.979, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.679, - "Status": "Ok", - "TotalDuration": 47739.328, - "TotalOverhead": 79570.272, - "ValidationOverhead": 2.011 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 33818.88, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 4516.773, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2763127 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 180350015 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 608906165 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065517 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 93.7956204379562 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9899651218254768 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.77104671178172 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 19501416448 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4299161600 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 10791944192 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2174746624 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1787559936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 11.48775015861574 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 38.00121224511938 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.04311482622086 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7732.032, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3617.471, - "Status": "Ok", - "TotalDuration": 33818.88, - "TotalOverhead": 15867.666, - "ValidationOverhead": 1.39 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 103601.952, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 74824.408 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6339.227, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.15, - "Status": "Ok", - "TotalDuration": 103601.952, - "TotalOverhead": 81200.473, - "ValidationOverhead": 2.688 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 103618.4, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 20.297 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7628.189, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.614, - "Status": "Ok", - "TotalDuration": 103618.4, - "TotalOverhead": 7681.307, - "ValidationOverhead": 1.207 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 103586.4, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.38 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7608.514, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.034, - "Status": "Ok", - "TotalDuration": 103586.4, - "TotalOverhead": 7633.353, - "ValidationOverhead": 1.425 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 103611.04, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.382 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7636.449, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 19.663, - "Status": "Ok", - "TotalDuration": 103611.04, - "TotalOverhead": 7659.824, - "ValidationOverhead": 1.33 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 103785.312, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.17 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7603.928, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 19.504, - "Status": "Ok", - "TotalDuration": 103785.312, - "TotalOverhead": 7626.896, - "ValidationOverhead": 1.294 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 103739.36, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.104 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7724.469, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 12.14, - "Status": "Ok", - "TotalDuration": 103739.36, - "TotalOverhead": 7741.471, - "ValidationOverhead": 2.758 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 22 - }, - "Duration": 103697.824, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 7901.936, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 118174112 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 482160994 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 551495866 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 675282944 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.84615384615384 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9808075385605213 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 98.90838002281653 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18538823680 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 4764729344 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 1075838976 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2470445056 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 564133888 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 865337344 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 3.167187205834785 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 6.549032288756077 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.01166313238413 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7748.164, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3392.767, - "Status": "Ok", - "TotalDuration": 103697.824, - "TotalOverhead": 19044.288, - "ValidationOverhead": 1.421 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 106005.408, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 73529.953 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6427.14, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.199, - "Status": "Ok", - "TotalDuration": 106005.408, - "TotalOverhead": 79994.27, - "ValidationOverhead": 1.978 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 105876.384, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.462 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7655.959, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.896, - "Status": "Ok", - "TotalDuration": 105876.384, - "TotalOverhead": 7692.576, - "ValidationOverhead": 1.259 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 25 - }, - "Duration": 172438.496, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 78471.938 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7665.306, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.21, - "Status": "Ok", - "TotalDuration": 172438.496, - "TotalOverhead": 86193.534, - "ValidationOverhead": 2.08 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 105829.792, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 3.304 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7667.392, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 23.839, - "Status": "Ok", - "TotalDuration": 105829.792, - "TotalOverhead": 7695.736, - "ValidationOverhead": 1.201 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 25 - }, - "Duration": 172217.056, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.503 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7610.46, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 22.388, - "Status": "Ok", - "TotalDuration": 172217.056, - "TotalOverhead": 7637.055, - "ValidationOverhead": 1.704 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 105869.728, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.439 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7637.793, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 13.8, - "Status": "Ok", - "TotalDuration": 105869.728, - "TotalOverhead": 7655.406, - "ValidationOverhead": 1.374 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 105955.584, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 6447.006, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 117387014 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 489575985 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 576662642 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 675282944 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 96.61654135338345 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9616711323612913 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 99.09360320480491 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18538823680 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 9817817088 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 2149580800 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 5423235072 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1087373312 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1165426688 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 3.104605992696794 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 7.233775786690732 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.26615306753641 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7715.483, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3329.396, - "Status": "Ok", - "TotalDuration": 105955.584, - "TotalOverhead": 17493.28, - "ValidationOverhead": 1.395 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22492.768, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 71925.228 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6377.945, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.035, - "Status": "Ok", - "TotalDuration": 22492.768, - "TotalOverhead": 78340.288, - "ValidationOverhead": 2.08 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22416.736, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.572 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7727.544, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.341, - "Status": "Ok", - "TotalDuration": 22416.736, - "TotalOverhead": 7763.546, - "ValidationOverhead": 1.089 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22402.592, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.262 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7664.732, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.414, - "Status": "Ok", - "TotalDuration": 22402.592, - "TotalOverhead": 7689.695, - "ValidationOverhead": 1.287 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22406.336, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.209 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7621.038, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 19.724, - "Status": "Ok", - "TotalDuration": 22406.336, - "TotalOverhead": 7644.483, - "ValidationOverhead": 1.512 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22380.256, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 2.269 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7596.648, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.362, - "Status": "Ok", - "TotalDuration": 22380.256, - "TotalOverhead": 7620.727, - "ValidationOverhead": 1.448 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 32440.414, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 70045.874 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7636.15, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.915, - "Status": "Ok", - "TotalDuration": 32440.414, - "TotalOverhead": 77719.274, - "ValidationOverhead": 2.335 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 22356.8, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 8127.413, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388781 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064489 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 270969900 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1075838976 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.8192036099358513 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 91.12406144829744 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 25786580992 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 6769606656 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 545259520 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 8623489024 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 3900702720 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 25165824 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1427898368 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 22.038113443695213 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 40.9735619764368 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.90820635212043 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7712.553, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3207.88, - "Status": "Ok", - "TotalDuration": 22356.8, - "TotalOverhead": 19049.271, - "ValidationOverhead": 1.425 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 25 - }, - "Duration": 172460.672, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 82871.841 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6399.463, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.555, - "Status": "Ok", - "TotalDuration": 172460.672, - "TotalOverhead": 89309.072, - "ValidationOverhead": 2.213 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 25 - }, - "Duration": 172252.672, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.67 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7731.984, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.114, - "Status": "Ok", - "TotalDuration": 172252.672, - "TotalOverhead": 7768.907, - "ValidationOverhead": 1.139 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6553.6, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 77204.473 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7650.554, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 58.221, - "Status": "Ok", - "TotalDuration": 6553.6, - "TotalOverhead": 84915.377, - "ValidationOverhead": 2.129 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 146600.704, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 78913.935 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7707.898, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.034, - "Status": "Ok", - "TotalDuration": 146600.704, - "TotalOverhead": 86677.851, - "ValidationOverhead": 1.984 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 22 - }, - "Duration": 172345.696, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 79819.304 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7660.047, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.171, - "Status": "Ok", - "TotalDuration": 172345.696, - "TotalOverhead": 87534.591, - "ValidationOverhead": 2.069 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171408.928, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 79872.757 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7694.706, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.121, - "Status": "Ok", - "TotalDuration": 171408.928, - "TotalOverhead": 87605.395, - "ValidationOverhead": 2.811 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 6543.008, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 7827.452, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2389836 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064435 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 69498614 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 270532608 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9779823472808131 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 85.5753801035266 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19344130048 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1793064960 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 136314880 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2181038080 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 731906048 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 756350976 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 47.571600552001314 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 81.15535737486381 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.95667619790312 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7718.951, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3730.999, - "Status": "Ok", - "TotalDuration": 6543.008, - "TotalOverhead": 19278.838, - "ValidationOverhead": 1.436 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171912.576, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 80372.426 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6507.565, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.957, - "Status": "Ok", - "TotalDuration": 171912.576, - "TotalOverhead": 86917.029, - "ValidationOverhead": 2.081 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171797.536, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.523 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7676.33, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.441, - "Status": "Ok", - "TotalDuration": 171797.536, - "TotalOverhead": 7713.626, - "ValidationOverhead": 1.332 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 32184.834, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 72289.677 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7869.557, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 68.574, - "Status": "Ok", - "TotalDuration": 32184.834, - "TotalOverhead": 80229.8, - "ValidationOverhead": 1.992 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 15 - }, - "Duration": 106089.792, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 74798.782 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 9270.299, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.286, - "Status": "Ok", - "TotalDuration": 106089.792, - "TotalOverhead": 84127.51, - "ValidationOverhead": 2.143 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 33871.776, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.874 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7705.688, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 24.405, - "Status": "Ok", - "TotalDuration": 33871.776, - "TotalOverhead": 7734.117, - "ValidationOverhead": 1.15 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171527.776, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 3.216 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7701.134, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 18.507, - "Status": "Ok", - "TotalDuration": 171527.776, - "TotalOverhead": 7724.414, - "ValidationOverhead": 1.557 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 20 - }, - "Duration": 32330.974, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 6548.772, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2838055 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 175282402 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 608904262 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065815 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 93.7956204379562 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9907693474254655 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.37772080114374 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 19501416448 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4299161600 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 10791944192 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2174746624 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1787559936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 11.186410122068061 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 37.15541423689685 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.04311482622086 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7767.94, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3728.06, - "Status": "Ok", - "TotalDuration": 32330.974, - "TotalOverhead": 18046.156, - "ValidationOverhead": 1.384 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 24 - }, - "Duration": 170669.408, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 78412.885 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6531.03, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.444, - "Status": "Ok", - "TotalDuration": 170669.408, - "TotalOverhead": 84980.144, - "ValidationOverhead": 2.785 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 24 - }, - "Duration": 170970.912, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.67 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7663.832, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.864, - "Status": "Ok", - "TotalDuration": 170970.912, - "TotalOverhead": 7699.657, - "ValidationOverhead": 1.291 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 37826.752, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 69000.038 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7631.683, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.725, - "Status": "Ok", - "TotalDuration": 37826.752, - "TotalOverhead": 76690.414, - "ValidationOverhead": 1.968 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 30603.2, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 70953.322 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7706.921, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.572, - "Status": "Ok", - "TotalDuration": 30603.2, - "TotalOverhead": 78716.911, - "ValidationOverhead": 2.096 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 39846.4, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.675 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7757.974, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.228, - "Status": "Ok", - "TotalDuration": 39846.4, - "TotalOverhead": 7787.018, - "ValidationOverhead": 1.141 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 31169.888, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 71505.891 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7734.607, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.598, - "Status": "Ok", - "TotalDuration": 31169.888, - "TotalOverhead": 79277.114, - "ValidationOverhead": 2.018 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 30949.664, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6827.728, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2918803 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 186674700 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 608903614 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065530 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 93.7956204379562 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9873489114608042 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.75343790466337 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 13058965504 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 2151677952 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 6496976896 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2174746624 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1384906752 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 11.78955545982899 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 31.05428463511572 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.7649063032368 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7682.592, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3374.18, - "Status": "Ok", - "TotalDuration": 30949.664, - "TotalOverhead": 17885.925, - "ValidationOverhead": 1.425 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 32629.216, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 73168.724 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6301.522, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.696, - "Status": "Ok", - "TotalDuration": 32629.216, - "TotalOverhead": 79508.244, - "ValidationOverhead": 2.302 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 33283.87, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.729 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7624.609, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.584, - "Status": "Ok", - "TotalDuration": 33283.87, - "TotalOverhead": 7661.168, - "ValidationOverhead": 1.246 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 19 - }, - "Duration": 42835.968, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 72151.504 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7651.126, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.297, - "Status": "Ok", - "TotalDuration": 42835.968, - "TotalOverhead": 79860.263, - "ValidationOverhead": 2.336 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 18 - }, - "Duration": 172390.144, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 83103.527 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7711.283, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.539, - "Status": "Ok", - "TotalDuration": 172390.144, - "TotalOverhead": 90870.6, - "ValidationOverhead": 2.251 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 18 - }, - "Duration": 172721.856, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.865 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7593.154, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.329, - "Status": "Ok", - "TotalDuration": 172721.856, - "TotalOverhead": 7622.611, - "ValidationOverhead": 1.263 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 32589.92, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.829 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7556.594, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.175, - "Status": "Ok", - "TotalDuration": 32589.92, - "TotalOverhead": 7575.068, - "ValidationOverhead": 1.47 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 19 - }, - "Duration": 34422.016, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 5999.067, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2681535 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 19545188 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 676013669 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065229 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 88.62068965517241 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9977715776415544 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.51948785656633 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 22565355520 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 19541262336 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 2155872256 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 8644460544 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 4349493248 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1823866880 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 13.003119794142725 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 39.29275676944098 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.12432626661875 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7729.882, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3797.754, - "Status": "Ok", - "TotalDuration": 34422.016, - "TotalOverhead": 17528.066, - "ValidationOverhead": 1.363 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 149901.856, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 79251.883 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6501.001, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.476, - "Status": "Ok", - "TotalDuration": 149901.856, - "TotalOverhead": 85790.45, - "ValidationOverhead": 2.09 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 141711.168, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 20.107 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7660.262, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.51, - "Status": "Ok", - "TotalDuration": 141711.168, - "TotalOverhead": 7715.101, - "ValidationOverhead": 1.222 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 105326.528, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 74748.093 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7660.261, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.753, - "Status": "Ok", - "TotalDuration": 105326.528, - "TotalOverhead": 82464.295, - "ValidationOverhead": 2.188 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 25 - }, - "Duration": 172395.744, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 78692.073 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7692.545, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.415, - "Status": "Ok", - "TotalDuration": 172395.744, - "TotalOverhead": 86441.962, - "ValidationOverhead": 1.929 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 105931.776, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 73294.328 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7684.105, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.4, - "Status": "Ok", - "TotalDuration": 105931.776, - "TotalOverhead": 81035.028, - "ValidationOverhead": 2.195 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 144106.432, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.734 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7648.983, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 16.869, - "Status": "Ok", - "TotalDuration": 144106.432, - "TotalOverhead": 7669.762, - "ValidationOverhead": 1.176 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 105434.848, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 6585.253, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 122485025 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 487606811 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 576515466 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 675282944 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 96.61654135338345 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9803538281045738 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 98.81158193653226 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18538823680 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 6596591616 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 1075838976 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 3275751424 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1087373312 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 964100096 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 3.1164282896645186 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 6.998119292828045 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.11290870776969 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7688.646, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3638.728, - "Status": "Ok", - "TotalDuration": 105434.848, - "TotalOverhead": 17914.071, - "ValidationOverhead": 1.444 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5487.808, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 78929.166 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6367.364, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.579, - "Status": "Ok", - "TotalDuration": 5487.808, - "TotalOverhead": 85333.171, - "ValidationOverhead": 2.062 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5482.08, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.499 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7600.607, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.266, - "Status": "Ok", - "TotalDuration": 5482.08, - "TotalOverhead": 7638.518, - "ValidationOverhead": 1.146 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5487.776, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.215 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7555.586, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.306, - "Status": "Ok", - "TotalDuration": 5487.776, - "TotalOverhead": 7580.408, - "ValidationOverhead": 1.301 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 8, - "RegistersCount": 16 - }, - "Duration": 37905.472, - "GlobalSize": { - "X": 8, - "Y": 128, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 2, - "Z": 1 - }, - "Overhead": 70056.244 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7642.772, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.592, - "Status": "Ok", - "TotalDuration": 37905.472, - "TotalOverhead": 77756.585, - "ValidationOverhead": 1.977 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 104346.304, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 74156.192 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7696.317, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.049, - "Status": "Ok", - "TotalDuration": 104346.304, - "TotalOverhead": 81908.64, - "ValidationOverhead": 2.082 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 104240.608, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.776 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7590.629, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 15.832, - "Status": "Ok", - "TotalDuration": 104240.608, - "TotalOverhead": 7610.411, - "ValidationOverhead": 1.174 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 56 - }, - "Duration": 5491.36, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6734.091, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2097322 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068507 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 19020222 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 69206016 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.5516847347242712 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 83.67834743013849 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17733517312 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 1485832192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 134217728 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 570425344 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1504182272 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 669745152 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 48.55692896894215 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 87.43276644977362 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.99021478545917 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7725.338, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3517.169, - "Status": "Ok", - "TotalDuration": 5491.36, - "TotalOverhead": 17977.943, - "ValidationOverhead": 1.345 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 15 - }, - "Duration": 104647.648, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 74701.468 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6331.613, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.904, - "Status": "Ok", - "TotalDuration": 104647.648, - "TotalOverhead": 81069.942, - "ValidationOverhead": 1.957 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 15 - }, - "Duration": 104467.136, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.651 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7648.275, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.048, - "Status": "Ok", - "TotalDuration": 104467.136, - "TotalOverhead": 7684.221, - "ValidationOverhead": 1.247 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 170061.12, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 81101.732 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7632.584, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.412, - "Status": "Ok", - "TotalDuration": 170061.12, - "TotalOverhead": 88791.767, - "ValidationOverhead": 2.039 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 18 - }, - "Duration": 171867.808, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 79213.623 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7680.623, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 52.97, - "Status": "Ok", - "TotalDuration": 171867.808, - "TotalOverhead": 86949.152, - "ValidationOverhead": 1.936 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 19247.36, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 72446.053 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7669.821, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 71.218, - "Status": "Ok", - "TotalDuration": 19247.36, - "TotalOverhead": 80189.131, - "ValidationOverhead": 2.039 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 18 - }, - "Duration": 171428.736, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 20.492 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7613.807, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 17.482, - "Status": "Ok", - "TotalDuration": 171428.736, - "TotalOverhead": 7653.001, - "ValidationOverhead": 1.22 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 29 - }, - "Duration": 19243.424, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 128 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 7287.466, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388780 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068507 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 69643536 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097161 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 10 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 1075838976 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9950067758238837 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 94.82354573330976 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 25786580992 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 2508193792 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 545259520 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2181038080 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 687865856 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 25165824 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 993001472 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 26.55620361792088 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 37.398811287008 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.86800422386483 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7752.13, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3330.073, - "Status": "Ok", - "TotalDuration": 19243.424, - "TotalOverhead": 18371.143, - "ValidationOverhead": 1.474 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 30609.408, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 72722.48 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6393.74, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.248, - "Status": "Ok", - "TotalDuration": 30609.408, - "TotalOverhead": 79153.485, - "ValidationOverhead": 2.017 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 32519.65, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.625 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7769.666, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.708, - "Status": "Ok", - "TotalDuration": 32519.65, - "TotalOverhead": 7807.09, - "ValidationOverhead": 1.091 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 19 - }, - "Duration": 33291.198, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 17.754 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7733.132, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.428, - "Status": "Ok", - "TotalDuration": 33291.198, - "TotalOverhead": 7773.598, - "ValidationOverhead": 1.284 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171472.352, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 79787.577 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7834.558, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.448, - "Status": "Ok", - "TotalDuration": 171472.352, - "TotalOverhead": 87678.53, - "ValidationOverhead": 1.947 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 28304.224, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 71201.742 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7660.979, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.333, - "Status": "Ok", - "TotalDuration": 28304.224, - "TotalOverhead": 78921.058, - "ValidationOverhead": 2.004 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 28394.08, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.913 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7661.034, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 15.456, - "Status": "Ok", - "TotalDuration": 28394.08, - "TotalOverhead": 7680.497, - "ValidationOverhead": 1.094 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 18 - }, - "Duration": 30078.368, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 8256.203, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2777655 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 178434612 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 558426068 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065585 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.09160305343511 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9887861486610301 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 86.830114417149 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 9344909312 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 2151677952 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 4886364160 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1111490560 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1185284096 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 11.429536183189352 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 31.46175754639154 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.55689483578459 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7708.123, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3486.959, - "Status": "Ok", - "TotalDuration": 30078.368, - "TotalOverhead": 19452.734, - "ValidationOverhead": 1.449 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 18 - }, - "Duration": 29805.952, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 71346.024 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6429.566, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.035, - "Status": "Ok", - "TotalDuration": 29805.952, - "TotalOverhead": 77813.643, - "ValidationOverhead": 2.018 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 16, - "RegistersCount": 18 - }, - "Duration": 29010.24, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.634 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7761.984, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.873, - "Status": "Ok", - "TotalDuration": 29010.24, - "TotalOverhead": 7798.657, - "ValidationOverhead": 1.166 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12390.624, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 74543.557 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7712.742, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 57.063, - "Status": "Ok", - "TotalDuration": 12390.624, - "TotalOverhead": 82315.271, - "ValidationOverhead": 1.909 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171276.064, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 80756.86 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7813.72, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.248, - "Status": "Ok", - "TotalDuration": 171276.064, - "TotalOverhead": 88626.916, - "ValidationOverhead": 2.088 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 24 - }, - "Duration": 171851.584, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 78271.564 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7673.903, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.175, - "Status": "Ok", - "TotalDuration": 171851.584, - "TotalOverhead": 86001.764, - "ValidationOverhead": 2.122 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 86149.024, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 74695.583 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7665.683, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.242, - "Status": "Ok", - "TotalDuration": 86149.024, - "TotalOverhead": 82398.531, - "ValidationOverhead": 2.023 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12267.84, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 6598.011, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388996 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2064557 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 136606722 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9556915650221026 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 93.44562342893579 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 21491613696 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 3451912192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 272629760 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 4328521728 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1698693120 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 977403904 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 31.714506274721384 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 49.92567533060469 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.93294890706719 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7825.687, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3372.284, - "Status": "Ok", - "TotalDuration": 12267.84, - "TotalOverhead": 17797.446, - "ValidationOverhead": 1.464 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106305.536, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 74399.949 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6379.749, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.051, - "Status": "Ok", - "TotalDuration": 106305.536, - "TotalOverhead": 80816.954, - "ValidationOverhead": 2.205 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106036.128, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.736 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7707.896, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.669, - "Status": "Ok", - "TotalDuration": 106036.128, - "TotalOverhead": 7744.536, - "ValidationOverhead": 1.235 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106180.384, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 20.048 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7635.164, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.998, - "Status": "Ok", - "TotalDuration": 106180.384, - "TotalOverhead": 7677.569, - "ValidationOverhead": 1.359 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 169256.352, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 81242.557 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7659.129, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.702, - "Status": "Ok", - "TotalDuration": 169256.352, - "TotalOverhead": 88958.463, - "ValidationOverhead": 2.075 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 105841.696, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 73442.583 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7822.28, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.144, - "Status": "Ok", - "TotalDuration": 105841.696, - "TotalOverhead": 81322.049, - "ValidationOverhead": 2.042 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 169147.904, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.934 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7645.716, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 16.476, - "Status": "Ok", - "TotalDuration": 169147.904, - "TotalOverhead": 7666.381, - "ValidationOverhead": 1.255 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 105827.84, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 6768.986, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 117237997 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 489005407 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 576516506 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 675282944 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 96.61654135338345 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9646192252370646 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 98.80507473485639 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18538823680 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 9817817088 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 2149580800 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 5423235072 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1087373312 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1165426688 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 3.0983339942191095 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 7.240289807275857 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.26615306753641 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7733.851, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3313.135, - "Status": "Ok", - "TotalDuration": 105827.84, - "TotalOverhead": 17817.381, - "ValidationOverhead": 1.409 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 90904.832, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 76400.252 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6368.617, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.891, - "Status": "Ok", - "TotalDuration": 90904.832, - "TotalOverhead": 82805.857, - "ValidationOverhead": 2.097 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 91400.0, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.578 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7691.643, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.074, - "Status": "Ok", - "TotalDuration": 91400.0, - "TotalOverhead": 7727.462, - "ValidationOverhead": 1.167 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 168951.616, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 81490.718 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7684.263, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.932, - "Status": "Ok", - "TotalDuration": 168951.616, - "TotalOverhead": 89230.865, - "ValidationOverhead": 1.952 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 90851.488, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.642 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7665.959, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.657, - "Status": "Ok", - "TotalDuration": 90851.488, - "TotalOverhead": 7695.396, - "ValidationOverhead": 1.138 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 19 - }, - "Duration": 107003.072, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 73838.966 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7697.853, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.518, - "Status": "Ok", - "TotalDuration": 107003.072, - "TotalOverhead": 81593.827, - "ValidationOverhead": 2.49 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 89837.44, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 3.03 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7651.24, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 15.871, - "Status": "Ok", - "TotalDuration": 89837.44, - "TotalOverhead": 7671.338, - "ValidationOverhead": 1.197 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 31 - }, - "Duration": 91591.488, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 6440.065, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 87299030 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 434575322 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 551204856 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 675282944 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.84615384615384 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.943704677778345 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 98.54927304203855 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18538823680 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 3106930688 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2470445056 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 550502400 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 796327936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 3.6107372480182214 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 6.815195461701776 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.92601431980907 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7997.441, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3116.289, - "Status": "Ok", - "TotalDuration": 91591.488, - "TotalOverhead": 17555.339, - "ValidationOverhead": 1.544 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 150669.152, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 79910.733 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6270.478, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.502, - "Status": "Ok", - "TotalDuration": 150669.152, - "TotalOverhead": 86218.783, - "ValidationOverhead": 2.07 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 145264.256, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.656 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7613.159, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.19, - "Status": "Ok", - "TotalDuration": 145264.256, - "TotalOverhead": 7650.262, - "ValidationOverhead": 1.257 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 145334.4, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.743 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7687.654, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.6, - "Status": "Ok", - "TotalDuration": 145334.4, - "TotalOverhead": 7717.586, - "ValidationOverhead": 1.589 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 146525.824, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.332 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7652.709, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 22.35, - "Status": "Ok", - "TotalDuration": 146525.824, - "TotalOverhead": 7678.788, - "ValidationOverhead": 1.397 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 144554.336, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.171 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7663.174, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.557, - "Status": "Ok", - "TotalDuration": 144554.336, - "TotalOverhead": 7687.181, - "ValidationOverhead": 1.279 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 143570.72, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.135 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7611.268, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 13.345, - "Status": "Ok", - "TotalDuration": 143570.72, - "TotalOverhead": 7628.031, - "ValidationOverhead": 1.283 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 144504.608, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 6675.741, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 357816425 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 416847207 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 560322158 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 608174080 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.09160305343511 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.7954970052416022 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 98.88941810899317 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17867735040 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 14639693824 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4296015872 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 9181331456 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 543686656 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1458339840 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 2.188207290785655 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 6.476076174460234 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.70677451971689 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7738.079, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3356.344, - "Status": "Ok", - "TotalDuration": 144504.608, - "TotalOverhead": 17771.71, - "ValidationOverhead": 1.546 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 139888.192, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 80840.479 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6431.953, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.726, - "Status": "Ok", - "TotalDuration": 139888.192, - "TotalOverhead": 87311.838, - "ValidationOverhead": 2.68 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 142882.592, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.749 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7672.554, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.027, - "Status": "Ok", - "TotalDuration": 142882.592, - "TotalOverhead": 7708.583, - "ValidationOverhead": 1.253 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 142657.28, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.369 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7630.128, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 22.4, - "Status": "Ok", - "TotalDuration": 142657.28, - "TotalOverhead": 7656.288, - "ValidationOverhead": 1.391 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 142848.608, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.191 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7792.58, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.288, - "Status": "Ok", - "TotalDuration": 142848.608, - "TotalOverhead": 7816.503, - "ValidationOverhead": 1.444 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 141398.176, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 17.487 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7992.194, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.933, - "Status": "Ok", - "TotalDuration": 141398.176, - "TotalOverhead": 8044.568, - "ValidationOverhead": 1.954 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 143411.04, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.373 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7738.159, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.538, - "Status": "Ok", - "TotalDuration": 143411.04, - "TotalOverhead": 7756.62, - "ValidationOverhead": 1.55 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 133228.32, - "GlobalSize": { - "X": 8, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 4, - "Z": 1 - }, - "Overhead": 21759.188, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 362742538 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 419281892 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 547885086 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 608174080 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 99.22779922779922 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.801199035648971 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 99.64905755064056 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17867735040 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 13748928512 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4296015872 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 8778678272 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 290455552 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1410007040 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 2.1960783248461224 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 6.255669309421458 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.69672321636068 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7805.549, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3353.251, - "Status": "Ok", - "TotalDuration": 133228.32, - "TotalOverhead": 32919.414, - "ValidationOverhead": 1.426 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 105403.872, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 73775.501 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6368.448, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.855, - "Status": "Ok", - "TotalDuration": 105403.872, - "TotalOverhead": 80179.896, - "ValidationOverhead": 2.092 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 105491.84, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.743 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7685.652, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.436, - "Status": "Ok", - "TotalDuration": 105491.84, - "TotalOverhead": 7721.029, - "ValidationOverhead": 1.198 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 105437.344, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 19.904 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7648.825, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.578, - "Status": "Ok", - "TotalDuration": 105437.344, - "TotalOverhead": 7691.525, - "ValidationOverhead": 1.218 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 105381.856, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.438 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7612.908, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.543, - "Status": "Ok", - "TotalDuration": 105381.856, - "TotalOverhead": 7637.037, - "ValidationOverhead": 1.148 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 105443.808, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.417 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7575.612, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.032, - "Status": "Ok", - "TotalDuration": 105443.808, - "TotalOverhead": 7599.282, - "ValidationOverhead": 1.221 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 105434.432, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.27 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7595.968, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 13.205, - "Status": "Ok", - "TotalDuration": 105434.432, - "TotalOverhead": 7612.515, - "ValidationOverhead": 1.072 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 25 - }, - "Duration": 105397.12, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6856.432, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 122898469 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 488031698 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 576516130 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 675282944 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 96.61654135338345 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9809459984262971 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 98.89271692708735 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18538823680 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 6596591616 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 1075838976 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 3275751424 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1087373312 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 964100096 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 3.115732507568845 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 6.990814313147664 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.11290870776969 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7630.946, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3139.757, - "Status": "Ok", - "TotalDuration": 105397.12, - "TotalOverhead": 17628.619, - "ValidationOverhead": 1.484 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 44444.992, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 73133.623 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6275.11, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.341, - "Status": "Ok", - "TotalDuration": 44444.992, - "TotalOverhead": 79447.168, - "ValidationOverhead": 2.094 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 44543.04, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.635 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7600.029, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.798, - "Status": "Ok", - "TotalDuration": 44543.04, - "TotalOverhead": 7635.653, - "ValidationOverhead": 1.191 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12445.344, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 75022.335 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8167.505, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 54.131, - "Status": "Ok", - "TotalDuration": 12445.344, - "TotalOverhead": 83246.003, - "ValidationOverhead": 2.032 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12332.0, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.645 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7569.712, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 24.93, - "Status": "Ok", - "TotalDuration": 12332.0, - "TotalOverhead": 7598.447, - "ValidationOverhead": 1.16 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 44547.136, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 18.047 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7572.32, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.997, - "Status": "Ok", - "TotalDuration": 44547.136, - "TotalOverhead": 7628.697, - "ValidationOverhead": 1.333 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 44568.576, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 256 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.285 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8097.416, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 15.614, - "Status": "Ok", - "TotalDuration": 44568.576, - "TotalOverhead": 8116.815, - "ValidationOverhead": 1.5 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 0, - "RegistersCount": 32 - }, - "Duration": 12444.448, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 64 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6350.343, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2388781 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 2068511 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 136606426 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 2097163 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9531992051042993 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 92.93356556617606 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 21491613696 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 3451912192 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 272629760 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 4328521728 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1698693120 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 12582912 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 977403904 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 32.349880857116275 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 4 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 51.20639312744434 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.93294890706719 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7723.063, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3267.571, - "Status": "Ok", - "TotalDuration": 12444.448, - "TotalOverhead": 17342.373, - "ValidationOverhead": 1.396 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 27565.344, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 71877.621 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6433.656, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.717, - "Status": "Ok", - "TotalDuration": 27565.344, - "TotalOverhead": 78348.953, - "ValidationOverhead": 1.959 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 28390.912, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.864 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 10477.763, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.495, - "Status": "Ok", - "TotalDuration": 28390.912, - "TotalOverhead": 10514.462, - "ValidationOverhead": 1.34 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 29413.44, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 19.596 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7745.099, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.962, - "Status": "Ok", - "TotalDuration": 29413.44, - "TotalOverhead": 7788.067, - "ValidationOverhead": 1.41 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 15 - }, - "Duration": 30666.208, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 72129.019 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7751.3, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.824, - "Status": "Ok", - "TotalDuration": 30666.208, - "TotalOverhead": 79938.864, - "ValidationOverhead": 2.721 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 28417.76, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.705 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7689.673, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 26.979, - "Status": "Ok", - "TotalDuration": 28417.76, - "TotalOverhead": 7720.48, - "ValidationOverhead": 1.123 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 15 - }, - "Duration": 143416.064, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 80677.003 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 9381.273, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.016, - "Status": "Ok", - "TotalDuration": 143416.064, - "TotalOverhead": 90096.17, - "ValidationOverhead": 1.878 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 27569.472, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 6944.716, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2478721 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 164262336 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 558280618 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065813 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 6 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.09160305343511 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9865421599629248 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.14429906274866 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 6123683840 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2738880512 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1111490560 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 983957504 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 12.938962480425642 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 28.872363880328578 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.26162248568004 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7831.969, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3350.368, - "Status": "Ok", - "TotalDuration": 27569.472, - "TotalOverhead": 18128.428, - "ValidationOverhead": 1.375 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 168335.648, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 81732.229 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6496.295, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.962, - "Status": "Ok", - "TotalDuration": 168335.648, - "TotalOverhead": 88264.435, - "ValidationOverhead": 1.949 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 168315.744, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.596 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7691.849, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 34.281, - "Status": "Ok", - "TotalDuration": 168315.744, - "TotalOverhead": 7729.855, - "ValidationOverhead": 1.129 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 168465.376, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 20.339 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7629.389, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 23.807, - "Status": "Ok", - "TotalDuration": 168465.376, - "TotalOverhead": 7675.002, - "ValidationOverhead": 1.467 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 168539.232, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.248 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7749.092, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.03, - "Status": "Ok", - "TotalDuration": 168539.232, - "TotalOverhead": 7773.721, - "ValidationOverhead": 1.351 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 168343.456, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.291 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7584.451, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 19.903, - "Status": "Ok", - "TotalDuration": 168343.456, - "TotalOverhead": 7607.905, - "ValidationOverhead": 1.26 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 168186.624, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.19 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7570.597, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 13.242, - "Status": "Ok", - "TotalDuration": 168186.624, - "TotalOverhead": 7587.392, - "ValidationOverhead": 1.363 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 168898.592, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6441.023, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 517104794 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 528843913 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 560905514 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 608174080 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.09160305343511 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.955421286702228 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 99.22738928446714 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17867735040 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 2560098304 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 269484032 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2738880512 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1348993024 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 778862592 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 1.8554970596546747 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 3.173206543984972 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.45096554335478 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7747.848, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3234.309, - "Status": "Ok", - "TotalDuration": 168898.592, - "TotalOverhead": 17424.498, - "ValidationOverhead": 1.318 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106212.928, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 74977.777 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6410.959, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.007, - "Status": "Ok", - "TotalDuration": 106212.928, - "TotalOverhead": 81426.533, - "ValidationOverhead": 1.79 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106364.416, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.687 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7644.728, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 31.112, - "Status": "Ok", - "TotalDuration": 106364.416, - "TotalOverhead": 7679.691, - "ValidationOverhead": 1.164 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106514.592, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.204 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7630.144, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.73, - "Status": "Ok", - "TotalDuration": 106514.592, - "TotalOverhead": 7655.435, - "ValidationOverhead": 1.357 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106294.4, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.179 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7648.403, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.099, - "Status": "Ok", - "TotalDuration": 106294.4, - "TotalOverhead": 7672.026, - "ValidationOverhead": 1.345 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106204.256, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.253 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7597.371, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.615, - "Status": "Ok", - "TotalDuration": 106204.256, - "TotalOverhead": 7621.474, - "ValidationOverhead": 1.235 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106183.584, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 2.242 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7611.426, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 12.207, - "Status": "Ok", - "TotalDuration": 106183.584, - "TotalOverhead": 7627.161, - "ValidationOverhead": 1.286 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 18 - }, - "Duration": 106244.64, - "GlobalSize": { - "X": 16, - "Y": 64, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 4, - "Z": 1 - }, - "Overhead": 6659.405, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 118514713 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 488583014 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 551256240 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065225 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 675282944 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.84615384615384 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9650321524570987 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 98.71485671673442 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 18538823680 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 7985954816 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 2149580800 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 4617928704 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 564133888 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 3145728 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1066663936 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 3.0864465374047216 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 7.237321118809015 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.19820594740723 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7940.956, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3032.601, - "Status": "Ok", - "TotalDuration": 106244.64, - "TotalOverhead": 17634.443, - "ValidationOverhead": 1.481 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 146917.152, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 82128.225 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6292.86, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 37.163, - "Status": "Ok", - "TotalDuration": 146917.152, - "TotalOverhead": 88460.353, - "ValidationOverhead": 2.105 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 145153.696, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 3.093 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7602.772, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.733, - "Status": "Ok", - "TotalDuration": 145153.696, - "TotalOverhead": 7640.85, - "ValidationOverhead": 1.252 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 18 - }, - "Duration": 172357.408, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 82773.319 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7589.811, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.314, - "Status": "Ok", - "TotalDuration": 172357.408, - "TotalOverhead": 90420.962, - "ValidationOverhead": 2.518 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 22 - }, - "Duration": 172501.856, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 83142.118 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7641.304, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 56.36, - "Status": "Ok", - "TotalDuration": 172501.856, - "TotalOverhead": 90841.953, - "ValidationOverhead": 2.171 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 142892.384, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 3.241 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7551.349, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.264, - "Status": "Ok", - "TotalDuration": 142892.384, - "TotalOverhead": 7581.134, - "ValidationOverhead": 1.28 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 22 - }, - "Duration": 172497.024, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.595 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7545.578, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 13.89, - "Status": "Ok", - "TotalDuration": 172497.024, - "TotalOverhead": 7563.476, - "ValidationOverhead": 1.413 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 20 - }, - "Duration": 145484.928, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 5737.212, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 373890141 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 426548665 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 560613104 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541226968 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 608174080 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.09160305343511 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077998256 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.7720823073656395 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 102.24143885652974 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 17867735040 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 14639693824 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 4296015872 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 9181331456 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 543686656 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 1572864 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1458339840 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 2.2237210551270485 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 6.365423609172569 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 99.70677451971689 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7725.938, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3263.86, - "Status": "Ok", - "TotalDuration": 145484.928, - "TotalOverhead": 16728.473, - "ValidationOverhead": 1.463 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 28193.472, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 72788.105 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6389.1, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 35.458, - "Status": "Ok", - "TotalDuration": 28193.472, - "TotalOverhead": 79214.726, - "ValidationOverhead": 2.063 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 28222.688, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.824 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 10394.884, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.27, - "Status": "Ok", - "TotalDuration": 28222.688, - "TotalOverhead": 10431.175, - "ValidationOverhead": 1.197 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 169597.056, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 82545.528 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7750.785, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 53.682, - "Status": "Ok", - "TotalDuration": 169597.056, - "TotalOverhead": 90352.089, - "ValidationOverhead": 2.094 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 169961.952, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.617 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7653.905, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 24.817, - "Status": "Ok", - "TotalDuration": 169961.952, - "TotalOverhead": 7682.534, - "ValidationOverhead": 1.195 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 170099.232, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 20.218 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7608.984, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 22.204, - "Status": "Ok", - "TotalDuration": 170099.232, - "TotalOverhead": 7652.773, - "ValidationOverhead": 1.367 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 32 - }, - "Duration": 170157.792, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 17.455 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7647.529, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 14.399, - "Status": "Ok", - "TotalDuration": 170157.792, - "TotalOverhead": 7680.716, - "ValidationOverhead": 1.333 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 22 - }, - "Duration": 28221.664, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 7133.809, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2576945 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 164713842 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 558280161 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065813 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 98.09160305343511 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9903113097651111 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 95.99357969274497 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 6123683840 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 2738880512 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 1111490560 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 983957504 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 12.64056832070888 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 8 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 28.250668669347007 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.26162248568004 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7697.216, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3086.935, - "Status": "Ok", - "TotalDuration": 28221.664, - "TotalOverhead": 17919.453, - "ValidationOverhead": 1.493 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 104831.008, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 78734.459 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8576.049, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 36.128, - "Status": "Ok", - "TotalDuration": 104831.008, - "TotalOverhead": 87349.195, - "ValidationOverhead": 2.559 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 64, - "RegistersCount": 20 - }, - "Duration": 104653.216, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 16 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.744 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7598.185, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 33.308, - "Status": "Ok", - "TotalDuration": 104653.216, - "TotalOverhead": 7635.505, - "ValidationOverhead": 1.268 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 29685.952, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 72971.284 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7609.232, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 55.198, - "Status": "Ok", - "TotalDuration": 29685.952, - "TotalOverhead": 80637.901, - "ValidationOverhead": 2.187 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 31160.256, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.707 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7625.261, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 25.118, - "Status": "Ok", - "TotalDuration": 31160.256, - "TotalOverhead": 7654.206, - "ValidationOverhead": 1.12 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 31927.968, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.43 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7673.913, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 20.937, - "Status": "Ok", - "TotalDuration": 31927.968, - "TotalOverhead": 7698.785, - "ValidationOverhead": 1.505 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 32003.04, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.149 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7694.597, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 13.72, - "Status": "Ok", - "TotalDuration": 32003.04, - "TotalOverhead": 7711.811, - "ValidationOverhead": 1.345 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 32, - "RegistersCount": 25 - }, - "Duration": 31542.304, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 32 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 5074.91, - "ProfilingData": { - "Counters": [ - { - "Name": "dram_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "dram_read_transactions", - "Type": "UnsignedInt", - "Value": 2865863 - }, - { - "Name": "dram_write_transactions", - "Type": "UnsignedInt", - "Value": 173561160 - }, - { - "Name": "l2_utilization", - "Type": "UtilizationLevel", - "Value": 7 - }, - { - "Name": "l2_read_transactions", - "Type": "UnsignedInt", - "Value": 608903342 - }, - { - "Name": "l2_write_transactions", - "Type": "UnsignedInt", - "Value": 541065229 - }, - { - "Name": "tex_utilization", - "Type": "UtilizationLevel", - "Value": 5 - }, - { - "Name": "tex_cache_transactions", - "Type": "UnsignedInt", - "Value": 809500672 - }, - { - "Name": "local_memory_overhead", - "Type": "Percent", - "Value": 93.7956204379562 - }, - { - "Name": "shared_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "shared_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "shared_load_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "shared_store_transactions", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "local_load_transactions", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "local_store_transactions", - "Type": "UnsignedInt", - "Value": 538968064 - }, - { - "Name": "achieved_occupancy", - "Type": "Double", - "Value": 0.9881109971636389 - }, - { - "Name": "sm_efficiency", - "Type": "Percent", - "Value": 96.59632984735472 - }, - { - "Name": "inst_fp_16", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_fp_32", - "Type": "UnsignedInt", - "Value": 19881000960 - }, - { - "Name": "inst_fp_64", - "Type": "UnsignedInt", - "Value": 0 - }, - { - "Name": "inst_integer", - "Type": "UnsignedInt", - "Value": 9837740032 - }, - { - "Name": "inst_control", - "Type": "UnsignedInt", - "Value": 1077936128 - }, - { - "Name": "inst_compute_ld_st", - "Type": "UnsignedInt", - "Value": 4349493248 - }, - { - "Name": "inst_misc", - "Type": "UnsignedInt", - "Value": 2174746624 - }, - { - "Name": "inst_bit_convert", - "Type": "UnsignedInt", - "Value": 6291456 - }, - { - "Name": "inst_executed", - "Type": "UnsignedInt", - "Value": 1183580160 - }, - { - "Name": "half_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "single_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 3 - }, - { - "Name": "flop_sp_efficiency", - "Type": "Percent", - "Value": 12.121202862215986 - }, - { - "Name": "double_precision_fu_utilization", - "Type": "UtilizationLevel", - "Value": 0 - }, - { - "Name": "flop_dp_efficiency", - "Type": "Percent", - "Value": 0.0 - }, - { - "Name": "special_fu_utilization", - "Type": "UtilizationLevel", - "Value": 2 - }, - { - "Name": "cf_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "ldst_fu_utilization", - "Type": "UtilizationLevel", - "Value": 1 - }, - { - "Name": "tex_fu_utilization", - "Type": "UtilizationLevel", - "Value": 9 - }, - { - "Name": "issue_slot_utilization", - "Type": "Percent", - "Value": 30.955638058854625 - }, - { - "Name": "warp_execution_efficiency", - "Type": "Percent", - "Value": 100.0 - }, - { - "Name": "warp_nonpred_execution_efficiency", - "Type": "Percent", - "Value": 98.55481727574751 - } - ], - "RemainingProfilingRuns": 0 - } - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 4, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 8744.937, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 3492.932, - "Status": "Ok", - "TotalDuration": 31542.304, - "TotalOverhead": 17314.277, - "ValidationOverhead": 1.498 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171834.24, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 80860.069 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 6869.106, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 37.994, - "Status": "Ok", - "TotalDuration": 171834.24, - "TotalOverhead": 87769.294, - "ValidationOverhead": 2.125 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 172013.696, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.76 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7658.442, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 32.252, - "Status": "Ok", - "TotalDuration": 172013.696, - "TotalOverhead": 7694.608, - "ValidationOverhead": 1.154 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171799.136, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.252 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7653.219, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 23.562, - "Status": "Ok", - "TotalDuration": 171799.136, - "TotalOverhead": 7680.502, - "ValidationOverhead": 1.469 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 171951.424, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.272 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7607.184, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 21.991, - "Status": "Ok", - "TotalDuration": 171951.424, - "TotalOverhead": 7632.784, - "ValidationOverhead": 1.337 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 31 - }, - "Duration": 172003.2, - "GlobalSize": { - "X": 16, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 16, - "Y": 8, - "Z": 1 - }, - "Overhead": 2.279 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 16, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7630.836, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 19.789, - "Status": "Ok", - "TotalDuration": 172003.2, - "TotalOverhead": 7654.334, - "ValidationOverhead": 1.43 - }, - { - "ComputationResults": [ - { - "CompilationData": { - "ConstantMemorySize": 0, - "LocalMemorySize": 0, - "MaxWorkGroupSize": 1024, - "PrivateMemorySize": 128, - "RegistersCount": 18 - }, - "Duration": 171893.088, - "GlobalSize": { - "X": 8, - "Y": 32, - "Z": 8 - }, - "KernelFunction": "directCoulombSum", - "LocalSize": { - "X": 32, - "Y": 8, - "Z": 1 - }, - "Overhead": 79493.8 - } - ], - "Configuration": [ - { - "Name": "INNER_UNROLL_FACTOR", - "Value": 2, - "ValueType": "UnsignedInt" - }, - { - "Name": "Z_ITERATIONS", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_X", - "Value": 32, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Y", - "Value": 8, - "ValueType": "UnsignedInt" - }, - { - "Name": "WORK_GROUP_SIZE_Z", - "Value": 1, - "ValueType": "UnsignedInt" - }, - { - "Name": "USE_SOA", - "Value": 0, - "ValueType": "UnsignedInt" - }, - { - "Name": "VECTOR_SIZE", - "Value": 1, - "ValueType": "UnsignedInt" - } - ], - "DataMovementOverhead": 7700.103, - "ExtraDuration": 0.0, - "KernelName": "directCoulombSum", - "SearcherOverhead": 7.725, - "Status": "Ok", - "TotalDuration": 171893.088, - "TotalOverhead": 87203.688, - "ValidationOverhead": 2.06 - } - ] -} \ No newline at end of file diff --git "a/Tutorials/08ProfileBasedSearcher/\\" "b/Tutorials/08ProfileBasedSearcher/\\" deleted file mode 100644 index e3e184c7..00000000 --- "a/Tutorials/08ProfileBasedSearcher/\\" +++ /dev/null @@ -1,241 +0,0 @@ -import sys -import numpy as np -import pyktt as ktt - -from base import * -from mlKTTPredictor import * - -BATCH = 5 - -# Implement custom searcher in Python. The interface is the same as in C++, including helper methods defined in -# the parent class. Note that it is necessary to call the parent class constructor from inheriting constructor. -class PyRandomSearcher(ktt.Searcher): - def __init__(self): - ktt.Searcher.__init__(self) - - def OnInitialize(self): - self.currentConfiguration = self.GetRandomConfiguration() - - def CalculateNextConfiguration(self, previousResult): - self.currentConfiguration = self.GetRandomConfiguration() - return True - - def GetCurrentConfiguration(self): - return self.currentConfiguration - - currentConfiguration = ktt.KernelConfiguration() - -class PyProfilingSearcher(ktt.Searcher): - ccMajor = 0 - ccMinor = 0 - cc = 0 - multiprocessors = 0 - profilingCountersModel = 0 - bestDuration = -1 - bestConf = None - preselectedBatch = [] - tuningParamsNames = [] - currentConfiguration = ktt.KernelConfiguration() - tuner = None - model = None - - def __init__(self): - ktt.Searcher.__init__(self) - - def OnInitialize(self): - for i in range(0, BATCH) : - self.preselectedBatch.append(self.GetRandomConfiguration()) - self.currentConfiguration = self.preselectedBatch[0] - - tp = self.currentConfiguration.GetPairs() - for p in tp : - self.tuningParamsNames.append(p.GetName()) - - def Configure(self, tuner, modelFile): - self.tuner = tuner - self.ccMajor = tuner.GetCurrentDeviceInfo().GetCUDAComputeCapabilityMajor() - self.ccMinor = tuner.GetCurrentDeviceInfo().GetCUDAComputeCapabilityMinor() - self.cc = self.ccMajor + round(0.1 * self.ccMinor, 1) - self.multiprocessors = tuner.GetCurrentDeviceInfo().GetMaxComputeUnits() - - self.profilingCountersModel = readPCList(modelFile + ".pc") - self.model = loadMLModel(modelFile) - - def CalculateNextConfiguration(self, previousResult): - # select the new configuration - if len(self.preselectedBatch) > 0: - # we are testing current batch - if (self.bestConf == None) or (previousResult.GetKernelDuration() < self.bestDuration) : - self.bestDuration = previousResult.GetKernelDuration() - self.bestConf = self.currentConfiguration - self.currentConfiguration = self.preselectedBatch.pop(0) - else : - if self.bestDuration != -1 : - # we run the fastest one once again, but with profiling - self.currentConfiguration = self.bestConf - self.bestDuration = -1 - self.tuner.SetProfiling(True) - else : - # get PCs from the last tuning run - if len(previousResult.GetResults()[0]) > 1: - print("Warning: this version of profile-based searcher does not support searching kernels collections. Using counters from kernels 0 only.") - globalSize = previousResult.GetResults()[0].GetGlobalSize() - localSize = previousResult.GetResults()[0].GetLocalSize() - profilingCountersRun = previousResult.GetResults()[0].GetProfilingData().GetCounters() #FIXME this supposes there is no composition profiled - pcNames = ["Global size", "Local size"] - pcVals = [globalSize.GetTotalSize(), localSize.GetTotalSize()] - for pd in profilingCountersRun : - pcNames.append(pd.GetName()) - if (pd.GetType() == ktt.ProfilingCounterType.Int) : - pcVals.append(pd.GetValueInt()) - elif (pd.GetType() == ktt.ProfilingCounterType.UnsignedInt) or (pd.GetType() == ktt.ProfilingCounterType.Throughput) or (pd.GetType() == ktt.ProfilingCounterType.UtilizationLevel): - pcVals.append(pd.GetValueUint()) - elif (pd.GetType() == ktt.ProfilingCounterType.Double) or (pd.GetType() == ktt.ProfilingCounterType.Percent) : - pcVals.append(pd.GetValueDouble()) - else : - print("Fatal error, unsupported PC value passed to profile-based searcher!") - exit(1) - - # select candidate configurations according to position of the best one plus some random sample - candidates = self.GetNeighbourConfigurations(self.bestConf, 2, 100) - for i in range (0, 10) : - candidates.append(self.GetRandomConfiguration()) - print("Profile-based searcher: evaluating model for " + str(len(candidates)) + " candidates...") - - # get tuning space from candidates - candidatesTuningSpace = [] - for c in candidates : - tp = c.GetPairs() - candidateParams = [] - for p in tp : - candidateParams.append(p.GetValue()) - candidatesTuningSpace.append(candidateParams) - myTuningSpace = [] - tp = self.bestConf.GetPairs() - for p in tp : - myTuningSpace.append(p.GetValue()) - - # score the configurations - scoreDistrib = [1.0]*len(candidates) - bottlenecks = analyzeBottlenecks(pcNames, pcVals, 6.1, self.multiprocessors, self.convertSM2Cores() * self.multiprocessors) - changes = computeChanges(bottlenecks, self.profilingCountersModel, self.cc) - scoreDistrib = scoreTuningConfigurationsPredictor(changes, self.tuningParamsNames, myTuningSpace, candidatesTuningSpace, scoreDistrib, self.model) - - # select next batch - for i in range(0, BATCH) : - idx = weightedRandomSearchStep(scoreDistrib, len(candidates)) - self.preselectedBatch.append(candidates[idx]) - self.currentConfiguration = self.preselectedBatch[0] - self.bestConf = None - self.tuner.SetProfiling(False) - - return True - - def GetCurrentConfiguration(self): - return self.currentConfiguration - - def convertSM2Cores(self): - smToCoresDict = { - 0x30: 192, - 0x32: 192, - 0x35: 192, - 0x37: 192, - 0x50: 128, - 0x52: 128, - 0x53: 128, - 0x60: 64, - 0x61: 128, - 0x62: 128, - 0x70: 64, - 0x72: 64, - 0x75: 64, - 0x80: 64, - 0x86: 64 - } - defaultSM = 64 - - compact = (self.ccMajor << 4) + self.ccMinor - if compact in smToCoresDict: - return smToCoresDict[compact] - else: - print("Warning: unknown number of cores for SM " + str(self.ccMajor) + "." + str(self.ccMinor) + ", using default value of " + str(defaultSM)) - return defaultSM - -def main(): - deviceIndex = 0 - kernelFile = "./CudaKernel.cu" - - argc = len(sys.argv) - - if argc >= 2: - deviceIndex = sys.argv[1] - - if argc >= 3: - kernelFile = sys.argv[2] - - numberOfAtoms = 256 - gridSize = 256 - gridSpacing = 0.5 - gridDimensions = ktt.DimensionVector(gridSize, gridSize, gridSize) - blockDimensions = ktt.DimensionVector(1, 1) - - aX = 100.0 * np.random.rand(numberOfAtoms).astype('f') - aY = 100.0 * np.random.rand(numberOfAtoms).astype('f') - aZ = 100.0 * np.random.rand(numberOfAtoms).astype('f') - aW = 100.0 * np.random.rand(numberOfAtoms).astype('f') - aAll = np.zeros(numberOfAtoms*4, dtype = np.single) - for i in range(numberOfAtoms): - aAll[4 * i] = aX[i] - aAll[4 * i + 1] = aY[i] - aAll[4 * i + 2] = aZ[i] - aAll[4 * i + 3] = aW[i] - energyGrid = np.zeros(gridSize*gridSize*gridSize, dtype = np.single) - - tuner = ktt.Tuner(0, deviceIndex, ktt.ComputeApi.CUDA) - tuner.SetCompilerOptions("-use_fast_math") - tuner.SetTimeUnit(ktt.TimeUnit.Microseconds) - tuner.SetProfiling(False) - - definition = tuner.AddKernelDefinitionFromFile("directCoulombSum", kernelFile, gridDimensions, blockDimensions) - - aXId = tuner.AddArgumentVectorFloat(aX, ktt.ArgumentAccessType.ReadOnly) - aYId = tuner.AddArgumentVectorFloat(aY, ktt.ArgumentAccessType.ReadOnly) - aZId = tuner.AddArgumentVectorFloat(aZ, ktt.ArgumentAccessType.ReadOnly) - aWId = tuner.AddArgumentVectorFloat(aW, ktt.ArgumentAccessType.ReadOnly) - aAllId = tuner.AddArgumentVectorFloat(aAll, ktt.ArgumentAccessType.ReadOnly) - numberOfAtomsId = tuner.AddArgumentScalarInt(numberOfAtoms) - gridSpacingId = tuner.AddArgumentScalarFloat(gridSpacing) - gridSizeId = tuner.AddArgumentScalarInt(gridSize) - energyGridId = tuner.AddArgumentVectorFloat(energyGrid, ktt.ArgumentAccessType.WriteOnly) - tuner.SetArguments(definition, [aAllId, aXId, aYId, aZId, aWId, numberOfAtomsId, gridSpacingId, gridSizeId, energyGridId]) - - kernel = tuner.CreateSimpleKernel("directCoulombSum", definition) - - tuner.AddParameter(kernel, "WORK_GROUP_SIZE_X", [16, 32]) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Local, ktt.ModifierDimension.X, "WORK_GROUP_SIZE_X", ktt.ModifierAction.Multiply) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Global, ktt.ModifierDimension.X, "WORK_GROUP_SIZE_X", ktt.ModifierAction.Divide) - tuner.AddParameter(kernel, "WORK_GROUP_SIZE_Y", [1, 2, 4, 8]) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Local, ktt.ModifierDimension.Y, "WORK_GROUP_SIZE_Y", ktt.ModifierAction.Multiply) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Global, ktt.ModifierDimension.Y, "WORK_GROUP_SIZE_Y", ktt.ModifierAction.Divide) - tuner.AddParameter(kernel, "WORK_GROUP_SIZE_Z", [1]) - tuner.AddParameter(kernel, "Z_ITERATIONS", [1, 2, 4, 8, 16, 32]) - tuner.AddThreadModifier(kernel, [definition], ktt.ModifierType.Global, ktt.ModifierDimension.Z, "Z_ITERATIONS", ktt.ModifierAction.Divide) - tuner.AddParameter(kernel, "INNER_UNROLL_FACTOR", [0, 1, 2, 4, 8, 16, 32]) - tuner.AddParameter(kernel, "USE_SOA", [0, 1]) - tuner.AddParameter(kernel, "VECTOR_SIZE", [1]) - unrollLimit = lambda vector: vector[0] < vector[1] - tuner.AddConstraint(kernel, ["INNER_UNROLL_FACTOR", "Z_ITERATIONS"], unrollLimit) - parallelBound = lambda vector: vector[0] * vector[1] >= 64 - tuner.AddConstraint(kernel, ["WORK_GROUP_SIZE_X", "WORK_GROUP_SIZE_Y"], parallelBound) - - # Make tuner user the searcher implemented in Python. - searcher = PyProfilingSearcher() - tuner.SetSearcher(kernel, searcher) - searcher.Configure(tuner, "1070-coulomb_output_DT.sav") - - # Begin tuning utilizing the stop condition implemented in Python. - results = tuner.Tune(kernel) - tuner.SaveResults(results, "TuningOutput", ktt.OutputFormat.JSON) - -if __name__ == "__main__": - main() diff --git a/Tutorials/08ProfileBasedSearcher/__pycache__/base.cpython-36.pyc b/Tutorials/08ProfileBasedSearcher/__pycache__/base.cpython-36.pyc deleted file mode 100644 index 39b90a3c..00000000 Binary files a/Tutorials/08ProfileBasedSearcher/__pycache__/base.cpython-36.pyc and /dev/null differ diff --git a/Tutorials/08ProfileBasedSearcher/__pycache__/mlKTTPredictor.cpython-36.pyc b/Tutorials/08ProfileBasedSearcher/__pycache__/mlKTTPredictor.cpython-36.pyc deleted file mode 100644 index 2622d665..00000000 Binary files a/Tutorials/08ProfileBasedSearcher/__pycache__/mlKTTPredictor.cpython-36.pyc and /dev/null differ diff --git a/Tutorials/08ProfileBasedSearcher/pyktt.so b/Tutorials/08ProfileBasedSearcher/pyktt.so deleted file mode 100755 index 8e3d27cf..00000000 Binary files a/Tutorials/08ProfileBasedSearcher/pyktt.so and /dev/null differ