Rename Omnitrace to ROCm Systems Profiler (#4)

The Omnitrace program is being renamed. 

Full name: "ROCm Systems Profiler"
Package name: "rocprofiler-systems"
Binary / Library names: "rocprof-sys-*"

---------
Co-authored-by: Xuan Chen <xuchen@amd.com>
Signed-off-by: David Galiffi <David.Galiffi@amd.com>

source/lib/rocprof-sys/library/causal/components/progress_point.cpp

@@ -0,0 +1,240 @@
+// MIT License
+//
+// Copyright (c) 2022-2024 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.
+
+#include "library/causal/components/progress_point.hpp"
+#include "core/common.hpp"
+#include "core/concepts.hpp"
+#include "core/debug.hpp"
+#include "core/timemory.hpp"
+#include "library/causal/experiment.hpp"
+#include "library/thread_data.hpp"
+
+#include <timemory/hash/types.hpp>
+#include <timemory/mpl/type_traits.hpp>
+#include <timemory/units.hpp>
+
+namespace rocprofsys
+{
+namespace causal
+{
+namespace component
+{
+namespace
+{
+using progress_allocator_t = tim::data::ring_buffer_allocator<progress_point>;
+using progress_map_t       = std::unordered_map<tim::hash_value_t, progress_point*>;
+
+auto&
+get_progress_map()
+{
+    using thread_data_t = thread_data<identity<progress_map_t>>;
+    static auto& _v     = thread_data_t::instance(construct_on_init{});
+    return _v;
+}
+
+progress_map_t&
+get_progress_map(int64_t _tid)
+{
+    return get_progress_map()->at(_tid);
+}
+
+auto&
+get_progress_allocator(int64_t _tid)
+{
+    return thread_data<progress_allocator_t>::instance(construct_on_thread{ _tid });
+}
+}  // namespace
+
+std::unordered_map<tim::hash_value_t, progress_point>
+progress_point::get_progress_points()
+{
+    auto _data = std::unordered_map<tim::hash_value_t, progress_point>{};
+    if(!get_progress_map()) return _data;
+    for(const auto& titr : *get_progress_map())
+    {
+        for(const auto& itr : titr)
+        {
+            if(itr.second)
+            {
+                auto& ditr = _data[itr.first];
+                ditr += *itr.second;
+                ditr.set_hash(itr.second->get_hash());
+                itr.second->set_value(0);
+            }
+        }
+    }
+    return _data;
+}
+
+std::string
+progress_point::label()
+{
+    return "progress_point";
+}
+
+std::string
+progress_point::description()
+{
+    return "Tracks progress point latency and throughput for causal profiling";
+}
+
+void
+progress_point::start()
+{
+    ++m_arrival;
+}
+
+void
+progress_point::stop()
+{
+    ++m_departure;
+}
+
+void
+progress_point::mark()
+{
+    ++m_delta;
+}
+
+void
+progress_point::set_value(int64_t _v)
+{
+    m_delta     = _v;
+    m_arrival   = _v;
+    m_departure = _v;
+}
+
+progress_point&
+progress_point::operator+=(const progress_point& _v)
+{
+    if(this != &_v)
+    {
+        m_delta += _v.m_delta;
+        m_arrival += _v.m_arrival;
+        m_departure += _v.m_departure;
+    }
+    return *this;
+}
+
+progress_point&
+progress_point::operator-=(const progress_point& _v)
+{
+    if(this != &_v)
+    {
+        m_delta -= _v.m_delta;
+        m_arrival -= _v.m_arrival;
+        m_departure -= _v.m_departure;
+    }
+    return *this;
+}
+
+bool
+progress_point::is_throughput_point() const
+{
+    return (m_delta != 0);
+}
+
+bool
+progress_point::is_latency_point() const
+{
+    return (m_arrival != 0 || m_departure != 0);
+}
+
+int64_t
+progress_point::get_delta() const
+{
+    return m_delta;
+}
+
+int64_t
+progress_point::get_arrival() const
+{
+    if(!is_latency_point()) return m_arrival;
+    // when it is a latency point, we want the difference to be greater than zero
+    return (m_arrival >= m_departure) ? (m_arrival + 1) : m_arrival;
+}
+
+int64_t
+progress_point::get_departure() const
+{
+    // if(!is_latency_point()) return m_departure;
+    // return (m_departure <= m_arrival) ? m_departure : (m_departure + 1);
+    return m_departure;
+}
+
+int64_t
+progress_point::get_latency_delta() const
+{
+    return (get_arrival() - get_departure());
+}
+
+int64_t
+progress_point::get_laps() const
+{
+    return std::max(get_delta(), get_latency_delta());
+}
+
+void
+progress_point::print(std::ostream& os) const
+{
+    os << tim::get_hash_identifier(m_hash) << " :: ";
+    tim::operation::base_printer<progress_point>(os, *this);
+}
+}  // namespace component
+}  // namespace causal
+}  // namespace rocprofsys
+
+namespace tim
+{
+namespace operation
+{
+namespace causal = rocprofsys::causal;
+
+void
+push_node<causal::component::progress_point>::operator()(type&        _obj, scope::config,
+                                                         hash_value_t _hash,
+                                                         int64_t      _tid) const
+{
+    auto itr = causal::component::get_progress_map(_tid).emplace(_hash, nullptr);
+    if(itr.second && !itr.first->second)
+    {
+        auto& _alloc = causal::component::get_progress_allocator(_tid);
+        auto* _val   = _alloc->allocate(1);
+        _alloc->construct(_val);
+        _val->set_hash(_hash);
+        itr.first->second = _val;
+    }
+    _obj.set_hash(_hash);
+    _obj.set_iterator(itr.first->second);
+}
+
+void
+pop_node<causal::component::progress_point>::operator()(type& _obj, int64_t) const
+{
+    auto* itr = _obj.get_iterator();
+    if(itr && !(_obj.get_is_invalid() || _obj.get_is_running()))
+    {
+        *itr += _obj;
+    }
+}
+}  // namespace operation
+}  // namespace tim