Decouple free ab

HostLibraryTests/TensorDescriptor_test.cpp

@@ -50,27 +50,76 @@ TEST(TensorDescriptor, Simple)
     EXPECT_EQ(t.index(3,4,1), 3 + 4*11 + 11*13);
 }
 
+TEST(TensorDescriptor, OverlappingStrides)
+{
+    TensorDescriptor t(DataType::Float, {4,6,3}, {1,4,1});
+
+    EXPECT_EQ(t.dimensions(), 3);
+    EXPECT_EQ(t.sizes(),   std::vector<size_t>({4,6,3}));
+    EXPECT_EQ(t.strides(), std::vector<size_t>({1,4,1}));
+
+    EXPECT_EQ(t.dimensionPadding(0), 0);
+    EXPECT_EQ(t.dimensionPadding(1), 0);
+
+    EXPECT_EQ(t.totalLogicalElements(),   4*6*3);
+    EXPECT_EQ(t.totalAllocatedElements(), 4*6+(3-1));
+    EXPECT_EQ(t.totalAllocatedBytes(),    (4*6+(3-1))*4);
+}
+
 TEST(TensorDescriptor, Padded)
 {
     TensorDescriptor t(DataType::Float, {11,13,17,4}, {1, 16, 16*13, 16*13*17});
 
     EXPECT_EQ(t.dimensions(), 4);
     EXPECT_EQ(t.sizes(),   std::vector<size_t>({11,13,17,4}));
-    EXPECT_EQ(t.strides(), std::vector<size_t>({1,16,16*13,16*13*17}));
+    EXPECT_EQ(t.strides(), std::vector<size_t>({1, 16,16*13,16*13*17}));
 
     EXPECT_EQ(t.totalLogicalElements(),   11*13*17*4);
-    EXPECT_EQ(t.totalAllocatedElements(), 16*13*17*4);
-    EXPECT_EQ(t.totalAllocatedBytes(),    16*13*17*4*4);
+    EXPECT_EQ(t.totalAllocatedElements(), 1 + 1*(11-1) + 16*(13-1) + (16*13)*(17-1) + (16*13*17)*(4-1));
 
     EXPECT_EQ(t.dimensionPadding(0), 0);
     EXPECT_EQ(t.dimensionPadding(1), 5);
     EXPECT_EQ(t.dimensionPadding(2), 0);
     EXPECT_EQ(t.dimensionPadding(3), 0);
 
     EXPECT_EQ(t.index(3,4,1,2), 3 + 4*16 + 16*13 + 16*13*17*2);
+}
+
+TEST(TensorDescriptor, SimplePadded)
+{
+    TensorDescriptor t(DataType::Float, {4,5}, {1,8});
+
+    EXPECT_EQ(t.dimensions(), 2);
+    EXPECT_EQ(t.sizes(),   std::vector<size_t>({4,5}));
+    EXPECT_EQ(t.strides(), std::vector<size_t>({1,8}));  // default 1,4
+
+    EXPECT_EQ(t.dimensionPadding(0), 0);
+    EXPECT_EQ(t.dimensionPadding(1), 4);
+
+    EXPECT_EQ(t.totalLogicalElements(),   4*5);
+    EXPECT_EQ(t.totalAllocatedElements(), 4+8*(5-1));
+    //EXPECT_EQ(t.totalAllocatedBytes(),    (4*6+(3-1))*4);
 
 }
 
+TEST(TensorDescriptor, SimpleStrideZero)
+{
+    TensorDescriptor t(DataType::Float, {4,5,6},
+        {TensorDescriptor::UseDefaultStride,TensorDescriptor::UseDefaultStride,0});
+
+    EXPECT_EQ(t.dimensions(), 3);
+    EXPECT_EQ(t.sizes(),   std::vector<size_t>({4,5,6}));
+    EXPECT_EQ(t.strides(), std::vector<size_t>({1,4,0}));  // default 1,4
+
+    EXPECT_EQ(t.dimensionPadding(0), 0);
+    EXPECT_EQ(t.dimensionPadding(1), 0);
+    EXPECT_EQ(t.dimensionPadding(2), -20);
+
+    EXPECT_EQ(t.totalLogicalElements(),   4*5*6);
+    EXPECT_EQ(t.totalAllocatedElements(), 4*5);
+    EXPECT_EQ(t.totalAllocatedBytes(),    4*5*4);
+}
+
 TEST(TensorDescriptor, CollapseDims1)
 {
     TensorDescriptor t(DataType::Float, {11,13,17,4}, {1, 16, 16*13, 16*13*17});
@@ -179,13 +228,19 @@ TEST(TensorDescriptor, IncrementCoord2d)
                              dims.begin(), dims.end()), true);
 }
 
+TEST(TensorDescriptor, DefaultLowerDims)
+{
+    TensorDescriptor desc(DataType::Float, {4,5,6}, {static_cast<size_t>(-1),5});
+    EXPECT_EQ(desc.dimensions(), 3);
+    EXPECT_EQ(desc.sizes(), std::vector<size_t>({4,5,6}));
+    EXPECT_EQ(desc.strides(), std::vector<size_t>({1,5,25}));
+}
+
 TEST(TensorDescriptor, LowerDimOnly)
 {
     TensorDescriptor desc(DataType::Float, {4,5,6}, {5});
-    TensorDescriptor desc2(DataType::Float, {4,5,6});
-
     EXPECT_EQ(desc.dimensions(), 3);
     EXPECT_EQ(desc.sizes(), std::vector<size_t>({4,5,6}));
-    EXPECT_EQ(desc.strides(), std::vector<size_t>({1,5,25}));
+    EXPECT_EQ(desc.strides(), std::vector<size_t>({5,20,100}));
 }
 

