[OpenCL] Group builtin functions by prototype

[svenvh]

Summary

The file generated from the tablegen file, and containing the
function definitions can be re-organised to save some memory.
Functions having the same prototypes will point to a common
list of prototypes.
Functions having only one prototype will point to a prototype
definition of another function.

This depends on:
-1, splitting opencl-c.h file: https://reviews.llvm.org/D63256/new/
-2, Adding generic types: https://reviews.llvm.org/D63434
-3, Adding const, volatile and pointer types: https://reviews.llvm.org/D63442
-4, Adding image types: https://reviews.llvm.org/D63480
-5, Adding version handling: https://reviews.llvm.org/D63504

[Anastasia]

Functions having only one prototype will point to a prototype
definition of another function.

Do you mean functions having only one prototype will point to a prototype
definition of another function with the same prototype?

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

94

This optimization generally seems reasobale. Do you have any idea how it affects the build time to generate the Tablegen file and how much space do we actually save?

202

It is not clear whether signatures for functions that don't share the prototype with any others should still be in this table?

222

This data stricture is really difficult to understand, do you think you could split it into multiple type aliases?

521

I think you need to either simplify or document what (SignatureListMap.find(Candidate)->second.first)[Index].first expression returns.

545

where is this being deallocated?

558

same problem as before... expression is too complex!

567

The same here... where do we release the memory?

[svenvh]

• Improve variable names & comments.
• Fix memory leaks.
• Rebase on top of recent master, and move before https://reviews.llvm.org/D63555 as the generated code on master is growing in size; with this patch we save about 100kb in the binary.
• Restucture SignatureListMap to make it easier to understand.

[svenvh]

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

94

It doesn't affect build time in a noticable way. With this patch, clang-tblgen -gen-clang-opencl-builtins runs in less than half a second.

We save about 100kb now. The savings will increase when we add more OpenCL builtins to the .td file.

202

All signatures will go into this table. Some might be shared, some not.

222

Done.

521

Broken up (and readability benefits from the SignatureListMap restructuring too).

545

At lines 535 and 545 now.

558

Better now?

567

You were referring to a new expression here, which is now gone.

[Anastasia]

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

200

This sentence is a bit hard to understand. I am also still confused what BuiltinIndexListTy represents.

202

I am confused where does the saving come from. We are currently adding an extra data structure without removing any other. So do we then reduce number of entries in SignaturesList?

557

frame?

[svenvh]

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

200

Would it help if it was rephrased as follows?

Map an ordered vector of signatures to their original TableGen Record instances, and to a list of function names that share these signatures.

202

When generating the tables, this patch will make EmitBuiltinTable iterate over the entries in SignatureListMap instead of FctOverloadMap. SignatureListMap essentially contains the same information as FctOverloadMap, but it results in fewer table entries as we group builtins with the same signatures together.

557

"frame" here means an index into the BuiltinTable and the number of BuiltinTable entries, which together compose a list of signatures. This is the pair being returned by the StringMatcher when a name is successfully matched.

Frankly speaking the comment is a bit confusing, will rephrase as:
// A single signature list may be used by different builtins. Return the same <index, length> pair for each of those builtins.

[Anastasia]

LGTM! Feel free to change comments on the final commit! Thanks!

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

200

Yes, it is much more readable! Thank you!

557

Perfect! Thanks!

clang/utils/TableGen/ClangOpenCLBuiltinEmitter.cpp

   // FctOverloadMap and TypeMap.
   void GetOverloads();
 
+  // Helper function for BuiltinNameEmitter::GroupFctBySignature.
+  // When comparing two lists of signatures, checks OpenCL versions and
+  // function extension are equal for each signature.
+  // \param Candidate (in) The entry in the SignatureListMap to check
+  //
+  // \param SignatureList (in) The list of signatures of the considered function.
+  //
+  // \returns true if the two lists of signatures are identic
+  bool CheckSignature(SmallVector<unsigned, 11>* Candidate,
+        std::vector<std::pair<const Record *, unsigned>> &SignatureList);
+
+  // Some builtin functions have the same list of signatures. For instance, the
+  // "sin" and "cos" functions. To save space in the BuiltinTable, the
+  // "isOpenCLBuiltin" function will have the same output for these two
+  // function name.
+  // This function groups functions with the same list of signatures by
+  // populating the SignatureListMap.
+  void GroupFctBySignature();
+
   // Emit the FctExtensionTable and the TypeExtensionTable.
   // FctExtensionTable maps enums OpenCLFctExtensionID to their extension.
   // TypeExtensionTable maps OpenCLTypeID enums (not being generic types) to

 
   // Same as TypeExtensionList, but for generic types only.
   std::vector<const Record *> GenTypeExtensionList;
+
+  // Map an ordered vector of signatures to the definitions of the same list
+  // of signatures, and to a list of function names that have this list of
+  // signatures.
+  // E.g.:
+  // If the "cos" and "sin" functions had only three signatures. These
+  // signatures being at the index Ix in the SignatureTable:
+  //          cos         |         sin         |  Signature    | Index
+  //  float   cos(float)  | float   sin(float)  |  Signature1   | I1
+  //  double  cos(double) | double  sin(double) |  Signature2   | I2
+  //  half    cos(half)   | half    sin(half)   |  Signature3   | I3
+  //
+  // Then we will create a mapping of the vector of signature:
+  // SignatureListMap(<I1, I2, I3>) =
+  //     <<<Signature1, I1>,
+  //       <Signature2, I2>,
+  //       <Signature3, I3>>,
+  //       <"cos", "sin">>
+  // The function "tan", having the same signatures, would be inserted at the
+  // same entry (<I1, I2, I3>).
+  MapVector<SmallVector<unsigned, 11>*,
+            std::pair<std::vector<std::pair<const Record *, unsigned>>,
+                      std::vector<StringRef>*>> SignatureListMap;
 };
 } // namespace
 

 
   // Parse the Records to populate the internal lists
   GetOverloads();
