Address PR comments. Minor Fixes

Author: marantic-amd

projects/rocprofiler-systems/source/lib/core/common_types.hpp

@@ -0,0 +1,86 @@
+// MIT License
+//
+// Copyright (c) 2025 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace rocprofsys
+{
+/**
+ * @brief Structure for function/region argument information
+ *
+ * Represents metadata about function or region arguments including
+ * their position, type, name, and value information.
+ */
+struct arg_info
+{
+    uint32_t    arg_number = 0;   ///< Argument position/index
+    std::string arg_type   = {};  ///< Argument type (e.g., "int", "float*")
+    std::string arg_name   = {};  ///< Argument name
+    std::string arg_value  = {};  ///< Argument value as string
+};
+
+using function_args_t = std::vector<arg_info>;
+
+inline function_args_t
+process_arguments_string(const std::string& arg_str)
+{
+    function_args_t   args;
+    const std::string delimiter = ";;";
+
+    auto split = [](const std::string& str, const std::string& _delimiter) {
+        std::vector<std::string> tokens;
+        size_t                   start = 0;
+        size_t                   end   = str.find(_delimiter);
+
+        while(end != std::string::npos)
+        {
+            tokens.push_back(str.substr(start, end - start));
+            start = end + _delimiter.length();
+            end   = str.find(_delimiter, start);
+        }
+
+        return tokens;
+    };
+
+    auto tokens = split(arg_str, delimiter);
+
+    // Ensure the number of tokens is a multiple of 4
+    if(tokens.size() % 4 != 0)
+    {
+        throw std::invalid_argument("Malformed argument string.");
+    }
+
+    for(auto it = tokens.begin(); it != tokens.end(); it += 4)
+    {
+        arg_info arg = { static_cast<uint32_t>(std::stoi(*it)), *(it + 1), *(it + 2),
+                         *(it + 3) };
+        args.push_back(arg);
+    }
+
+    return args;
+}
+
+}  // namespace rocprofsys

projects/rocprofiler-systems/source/lib/core/trace_cache/CMakeLists.txt

@@ -38,6 +38,7 @@ set(trace_cache_headers
     ${CMAKE_CURRENT_LIST_DIR}/rocpd_post_processing.hpp
     ${CMAKE_CURRENT_LIST_DIR}/perfetto_post_processing.hpp
     ${CMAKE_CURRENT_LIST_DIR}/sample_type.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/common_types.hpp
 )
 
 target_sources(

projects/rocprofiler-systems/source/lib/core/trace_cache/cache_manager.cpp

@@ -156,18 +156,17 @@ cache_manager::post_process_bulk()
             shutdown();
         }
 
+        auto _cache_files = get_cache_files();
+
         if(get_use_rocpd() || get_caching_perfetto())
         {
             ROCPROFSYS_PRINT(
                 "Generating rocpd with collected data. This may take a while..\n");
 
-            auto _cache_files = get_cache_files();
-            
-            std::vector<std::thread> rocpd_threads;
-            ROCPROFSYS_SCOPED_SAMPLING_ON_CHILD_THREADS(false);
-
             if(get_caching_perfetto())
             {
+                perfetto_post_processing::initialize_perfetto();
+
                 for(const auto& [pid, files] : _cache_files)
                 {
                     if(!files.buff_storage.empty() && !files.metadata.empty())
@@ -203,12 +202,23 @@ cache_manager::post_process_bulk()
 
                         bool _perfetto_error = false;
                         _perfetto_post_processing.post_process(_perfetto_error);
+
+                        if(_perfetto_error)
+                        {
+                            ROCPROFSYS_WARNING(0,
+                                               "Perfetto trace generation failed for "
+                                               "process: %d\n",
+                                               pid);
+                        }
                     }
                 }
             }
 
             if(get_use_rocpd())
             {
+                std::vector<std::thread> rocpd_threads;
+                ROCPROFSYS_SCOPED_SAMPLING_ON_CHILD_THREADS(false);
+
                 rocpd_threads.emplace_back([this]() {
                     auto                  pid  = getpid();
                     auto                  ppid = get_root_process_id();
@@ -251,19 +261,14 @@ cache_manager::post_process_bulk()
                             _post_processing.register_parser_callback(_parser);
                             _post_processing.post_process_metadata();
                             _parser.consume_storage();
-                            std::remove(files.metadata.c_str());  // Remove metadata file
                         });
                     }
                 }
-            }
 
-            for(auto& thread : rocpd_threads)
-            {
-                thread.join();
-            }
-            if(get_caching_perfetto())
-            {
-                clear_cache_files();
+                for(auto& thread : rocpd_threads)
+                {
+                    thread.join();
+                }
             }
         }