Parallelize the generation of the files. (#2035)

CMakeLists.txt

@@ -369,6 +369,9 @@ vulkan_hpp__setup_warning_level( NAME VulkanHppGenerator )
 target_compile_definitions( VulkanHppGenerator PUBLIC BASE_PATH="${CMAKE_CURRENT_SOURCE_DIR}" VK_SPEC="${vk_spec}" )
 target_include_directories( VulkanHppGenerator PRIVATE ${VULKAN_HPP_TINYXML2_SRC_DIR} )
 set_target_properties( VulkanHppGenerator PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON )
+if( UNIX )
+	target_link_libraries( VulkanHppGenerator PUBLIC pthread )
+endif()
 
 # The video generator executable
 add_executable( VideoHppGenerator VideoHppGenerator.cpp VideoHppGenerator.hpp XMLHelper.hpp ${TINYXML2_SOURCES} ${TINYXML2_HEADERS} )

VulkanHppGenerator.cpp

@@ -20,6 +20,7 @@
 #include <array>
 #include <cassert>
 #include <fstream>
+#include <future>
 #include <regex>
 #include <sstream>
 
@@ -90,10 +91,52 @@ VulkanHppGenerator::VulkanHppGenerator( tinyxml2::XMLDocument const & document,
   m_definesPartition = partitionDefines( m_defines );
 }
 
+void VulkanHppGenerator::distributeSecondLevelCommands()
+{
+  // distribute commands from instance/device to second-level handles, like Queue, Event,... for RAII handles
+  for ( auto & handle : m_handles )
+  {
+    if ( !handle.first.empty() )
+    {
+      for ( auto command = handle.second.commands.begin(); command != handle.second.commands.end(); )
+      {
+        bool foundCommand = false;
+        if ( !m_RAIISpecialFunctions.contains( *command ) )
+        {
+          auto commandIt = findByNameOrAlias( m_commands, *command );
+          assert( commandIt != m_commands.end() );
+          assert( commandIt->second.params.front().type.type == handle.first );
+          if ( ( 1 < commandIt->second.params.size() ) && ( isHandleType( commandIt->second.params[1].type.type ) ) && !commandIt->second.params[1].optional )
+          {
+            auto handleIt = m_handles.find( commandIt->second.params[1].type.type );
+            assert( handleIt != m_handles.end() );
+            // filter out functions seem to fit due to taking handles as first and second argument, but the first argument is not the
+            // type to create the second one, and so it's unknown to the raii handle!
+            assert( !handleIt->second.constructorIts.empty() );
+            if ( ( *handleIt->second.constructorIts.begin() )->second.handle == handle.first )
+            {
+              assert( std::none_of( handleIt->second.constructorIts.begin(),
+                                    handleIt->second.constructorIts.end(),
+                                    [&handle]( auto const & constructorIt ) { return constructorIt->second.handle != handle.first; } ) );
+              handleIt->second.secondLevelCommands.insert( *command );
+              command      = handle.second.commands.erase( command );
+              foundCommand = true;
+            }
+          }
+        }
+        if ( !foundCommand )
+        {
+          ++command;
+        }
+      }
+    }
+  }
+}
+
 void VulkanHppGenerator::generateEnumsHppFile() const
 {
   std::string const vulkan_enums_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_enums.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_enums_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_enums_hpp + " ...\n" );
 
   std::string const vulkanEnumsHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_ENUMS_HPP
@@ -124,7 +167,7 @@ ${objectTypeToDebugReportObjectType}
 void VulkanHppGenerator::generateExtensionInspectionFile() const
 {
   std::string const vulkan_extension_inspection_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_extension_inspection.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_extension_inspection_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_extension_inspection_hpp + " ...\n" );
 
   std::string const vulkanExtensionInspectionHppTemplate = readSnippet( "ExtensionInspection.hpp" );
   std::string const deprecatedExtensions = generateReplacedExtensionsList( []( ExtensionData const & extension ) { return extension.isDeprecated; },
@@ -168,7 +211,7 @@ void VulkanHppGenerator::generateExtensionInspectionFile() const
 void VulkanHppGenerator::generateFormatTraitsHppFile() const
 {
   std::string const vulkan_format_traits_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_format_traits.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_format_traits_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_format_traits_hpp + " ...\n" );
 
   std::string const vulkanFormatTraitsHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_FORMAT_TRAITS_HPP
@@ -192,7 +235,7 @@ ${formatTraits}
 void VulkanHppGenerator::generateFuncsHppFile() const
 {
   std::string const vulkan_funcs_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_funcs.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_funcs_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_funcs_hpp + " ...\n" );
 
   std::string const vulkanFuncsHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_FUNCS_HPP
@@ -217,7 +260,7 @@ ${commandDefinitions}
 void VulkanHppGenerator::generateHandlesHppFile() const
 {
   std::string const vulkan_handles_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_handles.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_handles_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_handles_hpp + " ...\n" );
 
   std::string const vulkanHandlesHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_HANDLES_HPP
@@ -304,7 +347,7 @@ namespace VULKAN_HPP_NAMESPACE
 void VulkanHppGenerator::generateHashHppFile() const
 {
   std::string const vulkan_hash_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_hash.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_hash_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_hash_hpp + " ...\n" );
 
   std::string const vulkanHandlesHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_HASH_HPP
@@ -346,7 +389,7 @@ ${structHashStructures}
 void VulkanHppGenerator::generateHppFile() const
 {
   std::string const vulkan_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + ".hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_hpp << " ... " << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_hpp + " ...\n" );
 
   std::string const vulkanHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_HPP
@@ -485,7 +528,8 @@ namespace VULKAN_HPP_NAMESPACE
 void VulkanHppGenerator::generateMacrosFile() const
 {
   std::string const macros_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_hpp_macros.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << macros_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + macros_hpp + " ...\n" );
+
   std::string const macrosTemplate = R"(${licenseHeader}
 
 #ifndef VULKAN_HPP_MACROS_HPP
@@ -509,7 +553,7 @@ ${macros}
 void VulkanHppGenerator::generateRAIIHppFile() const
 {
   std::string const vulkan_raii_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_raii.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_raii_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_raii_hpp + " ...\n" );
 
   std::string const vulkanHandlesHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_RAII_HPP
@@ -592,7 +636,7 @@ namespace VULKAN_HPP_NAMESPACE
 void VulkanHppGenerator::generateSharedHppFile() const
 {
   std::string const vulkan_shared_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_shared.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_shared_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_shared_hpp + " ...\n" );
 
   std::string const vulkanHandlesHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_SHARED_HPP
@@ -637,7 +681,7 @@ namespace VULKAN_HPP_NAMESPACE
 void VulkanHppGenerator::generateStaticAssertionsHppFile() const
 {
   std::string const static_assertions_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_static_assertions.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << static_assertions_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + static_assertions_hpp + " ...\n" );
 
   std::string const vulkanHandlesHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_STATIC_ASSERTIONS_HPP
@@ -662,7 +706,7 @@ ${staticAssertions}
 void VulkanHppGenerator::generateStructsHppFile() const
 {
   std::string const vulkan_structs_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_structs.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_structs_hpp << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_structs_hpp + " ...\n" );
 
   std::string const vulkanHandlesHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_STRUCTS_HPP
@@ -688,7 +732,7 @@ ${structs}
 void VulkanHppGenerator::generateToStringHppFile() const
 {
   std::string const vulkan_to_string_hpp = std::string( BASE_PATH ) + "/vulkan/" + m_api + "_to_string.hpp";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_to_string_hpp << "..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_to_string_hpp + " ...\n" );
 
   std::string const vulkanHandlesHppTemplate = R"(${licenseHeader}
 #ifndef VULKAN_TO_STRING_HPP
@@ -742,7 +786,7 @@ ${enumsToString}
 void VulkanHppGenerator::generateCppModuleFile() const
 {
   std::string const vulkan_cppm = std::string( BASE_PATH ) + "/vulkan/" + m_api + ".cppm";
-  std::cout << "VulkanHppGenerator: Generating " << vulkan_cppm << "..." << std::endl;
+  messager.message( "VulkanHppGenerator: Generating " + vulkan_cppm + " ...\n" );
 
   std::string const vulkanCppmTemplate = R"(${licenseHeader}
 
@@ -813,24 +857,6 @@ void VulkanHppGenerator::prepareRAIIHandles()
     }
     handleIt->second.constructorIts = determineRAIIHandleConstructors( handleIt->first, handleIt->second.destructorIt );
   }
-
-  distributeSecondLevelCommands( m_RAIISpecialFunctions );
-}
-
-void VulkanHppGenerator::prepareVulkanFuncs()
-{
-  // rename a couple of function parameters to prevent this warning, treated as an error:
-  // warning C4458: declaration of 'objectType' hides class member
-  for ( auto & command : m_commands )
-  {
-    for ( auto & param : command.second.params )
-    {
-      if ( param.name == "objectType" )
-      {
-        param.name += "_";
-      }
-    }
-  }
 }
 
 //
@@ -2258,48 +2284,6 @@ void VulkanHppGenerator::distributeEnumValueAliases()
   }
 }
 