Tensile/BenchmarkProblems.py

@@ -411,10 +411,12 @@ def isbad(x):
 # Read GFlop/s from file
 ################################################################################
 def getResults(resultsFileName, solutions, enableTileSelection, newResultsFileName=None):
-  try:
-    resultsFile = open(resultsFileName, "r")
-  except IOError:
-    printExit("Can't open \"%s\" to get results" % resultsFileName )
+
+  if globalParameters["NewClient"] < 2:
+    try:
+      resultsFile = open(resultsFileName, "r")
+    except IOError:
+      printExit("Can't open \"%s\" to get results" % resultsFileName )
 
   newCSV = itertools.repeat(None)
   if newResultsFileName is not None:
@@ -425,53 +427,54 @@ def getResults(resultsFileName, solutions, enableTileSelection, newResultsFileNa
     diffCSV = csv.writer(diffFile)
 
   # setup data structures
-  numSolutions = 0
   results = []
-  for solutionsForHardcoded in solutions:
-    results.append([])
-    for solution in solutionsForHardcoded:
-      # GEMM csv files contain "LDD" "LDC" "LDA" "LDB" columns
-      if solution["ProblemType"]["OperationType"] == "GEMM":
-        problemSizeIdx = solution["ProblemType"]["TotalIndices"] + 5
+  if globalParameters["NewClient"] < 2:
+    numSolutions = 0
+    for solutionsForHardcoded in solutions:
+      results.append([])
+      for solution in solutionsForHardcoded:
+        # GEMM csv files contain "LDD" "LDC" "LDA" "LDB" columns
+        if solution["ProblemType"]["OperationType"] == "GEMM":
+          problemSizeIdx = solution["ProblemType"]["TotalIndices"] + 5
+        else:
+          problemSizeIdx = solution["ProblemType"]["TotalIndices"] + 1
+        results[-1].append([])
+        numSolutions += 1
+
+    # read results in gflops
+    csvFile = csv.reader(resultsFile)
+    startIdx = problemSizeIdx + 1
+    rowLength = startIdx + numSolutions
+
+    rowIdx = 0
+    for row,newRow in zip(csvFile, newCSV):
+      rowIdx+=1
+      if rowIdx == 1:
+        if newRow is not None:
+          diffCSV.writerow(row)
+          diffCSV.writerow(newRow)
+          headerRow = row
+        continue
       else:
-        problemSizeIdx = solution["ProblemType"]["TotalIndices"] + 1
-      results[-1].append([])
-      numSolutions += 1
-
-  # read results in gflops
-  csvFile = csv.reader(resultsFile)
-  startIdx = problemSizeIdx + 1
-  rowLength = startIdx + numSolutions
-
-  rowIdx = 0
-  for row,newRow in zip(csvFile, newCSV):
-    rowIdx+=1
-    if rowIdx == 1:
-      if newRow is not None:
-        diffCSV.writerow(row)
-        diffCSV.writerow(newRow)
-        headerRow = row
-      continue
-    else:
-      if len(row) < rowLength:
-        printWarning("CSV File %s row %u doesn't have %u elements; ignoring remainer of file." \
-            % (resultsFileName, rowIdx, rowLength) )
-        break
-      if newRow is not None:
-        diffCSV.writerow([compareResults(old,new,name) for old,new,name in itertools.zip_longest(row, newRow, headerRow)])
-
-      idx = startIdx
-      for i,solutionsForHardcoded in enumerate(solutions):
-        for j,solution in enumerate(solutionsForHardcoded):
-          gflops = float(row[idx])
-
-          results[i][j].append(gflops)
-          idx += 1
-  if rowIdx < 2 and not enableTileSelection:
-    printExit("CSV File %s only has %u row(s); prior benchmark must not have run long enough to produce data." \
-        % (resultsFileName, rowIdx) )
-
-  resultsFile.close()
+        if len(row) < rowLength:
+          printWarning("CSV File %s row %u doesn't have %u elements; ignoring remainer of file." \
+              % (resultsFileName, rowIdx, rowLength) )
+          break
+        if newRow is not None:
+          diffCSV.writerow([compareResults(old,new,name) for old,new,name in itertools.zip_longest(row, newRow, headerRow)])
+
+        idx = startIdx
+        for i,solutionsForHardcoded in enumerate(solutions):
+          for j,solution in enumerate(solutionsForHardcoded):
+            gflops = float(row[idx])
+
+            results[i][j].append(gflops)
+            idx += 1
+    if rowIdx < 2 and not enableTileSelection:
+      printExit("CSV File %s only has %u row(s); prior benchmark must not have run long enough to produce data." \
+          % (resultsFileName, rowIdx) )
+
+    resultsFile.close()
   if newResultsFileName is not None:
     newFile.close()
     diffFile.close()
@@ -806,7 +809,8 @@ def main( config ):
         resultsFileName = "%s.csv" % (resultsFileBase)
         solutionsFileName = "%s.yaml" % (resultsFileBase)
         granularityFileName = "%s_Granularity.csv" % (resultsFileBase)
-        shutil.copy( resultsFileName, newResultsFileName )
+        if globalParameters["NewClient"] < 2:
+          shutil.copy( resultsFileName, newResultsFileName )
         shutil.copy( solutionsFileName, newSolutionsFileName )
         if os.path.isfile(granularityFileName):
           shutil.copy( granularityFileName, newGranularityFileName )