+  GroupFctBySignature();
 
   // Emit data strucures.
   EmitExtensionTable();

   unsigned Index = 0;
 
   OS << "static const OpenCLBuiltinStruct BuiltinTable[] = {\n";
-  for (const auto &FOM : FctOverloadMap) {
+  for (const auto &SLM : SignatureListMap) {
 
-    OS << "// " << Index << " " << FOM.first << "\n";
+    OS << "// " << Index << " ";
+    for (const auto &Name : *(SLM.second.second)) {
+      OS << Name << ", ";
+    }
+    OS << "\n";
 
-    for (const auto &Overload : FOM.second) {
+    for (const auto &Overload : SLM.second.first) {
       OS << "  { "
          << Overload.second << ", "
          << Overload.first->getValueAsListOfDefs("Signature").size() << ", "

 }
 
 
+bool BuiltinNameEmitter::CheckSignature(
+      SmallVector<unsigned, 11>* Candidate,
+      std::vector<std::pair<const Record *, unsigned>> &SignatureList) {
+  // The two lists have the same list of signatures, but there are other
+  // fields to check
+  const Record *Rec, *Rec2;
+  for (unsigned Index = 0; Index < Candidate->size(); Index++) {
+    Rec   = SignatureList[Index].first;
+    Rec2  = (SignatureListMap.find(Candidate)->second.first)[Index].first;
+    if (Rec->getValueAsDef("MinVersion")->getValueAsInt("Name") ==
+        Rec2->getValueAsDef("MinVersion")->getValueAsInt("Name") &&
+        Rec->getValueAsDef("MaxVersion")->getValueAsInt("Name") ==
+        Rec2->getValueAsDef("MaxVersion")->getValueAsInt("Name") &&
+        Rec->getValueAsDef("Extension")->getValueAsString("ID") ==
+        Rec2->getValueAsDef("Extension")->getValueAsString("ID")) {
+        return true;
+    }
+  }
+  return false;
+}
+
+
+void BuiltinNameEmitter::GroupFctBySignature() {
+  // Available lists of signatures
+  std::vector<SmallVector<unsigned, 11>*> SignatureListPool;
+  bool FoundSimilar = false;
+
+  for (auto &Fct : FctOverloadMap) {
+    FoundSimilar = false;
+
+    // Gather all the signatures for the current function
+    SmallVector<unsigned, 11> *CurSignatureList =
+        new SmallVector<unsigned, 11>();
+    for (const auto &Signature : Fct.second) {
+      CurSignatureList->push_back(Signature.second);
+    }
+    // Order the list to facilitate the future comparisons
+    std::sort(CurSignatureList->begin(), CurSignatureList->end());
+
+    // Check if another function has the same list of signatures
+    // If yes, we just need to add the name of the function
+    for (auto *Candidate : SignatureListPool) {
+      if (Candidate->size() == CurSignatureList->size()) {
+        if (*Candidate == *CurSignatureList) {
+          if (CheckSignature(Candidate, Fct.second)) {
+            SignatureListMap.find(Candidate)->second.second->push_back(Fct.first);
+            FoundSimilar = true;
+          }
+        }
+      }
+    }
+
+    // else, add a new entry
+    if (!FoundSimilar) {
+      std::vector<StringRef> *NewStringList = new std::vector<StringRef>();
+      NewStringList->push_back(Fct.first);
+      SignatureListMap[CurSignatureList] =
+          std::make_pair(Fct.second, NewStringList);
+      SignatureListPool.push_back(CurSignatureList);
+    }
+  }
+}
+
+
 void BuiltinNameEmitter::EmitStringMatcher() {
   std::vector<StringMatcher::StringPair> ValidBuiltins;
   unsigned CumulativeIndex = 1;
-  for (auto &i : FctOverloadMap) {
-    auto &Ov = i.second;
-    std::string RetStmt;
-    raw_string_ostream SS(RetStmt);
-    SS << "return std::make_pair(" << CumulativeIndex << ", " << Ov.size()
-       << ");";
-    SS.flush();
-    CumulativeIndex += Ov.size();
-
-    ValidBuiltins.push_back(StringMatcher::StringPair(i.first, RetStmt));
-  }
 
+  for (const auto &SLM : SignatureListMap) {
+    const auto &Ovl = SLM.second.first;
+
+    // Function names with the same list of signatures have the reference the
+    // same frame in the BuiltinTable.
+    for (const auto &FctName : *(SLM.second.second)) {
+      std::string RetStmt;
+      raw_string_ostream SS(RetStmt);
+      SS << "return std::make_pair(" << CumulativeIndex << ", " << Ovl.size()
+         << ");";
+      SS.flush();
+      ValidBuiltins.push_back(StringMatcher::StringPair(FctName, RetStmt));
+    }
+    CumulativeIndex += Ovl.size();
+  }
 
   OS << R"(
 /// Find out whether a string matches an existing OpenCL builtin function name.