-void VulkanHppGenerator::distributeSecondLevelCommands( std::set<std::string> const & specialFunctions )
-{
-  // distribute commands from instance/device to second-level handles, like Queue, Event,... for RAII handles
-  for ( auto & handle : m_handles )
-  {
-    if ( !handle.first.empty() )
-    {
-      for ( auto command = handle.second.commands.begin(); command != handle.second.commands.end(); )
-      {
-        bool foundCommand = false;
-        if ( !specialFunctions.contains( *command ) )
-        {
-          auto commandIt = findByNameOrAlias( m_commands, *command );
-          assert( commandIt != m_commands.end() );
-          assert( commandIt->second.params.front().type.type == handle.first );
-          if ( ( 1 < commandIt->second.params.size() ) && ( isHandleType( commandIt->second.params[1].type.type ) ) && !commandIt->second.params[1].optional )
-          {
-            auto handleIt = m_handles.find( commandIt->second.params[1].type.type );
-            assert( handleIt != m_handles.end() );
-            // filter out functions seem to fit due to taking handles as first and second argument, but the first argument is not the
-            // type to create the second one, and so it's unknown to the raii handle!
-            assert( !handleIt->second.constructorIts.empty() );
-            if ( ( *handleIt->second.constructorIts.begin() )->second.handle == handle.first )
-            {
-              assert( std::none_of( handleIt->second.constructorIts.begin(),
-                                    handleIt->second.constructorIts.end(),
-                                    [&handle]( auto const & constructorIt ) { return constructorIt->second.handle != handle.first; } ) );
-              handleIt->second.secondLevelCommands.insert( *command );
-              command      = handle.second.commands.erase( command );
-              foundCommand = true;
-            }
-          }
-        }
-        if ( !foundCommand )
-        {
-          ++command;
-        }
-      }
-    }
-  }
-}
-
 void VulkanHppGenerator::distributeRequirements()
 {
   for ( auto const & feature : m_features )
@@ -2598,7 +2582,9 @@ std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector<ParamD
       else
       {
         assert( params[i].type.isValue() );
-        arguments.push_back( composedType + " " + params[i].name + generateCArraySizes( params[i].arraySizes ) );
+        // parameters named "objectType" collide with the member variable -> append an _ to here
+        std::string paramName = ( definition && ( params[i].name == "objectType" ) ) ? "objectType_" : params[i].name;
+        arguments.push_back( composedType + " " + paramName + generateCArraySizes( params[i].arraySizes ) );
       }
       arguments.back() += std::string( !definition && ( defaultStartIndex <= i ) && !hasDefaultAssignment ? " VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT" : "" );
     }
