SWDEV-387026: using gethostid instead of depending on libsystemd

Change-Id: If576eec4abee1a52dfe7cc5bce507420bc8a4d07


[ROCm/rocprofiler commit: 05f2ef97f9]

projects/rocprofiler/README.md

@@ -91,7 +91,6 @@ ROCProfilerV2 is a newly developed design for AMD’s tooling infrastructure tha
 - Gtest Development Package (Ubuntu: libgtest-dev)
 - Cppheaderparser Python 3 Package
 - Lxml Python 3 Package
-- Systemd Development Package (Ubuntu: libsystemd-dev)
 
 ### Build
 

projects/rocprofiler/plugin/att/CMakeLists.txt

@@ -45,7 +45,7 @@ target_link_options(
   att_plugin PRIVATE
   -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exportmap
   -Wl,--no-undefined)
-target_link_libraries(att_plugin PRIVATE ${ROCPROFILER_TARGET} systemd
+target_link_libraries(att_plugin PRIVATE ${ROCPROFILER_TARGET}
                                          hsa-runtime64::hsa-runtime64 stdc++fs)
 
 install(TARGETS att_plugin

projects/rocprofiler/plugin/ctf/CMakeLists.txt

@@ -48,7 +48,6 @@ target_link_options(ctf_plugin PRIVATE
 target_link_libraries(ctf_plugin PRIVATE
                       ${ROCPROFILER_TARGET}
                       hsa-runtime64::hsa-runtime64
-                      systemd
                       stdc++fs
                       dl)
 install(TARGETS ctf_plugin LIBRARY

projects/rocprofiler/plugin/file/CMakeLists.txt

@@ -37,7 +37,7 @@ target_include_directories(file_plugin PRIVATE ${PROJECT_SOURCE_DIR}/inc ${PROJE
 
 target_link_options(file_plugin PRIVATE -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exportmap -Wl,--no-undefined)
 
-target_link_libraries(file_plugin PRIVATE ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64 systemd stdc++fs amd_comgr dl)
+target_link_libraries(file_plugin PRIVATE ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64 stdc++fs amd_comgr dl)
 
 install(TARGETS file_plugin LIBRARY
   DESTINATION ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}

projects/rocprofiler/plugin/perfetto/CMakeLists.txt

@@ -20,7 +20,7 @@ target_include_directories(perfetto_plugin
 target_link_options(perfetto_plugin
         PRIVATE -Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exportmap -Wl,--no-undefined)
 
-target_link_libraries(perfetto_plugin PRIVATE ${ROCPROFILER_TARGET} Threads::Threads systemd stdc++fs amd_comgr)
+target_link_libraries(perfetto_plugin PRIVATE ${ROCPROFILER_TARGET} Threads::Threads stdc++fs amd_comgr)
 
 install(TARGETS perfetto_plugin LIBRARY
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}

projects/rocprofiler/plugin/perfetto/perfetto.cpp

@@ -42,7 +42,6 @@
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <systemd/sd-id128.h>
 
 #include "perfetto_sdk/sdk/perfetto.h"
 #include "rocprofiler_plugin.h"
@@ -152,26 +151,18 @@ class perfetto_plugin_t {
     tracing_session_->Setup(trace_cfg, file_descriptor_);
     tracing_session_->StartBlocking();
 
-
-    hostname_[1023] = '\0';
-    gethostname(hostname_, 1023);
-    sd_id128_t ret;
-    char machine_id[SD_ID128_STRING_MAX];
-    [[maybe_unused]] int status = sd_id128_get_machine(&ret);
-    assert(status == 0 && "Error: Couldn't get machine id!");
-    if (sd_id128_to_string(ret, machine_id)) machine_id_ = std::hash<std::string>{}(machine_id);
-
+    machine_id = gethostid();
     {
       std::lock_guard<std::mutex> lock(thread_tracks_lock_);
       process_name =
           perfetto::ProcessTrack::Current().Serialize().mutable_process()->process_name();
       auto process_track_desc = perfetto::ProcessTrack::Current().Serialize();
       uint64_t track_id =
-          track_counter_.fetch_add((1 + machine_id_) * GetPid(), std::memory_order_acquire);
+          track_counter_.fetch_add((1 + machine_id) * GetPid(), std::memory_order_acquire);
       for (uint64_t tid : track_ids_used_) {
         while (track_id == tid) {
           track_id =
-              track_counter_.fetch_add((1 + machine_id_) * GetPid(), std::memory_order_acquire);
+              track_counter_.fetch_add((1 + machine_id) * GetPid(), std::memory_order_acquire);
         }
       }
       std::string thread_track_str =
@@ -235,14 +226,14 @@ class perfetto_plugin_t {
         /* Create a new perfetto::Track (Sub-Track) */
         device_track_it =
             device_tracks_
-                .emplace(device_id, perfetto::ProcessTrack::Global(((device_id + 1) * machine_id_)))
+                .emplace(device_id, perfetto::ProcessTrack::Global(((device_id + 1) * machine_id)))
                 .first;
         auto gpu_desc = device_track_it->second.Serialize();
         gpu_desc.mutable_process()->set_pid(device_id);
         std::string gpu_str = rocmtools::string_printf("Node: %s Device:", hostname_);
         gpu_desc.mutable_process()->set_process_name(gpu_str);
         perfetto::TrackEvent::SetTrackDescriptor(device_track_it->second, gpu_desc);
-        track_ids_used_.emplace_back(device_id + 1 + machine_id_);
+        track_ids_used_.emplace_back(device_id + 1 + machine_id);
       }
     }
     auto& gpu_track = device_track_it->second;
@@ -258,7 +249,7 @@ class perfetto_plugin_t {
                              .emplace(gpu_queue_id.first,
                                       perfetto::Track((profiler_record.queue_id.handle + 1 +
                                                        profiler_record.gpu_id.handle) *
-                                                          QUEUE_CONSTANT * machine_id_ * GetPid(),
+                                                          QUEUE_CONSTANT * machine_id * GetPid(),
                                                       gpu_track))
                              .first;
 
@@ -268,7 +259,7 @@ class perfetto_plugin_t {
         queue_desc.set_name(queue_str);
         perfetto::TrackEvent::SetTrackDescriptor(queue_track_it->second, queue_desc);
       }
-      track_ids_used_.emplace_back(profiler_record.queue_id.handle + machine_id_ + 1 +
+      track_ids_used_.emplace_back(profiler_record.queue_id.handle + machine_id + 1 +
                                    profiler_record.gpu_id.handle);
     }
     auto& queue_track = queue_track_it->second;
@@ -298,7 +289,7 @@ class perfetto_plugin_t {
 
     auto get_counter_track_fn = [&](std::string counter_name) {
       std ::string counter_track_id =
-          std::to_string(machine_id_) + std::to_string(GetPid()) + counter_name;
+          std::to_string(machine_id) + std::to_string(GetPid()) + counter_name;
       std::pair<int, std::string> gpu_counter_track_id = std::make_pair(device_id, counter_name);
       std::unordered_map<std::string, perfetto::CounterTrack>::iterator counters_track_it;
       {
@@ -373,14 +364,14 @@ class perfetto_plugin_t {
           device_track_it =
               device_tracks_
                   .emplace(device_id,
-                           perfetto::ProcessTrack::Global(((device_id + 1) * machine_id_)))
+                           perfetto::ProcessTrack::Global(((device_id + 1) * machine_id)))
                   .first;
           auto gpu_desc = device_track_it->second.Serialize();
           gpu_desc.mutable_process()->set_pid(device_id);
           std::string gpu_str = rocmtools::string_printf("Node: %s Device:", hostname_);
           gpu_desc.mutable_process()->set_process_name(gpu_str);
           perfetto::TrackEvent::SetTrackDescriptor(device_track_it->second, gpu_desc);
-          track_ids_used_.emplace_back(1 + machine_id_ + device_id);
+          track_ids_used_.emplace_back(1 + machine_id + device_id);
         }
       }
     } else {
@@ -388,11 +379,11 @@ class perfetto_plugin_t {
       thread_track_it = thread_tracks_.find(thread_id);
       if (thread_track_it == thread_tracks_.end()) {
         uint64_t track_id =
-            track_counter_.fetch_add((1 + machine_id_) * GetPid(), std::memory_order_acquire);
+            track_counter_.fetch_add((1 + machine_id) * GetPid(), std::memory_order_acquire);
         for (uint64_t tid : track_ids_used_) {
           while (track_id == tid) {
             track_id =
-                track_counter_.fetch_add((1 + machine_id_) * GetPid(), std::memory_order_acquire);
+                track_counter_.fetch_add((1 + machine_id) * GetPid(), std::memory_order_acquire);
           }
         }
         thread_track_it =
@@ -416,10 +407,10 @@ class perfetto_plugin_t {
           if (roctx_track_it == roctx_tracks_.end()) {
             /* Create a new perfetto::Track */
             uint64_t track_id =
-                track_counter_.fetch_add((1 + machine_id_) * GetPid(), std::memory_order_acquire);
+                track_counter_.fetch_add((1 + machine_id) * GetPid(), std::memory_order_acquire);
             for (uint64_t tid : track_ids_used_) {
               while (track_id == tid) {
-                track_id = track_counter_.fetch_add((1 + machine_id_) * GetPid(),
+                track_id = track_counter_.fetch_add((1 + machine_id) * GetPid(),
                                                     std::memory_order_acquire);
               }
             }
@@ -482,10 +473,10 @@ class perfetto_plugin_t {
           if (hsa_track_it == hsa_tracks_.end()) {
             /* Create a new perfetto::Track */
             uint64_t track_id =
-                track_counter_.fetch_add((1 + machine_id_) * GetPid(), std::memory_order_acquire);
+                track_counter_.fetch_add((1 + machine_id) * GetPid(), std::memory_order_acquire);
             for (uint64_t tid : track_ids_used_) {
               while (track_id == tid) {
-                track_id = track_counter_.fetch_add((1 + machine_id_) * GetPid(),
+                track_id = track_counter_.fetch_add((1 + machine_id) * GetPid(),
                                                     std::memory_order_acquire);
               }
             }
@@ -522,10 +513,10 @@ class perfetto_plugin_t {
           if (hip_track_it == hip_tracks_.end()) {
             /* Create a new perfetto::Track */
             uint64_t track_id =
-                track_counter_.fetch_add((1 + machine_id_) * GetPid(), std::memory_order_acquire);
+                track_counter_.fetch_add((1 + machine_id) * GetPid(), std::memory_order_acquire);
             for (uint64_t tid : track_ids_used_) {
               while (track_id == tid) {
-                track_id = track_counter_.fetch_add((1 + machine_id_) * GetPid(),
+                track_id = track_counter_.fetch_add((1 + machine_id) * GetPid(),
                                                     std::memory_order_acquire);
               }
             }
@@ -602,7 +593,7 @@ class perfetto_plugin_t {
           stream_track_it = stream_tracks_.find(stream_id);
           if (stream_track_it == stream_tracks_.end()) {
             /* Create a new perfetto::Track */
-            uint64_t track_id = ((1 + stream_id + tracer_record.agent_id.handle) * machine_id_ *
+            uint64_t track_id = ((1 + stream_id + tracer_record.agent_id.handle) * machine_id *
                                  STREAM_CONSTANT * GetPid());
             stream_track_it =
                 stream_tracks_.emplace(stream_id, perfetto::Track(track_id, gpu_track)).first;
@@ -612,7 +603,7 @@ class perfetto_plugin_t {
                 rocmtools::string_printf("Process ID: %lu Stream %d", GetPid(), stream_id);
             stream_desc.set_name(stream_str);
             perfetto::TrackEvent::SetTrackDescriptor(stream_track_it->second, stream_desc);
-            track_ids_used_.emplace_back(1 + machine_id_ + tracer_record.agent_id.handle);
+            track_ids_used_.emplace_back(1 + machine_id + tracer_record.agent_id.handle);
           }
         }
         auto& stream_track = stream_track_it->second;
@@ -656,7 +647,7 @@ class perfetto_plugin_t {
           if (queue_track_it == queue_tracks_.end()) {
             /* Create a new perfetto::Track */
             uint64_t track_id =
-                ((1 + tracer_record.queue_id.handle + tracer_record.agent_id.handle) * machine_id_ *
+                ((1 + tracer_record.queue_id.handle + tracer_record.agent_id.handle) * machine_id *
                  QUEUE_CONSTANT * GetPid());
             queue_track_it =
                 queue_tracks_.emplace(gpu_queue_id.first, perfetto::Track(track_id, gpu_track))
@@ -668,7 +659,7 @@ class perfetto_plugin_t {
             queue_desc.set_name(queue_str);
             perfetto::TrackEvent::SetTrackDescriptor(queue_track_it->second, queue_desc);
           }
-          track_ids_used_.emplace_back(tracer_record.queue_id.handle + machine_id_ + 1 +
+          track_ids_used_.emplace_back(tracer_record.queue_id.handle + machine_id + 1 +
                                        tracer_record.agent_id.handle);
         }
         auto& queue_track = queue_track_it->second;
@@ -756,7 +747,7 @@ class perfetto_plugin_t {
       stream_tracks_lock_, counter_tracks_lock_;
 
   char hostname_[1024];
-  uint64_t machine_id_;
+  uint64_t machine_id;
 
   std::ofstream stream_;
 };

projects/rocprofiler/plugin/utils.h

@@ -27,7 +27,6 @@
 #include <unistd.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
-#include <systemd/sd-id128.h>
 
 #include <cassert>
 #include <cstdint>
@@ -50,14 +49,7 @@ namespace {
 }
 
 [[maybe_unused]] uint64_t GetMachineID() {
-  char hostname[1023] = "\0";
-  gethostname(hostname, 1023);
-  sd_id128_t ret;
-  char machine_id[SD_ID128_STRING_MAX];
-  [[maybe_unused]] int status = sd_id128_get_machine(&ret);
-  assert(status == 0 && "Error: Couldn't get machine id!");
-  if (sd_id128_to_string(ret, machine_id)) return std::hash<std::string>{}(machine_id);
-  return std::rand();
+  return gethostid();
 }
 
 }  // namespace

projects/rocprofiler/samples/CMakeLists.txt

@@ -52,7 +52,7 @@ file(GLOB ROCPROFILER_UTIL_SRC_FILES ${PROJECT_SOURCE_DIR}/src/utils/helper.cpp)
 set_source_files_properties(profiler/application_replay_sample.cpp PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
 hip_add_executable(profiler_application_replay profiler/application_replay_sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
 target_include_directories(profiler_application_replay PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
-target_link_libraries(profiler_application_replay PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+target_link_libraries(profiler_application_replay PRIVATE ${ROCPROFILER_TARGET} amd_comgr)
 target_link_options(profiler_application_replay PRIVATE "-Wl,--build-id=md5")
 add_dependencies(samples profiler_application_replay)
 install(TARGETS profiler_application_replay RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
@@ -61,7 +61,7 @@ install(TARGETS profiler_application_replay RUNTIME DESTINATION ${CMAKE_INSTALL_
 set_source_files_properties(profiler/kernel_replay_sample.cpp PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
 hip_add_executable(profiler_kernel_replay profiler/kernel_replay_sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
 target_include_directories(profiler_kernel_replay PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
-target_link_libraries(profiler_kernel_replay PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+target_link_libraries(profiler_kernel_replay PRIVATE ${ROCPROFILER_TARGET} amd_comgr)
 target_link_options(profiler_kernel_replay PRIVATE "-Wl,--build-id=md5")
 add_dependencies(samples profiler_kernel_replay)
 install(TARGETS profiler_kernel_replay RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
@@ -71,7 +71,7 @@ set_source_files_properties(profiler/user_replay_sample.cpp PROPERTIES HIP_SOURC
 hip_add_executable(profiler_user_replay profiler/user_replay_sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
 target_include_directories(profiler_user_replay PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
 target_link_options(profiler_user_replay PRIVATE "-Wl,--build-id=md5")
-target_link_libraries(profiler_user_replay PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+target_link_libraries(profiler_user_replay PRIVATE ${ROCPROFILER_TARGET} amd_comgr)
 add_dependencies(samples profiler_user_replay)
 install(TARGETS profiler_user_replay RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
 
@@ -79,7 +79,7 @@ install(TARGETS profiler_user_replay RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROO
 set_source_files_properties(profiler/device_profiling_sample.cpp PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
 hip_add_executable(profiler_device_profiling profiler/device_profiling_sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
 target_include_directories(profiler_device_profiling PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
-target_link_libraries(profiler_device_profiling PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+target_link_libraries(profiler_device_profiling PRIVATE ${ROCPROFILER_TARGET} amd_comgr)
 target_link_options(profiler_device_profiling PRIVATE "-Wl,--build-id=md5")
 add_dependencies(samples profiler_device_profiling)
 install(TARGETS profiler_device_profiling RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
@@ -112,7 +112,7 @@ install(TARGETS xgmi_counters_sampler RUNTIME DESTINATION ${CMAKE_INSTALL_DATARO
 set_source_files_properties(tracer/sample.cpp PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
 hip_add_executable(tracer_hip_hsa tracer/sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
 target_include_directories(tracer_hip_hsa PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
-target_link_libraries(tracer_hip_hsa PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+target_link_libraries(tracer_hip_hsa PRIVATE ${ROCPROFILER_TARGET} amd_comgr)
 target_link_options(tracer_hip_hsa PRIVATE "-Wl,--build-id=md5")
 add_dependencies(samples tracer_hip_hsa)
 install(TARGETS tracer_hip_hsa RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)

projects/rocprofiler/samples/Makefile

@@ -3,7 +3,7 @@ ROCPROFILER_LIBS_PATH ?=$(ROCM_PATH)/lib
 ROCM_INCLUDES=-I$(ROCM_PATH)/include
 ROCPROFILER_INCLUDES=-I$(ROCM_PATH)/include/rocprofiler/
 
-LIBS=-L$(ROCPROFILER_LIBS_PATH) -lrocprofiler64 -lamd_comgr -lsystemd
+LIBS=-L$(ROCPROFILER_LIBS_PATH) -lrocprofiler64 -lamd_comgr
 
 ifndef ROCPROFILER_LIBS_PATH
 $(warning You may need to set ROCPROFILER_LIBS_PATH to the path of the rocprofiler source)

projects/rocprofiler/samples/common/common.h

@@ -9,7 +9,6 @@
 #include <sys/types.h>
 #include <unistd.h>
 #include <fcntl.h>
-#include <systemd/sd-id128.h>
 
 #include <cstdint>
 #include <cstdio>
@@ -61,14 +60,7 @@ __global__ void kernelF() { printf("\nKernel F\n"); }
 }
 
 [[maybe_unused]] uint64_t GetMachineID() {
-  char hostname[1023] = "\0";
-  gethostname(hostname, 1023);
-  sd_id128_t ret;
-  char machine_id[SD_ID128_STRING_MAX];
-  [[maybe_unused]] int status = sd_id128_get_machine(&ret);
-  assert(status == 0 && "Error: Couldn't get machine id!");
-  if (sd_id128_to_string(ret, machine_id)) return std::hash<std::string>{}(machine_id);
-  return std::rand();
+  return gethostid();
 }
 
 std::ofstream output_file;