@@ -2653,15 +2639,19 @@ std::string VulkanHppGenerator::generateArgumentListEnhanced( std::vector<ParamD
   return generateList( arguments, "", ", " );
 }
 
-std::string
+std::string VulkanHppGenerator::generateArgumentListStandard( std::vector<ParamData> const & params,
-  VulkanHppGenerator::generateArgumentListStandard( std::vector<ParamData> const & params, std::set<size_t> const & skippedParams, bool withDispatcher ) const
+                                                              std::set<size_t> const &       skippedParams,
+                                                              bool                           definition,
+                                                              bool                           withDispatcher ) const
 {
   std::string argumentList;
   for ( size_t i = 0; i < params.size(); ++i )
   {
     if ( !skippedParams.contains( i ) )
     {
-      argumentList += params[i].type.compose( "VULKAN_HPP_NAMESPACE" ) + " " + params[i].name + generateCArraySizes( params[i].arraySizes ) + ", ";
+      // parameters named "objectType" collide with the member variable -> append an _ to here
+      std::string paramName = ( definition && ( params[i].name == "objectType" ) ) ? "objectType_" : params[i].name;
+      argumentList += params[i].type.compose( "VULKAN_HPP_NAMESPACE" ) + " " + paramName + generateCArraySizes( params[i].arraySizes ) + ", ";
     }
   }
   if ( withDispatcher )
@@ -2994,6 +2984,11 @@ std::string VulkanHppGenerator::generateCallArgumentsStandard( std::vector<Param
       }
       else if ( param.type.isValue() )
       {
+        // parameters named "objectType" collide with the member variable -> append an _ to here
+        if ( argument == "objectType" )
+        {
+          argument += "_";
+        }
         argument = "static_cast<" + param.type.type + ">( " + argument + " )";
       }
       else
@@ -3190,7 +3185,9 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedValue(
       else
       {
         assert( param.type.isValue() );
-        argument = "static_cast<" + param.type.type + ">( " + param.name + " )";
+        // parameters named "objectType" collide with the member variable -> append an _ to here
+        std::string paramName = ( param.name == "objectType" ) ? "objectType_" : param.name;
+        argument              = "static_cast<" + param.type.type + ">( " + paramName + " )";
       }
       // check if this param is used as the stride of an other param
       assert( std::none_of( params.begin(), params.end(), [paramIndex]( ParamData const & pd ) { return pd.strideParam.second == paramIndex; } ) );
@@ -4835,7 +4832,7 @@ std::string
 {
   std::set<size_t> skippedParams = determineSkippedParams( commandData.params, initialSkipCount, {}, {}, false );
 
-  std::string argumentList = generateArgumentListStandard( commandData.params, skippedParams, true );
+  std::string argumentList = generateArgumentListStandard( commandData.params, skippedParams, definition, true );
   std::string commandName  = generateCommandName( name, commandData.params, initialSkipCount );
   std::string nodiscard    = ( 1 < commandData.successCodes.size() + commandData.errorCodes.size() ) ? "VULKAN_HPP_NODISCARD " : "";
   std::string returnType   = stripPrefix( commandData.returnType, "Vk" );
@@ -6081,7 +6078,7 @@ std::string VulkanHppGenerator::generateCppModuleRaiiUsings() const
           usings += replaceWithMap( raiiUsingTemplate, { { "className", stripPrefix( handleIt->first, "Vk" ) } } );
 
           // if there is an array constructor, generate the plural type also
-          if ( !generateRAIIHandleConstructors( *handleIt ).second.empty() )
+          if ( hasArrayConstructor( handleIt->second ) )
           {
             usings += replaceWithMap( raiiUsingTemplate, { { "className", stripPrefix( type.name, "Vk" ) + "s" } } );
           }
@@ -9782,7 +9779,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandStandard( std::string c
                                                                    bool                definition ) const
 {
   std::set<size_t> skippedParams = determineSkippedParams( commandData.params, initialSkipCount, {}, {}, false );
-  std::string      argumentList  = generateArgumentListStandard( commandData.params, skippedParams, false );
+  std::string      argumentList  = generateArgumentListStandard( commandData.params, skippedParams, definition, false );
   std::string      commandName   = generateCommandName( name, commandData.params, initialSkipCount );
   std::string      nodiscard     = ( commandData.returnType != "void" ) ? "VULKAN_HPP_NODISCARD" : "";
   std::string      returnType =
@@ -9828,9 +9825,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandStandard( std::string c
   }
 }
 
-std::pair<std::string, std::string>
+std::pair<std::string, std::string> VulkanHppGenerator::generateRAIIHandleConstructor( std::pair<std::string, HandleData> const &         handle,
-  VulkanHppGenerator::generateRAIIHandleConstructor( std::pair<std::string, HandleData> const &                             handle,
+                                                                                       std::map<std::string, CommandData>::const_iterator constructorIt,
-                                                     std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator constructorIt,
                                                                                        std::string const &                                enter,
                                                                                        std::string const &                                leave ) const
 {
@@ -9973,7 +9969,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorArgument( ParamData
 }
 
 std::string VulkanHppGenerator::generateRAIIHandleConstructorArguments( std::pair<std::string, HandleData> const &         handle,
-                                                                        std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator constructorIt,
+                                                                        std::map<std::string, CommandData>::const_iterator constructorIt,
                                                                         bool                                               singular,
                                                                         bool                                               takesOwnership ) const
 {
@@ -10267,7 +10263,7 @@ std::pair<std::string, std::string> VulkanHppGenerator::generateRAIIHandleConstr
 }
 
 std::string VulkanHppGenerator::generateRAIIHandleConstructorByCall( std::pair<std::string, HandleData> const &         handle,
-                                                                     std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator constructorIt,
+                                                                     std::map<std::string, CommandData>::const_iterator constructorIt,
                                                                      std::string const &                                enter,
                                                                      std::string const &                                leave,
                                                                      bool                                               isPlural,
@@ -13632,6 +13628,18 @@ bool VulkanHppGenerator::handleRemovalType( std::string const & type, std::vecto
   return removed;
 }
 
+bool VulkanHppGenerator::hasArrayConstructor(HandleData const& handleData) const
+{
+  for ( auto constructorIt : handleData.constructorIts )
+  {
+    if (!determineVectorParams(constructorIt->second.params).empty())
+    {
+      return true;
+    }
+  }
+  return false;
+}
+
 bool VulkanHppGenerator::hasLen( MemberData const & memberData, std::vector<MemberData> const & members ) const
 {
   return ( !memberData.lenMembers.empty() &&
@@ -17383,6 +17391,8 @@ int main( int argc, char const ** argv )
   {
     std::cout << "VulkanHppGenerator: failed to determine clang_format version with error <" << ret << ">\n";
   }
+#else
+  std::cout << "VulkanHppGenerator: could not find clang-format. The generated files will not be formatted accordingly.\n";
 #endif
 
   tinyxml2::XMLDocument doc;
@@ -17399,26 +17409,27 @@ int main( int argc, char const ** argv )
     std::cout << "VulkanHppGenerator: Parsing " << filename << std::endl;
     VulkanHppGenerator generator( doc, api );
 
-    generator.generateHppFile();
-    generator.generateEnumsHppFile();
-    generator.generateExtensionInspectionFile();
-    generator.generateFormatTraitsHppFile();
-    generator.prepareVulkanFuncs();
-    generator.generateFuncsHppFile();
-    generator.generateHandlesHppFile();
-    generator.generateHashHppFile();
     generator.prepareRAIIHandles();
-    generator.generateMacrosFile();
-    generator.generateRAIIHppFile();
-    generator.generateSharedHppFile();
-    generator.generateStaticAssertionsHppFile();
-    generator.generateStructsHppFile();
-    generator.generateToStringHppFile();
-    generator.generateCppModuleFile();
 
-#if !defined( CLANG_FORMAT_EXECUTABLE )
+    std::vector<std::future<void>> generateFutures;
-    std::cout << "VulkanHppGenerator: could not find clang-format. The generated files will not be formatted accordingly.\n";
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateCppModuleFile, &generator ) );
-#endif
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateHppFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateEnumsHppFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateExtensionInspectionFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateFormatTraitsHppFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateFuncsHppFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateHandlesHppFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateHashHppFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateMacrosFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateSharedHppFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateStaticAssertionsHppFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateStructsHppFile, &generator ) );
+    generateFutures.emplace_back( std::async( &VulkanHppGenerator::generateToStringHppFile, &generator ) );
+    std::ranges::for_each( generateFutures, []( auto & generatorFuture ) { generatorFuture.wait(); } );
+
+    // this modifies the generator data and needs to be done after all the other generations are done
+    generator.distributeSecondLevelCommands();
+    generator.generateRAIIHppFile();
   }
   catch ( std::exception const & e )
   {

VulkanHppGenerator.hpp

@@ -88,6 +88,13 @@ class VulkanHppGenerator
 public:
   VulkanHppGenerator( tinyxml2::XMLDocument const & document, std::string const & api );
 
+  VulkanHppGenerator()                                             = delete;
+  VulkanHppGenerator( VulkanHppGenerator const & rhs )             = delete;
+  VulkanHppGenerator( VulkanHppGenerator && rhs )                  = delete;
+  VulkanHppGenerator & operator=( VulkanHppGenerator const & rhs ) = delete;
+  VulkanHppGenerator & operator=( VulkanHppGenerator && rhs )      = delete;
+
+  void distributeSecondLevelCommands();
   void generateEnumsHppFile() const;
   void generateExtensionInspectionFile() const;
   void generateFormatTraitsHppFile() const;
@@ -103,7 +110,6 @@ public:
   void generateToStringHppFile() const;
   void generateCppModuleFile() const;
   void prepareRAIIHandles();
-  void prepareVulkanFuncs();
 
   struct MacroData
   {
@@ -564,7 +570,6 @@ private:
   std::set<size_t>                                determineVoidPointerParams( std::vector<ParamData> const & params ) const;
   void                                            distributeEnumExtends();
   void                                            distributeEnumValueAliases();
-  void                                            distributeSecondLevelCommands( std::set<std::string> const & specialFunctions );
   void                                            distributeRequirements();
   void                                            distributeRequirements( std::vector<RequireData> const & requireData, std::string const & requiredBy );
   void                                            distributeStructAliases();
@@ -593,7 +598,8 @@ private:
                                                                                 bool                                      definition,
                                                                                 CommandFlavourFlags                       flavourFlags,
                                                                                 bool                                      withDispatcher ) const;
-  std::string generateArgumentListStandard( std::vector<ParamData> const & params, std::set<size_t> const & skippedParams, bool withDispatcher ) const;
+  std::string
+    generateArgumentListStandard( std::vector<ParamData> const & params, std::set<size_t> const & skippedParams, bool definition, bool withDispatcher ) const;
   std::string generateArgumentTemplates( std::vector<ParamData> const &            params,
                                          std::vector<size_t> const &               returnParams,
                                          std::map<size_t, VectorParamData> const & vectorParams,
@@ -926,7 +932,7 @@ private:
   std::pair<std::string, std::string> generateRAIIHandleConstructors( std::pair<std::string, HandleData> const & handle ) const;
   std::string generateRAIIHandleConstructorArgument( ParamData const & param, bool definition, bool singular, bool takesOwnership ) const;
   std::string generateRAIIHandleConstructorArguments( std::pair<std::string, HandleData> const &         handle,
-                                                      std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator constructorIt,
+                                                      std::map<std::string, CommandData>::const_iterator constructorIt,
                                                       bool                                               singular,
                                                       bool                                               takesOwnership ) const;
   std::string generateRAIIHandleConstructorInitializationList( std::pair<std::string, HandleData> const &         handle,
@@ -1047,6 +1053,7 @@ private:
   bool                                handleRemovalCommand( std::string const & command, std::vector<RequireData> & requireData );
   void                                handleRemovals();
   bool                                handleRemovalType( std::string const & type, std::vector<RequireData> & requireData );
+  bool                                hasArrayConstructor( HandleData const & handleData ) const;
   bool                                hasLen( MemberData const & md, std::vector<MemberData> const & members ) const;
   bool                                hasParentHandle( std::string const & handle, std::string const & parent ) const;
   bool isConstructorCandidate( std::pair<std::string, VulkanHppGenerator::CommandData> const & command, std::string const & handleType ) const;

XMLHelper.hpp

@@ -18,6 +18,7 @@
 #include <fstream>
 #include <iostream>
 #include <map>
+#include <mutex>
 #include <regex>
 #include <set>
 #include <string>
@@ -56,6 +57,21 @@ std::string                                      trimEnd( std::string const & in
 std::string                                      trimStars( std::string const & input );
 void                                             writeToFile( std::string const & str, std::string const & fileName );
 
+class SyncedMessageHandler
+{
+public:
+  void message( std::string const & m )
+  {
+    std::lock_guard<std::mutex> guard( m_messageMutex );
+    std::cout << m;
+  }
+
+private:
+  std::mutex m_messageMutex;
+};
+
+SyncedMessageHandler messager;
+
 struct TypeInfo
 {
   std::string compose( std::string const & nameSpace, std::string const & prefix_ = "Vk" ) const
@@ -209,7 +225,8 @@ inline void checkElements( int                                               lin
     // check: r.second (means: required excactly once) => (encouteredIt->second == 1)
     checkForError( !r.second || ( encounteredIt->second == 1 ),
                    line,
-                   "required element <" + r.first + "> is supposed to be listed exactly once, but is listed " + std::to_string( encounteredIt->second ) + " times" );
+                   "required element <" + r.first + "> is supposed to be listed exactly once, but is listed " + std::to_string( encounteredIt->second ) +
+                     " times" );
   }
 }
 
@@ -548,12 +565,12 @@ void writeToFile( std::string const & str, std::string const & fileName )
   ofs.close();
 
 #if defined( CLANG_FORMAT_EXECUTABLE )
-  std::cout << "VulkanHppGenerator: Formatting " << fileName << " ..." << std::endl;
+  messager.message( "VulkanHppGenerator: Formatting " + fileName + " ...\n" );
   const std::string commandString = "\"" CLANG_FORMAT_EXECUTABLE "\" -i --style=file " + fileName;
   const int         ret           = std::system( commandString.c_str() );
   if ( ret != 0 )
   {
-    std::cout << "VulkanHppGenerator: failed to format file " << fileName << " with error <" << ret << ">\n";
+    messager.message( "VulkanHppGenerator: failed to format file " + fileName + " with error <" + std::to_string( ret ) + ">\n" );
   }
 #endif
 }

vulkan/vulkan_handles.hpp

@@ -11445,14 +11445,14 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+    VULKAN_HPP_NODISCARD Result setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                                                 uint64_t                              objectHandle,
                                                 VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                                                 uint64_t                              data,
                                                 Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #else
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<void>::type setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+    typename ResultValueType<void>::type setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                                                          uint64_t                              objectHandle,
                                                          VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                                                          uint64_t                              data,
@@ -11460,14 +11460,14 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+    void getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                          uint64_t                              objectHandle,
                          VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                          uint64_t *                            pData,
                          Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+    VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                                                   uint64_t                              objectHandle,
                                                   VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                                                   Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
@@ -13907,14 +13907,14 @@ namespace VULKAN_HPP_NAMESPACE
 
 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+    VULKAN_HPP_NODISCARD Result setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                                                    uint64_t                              objectHandle,
                                                    VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                                                    uint64_t                              data,
                                                    Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #else
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+    typename ResultValueType<void>::type setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                                                             uint64_t                              objectHandle,
                                                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                                                             uint64_t                              data,
@@ -13922,14 +13922,14 @@ namespace VULKAN_HPP_NAMESPACE
 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+    void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                             uint64_t                              objectHandle,
                             VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                             uint64_t *                            pData,
                             Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+    VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                                                      uint64_t                              objectHandle,
                                                      VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                                                      Dispatch const & d                    VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
@@ -17277,7 +17277,7 @@ namespace VULKAN_HPP_NAMESPACE
 
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
-                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
+                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
                                 uint64_t                                       object,
                                 size_t                                         location,
                                 int32_t                                        messageCode,
@@ -17287,7 +17287,7 @@ namespace VULKAN_HPP_NAMESPACE
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
-                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
+                                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
                                 uint64_t                                       object,
                                 size_t                                         location,
                                 int32_t                                        messageCode,

vulkan/vulkan_raii.hpp

@@ -3117,7 +3117,7 @@ namespace VULKAN_HPP_NAMESPACE
         VULKAN_HPP_RAII_CREATE_NOEXCEPT;
 
       void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
-                                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
+                                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
                                   uint64_t                                       object,
                                   size_t                                         location,
                                   int32_t                                        messageCode,
@@ -4059,12 +4059,12 @@ namespace VULKAN_HPP_NAMESPACE
                                VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
         VULKAN_HPP_RAII_CREATE_NOEXCEPT;
 
-      void setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+      void setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                            uint64_t                              objectHandle,
                            VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                            uint64_t                              data ) const;
 
-      VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+      VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                                                     uint64_t                              objectHandle,
                                                     VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT;
 
@@ -4585,12 +4585,12 @@ namespace VULKAN_HPP_NAMESPACE
                                       Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 
-      void setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+      void setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                               uint64_t                              objectHandle,
                               VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
                               uint64_t                              data ) const;
 
-      VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType_,
+      VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType      objectType,
                                                        uint64_t                              objectHandle,
                                                        VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT;