user can now convert vertices to ptrs and vice versa

Author: saschatommasone

plugins/clock_tree_extractor/include/clock_tree_extractor/clock_tree.h

@@ -78,6 +78,13 @@ namespace hal
 
             Result<igraph_integer_t> get_vertex_from_ptr( const void *ptr ) const;
 
+            Result<std::pair<const void *, PtrType>> get_ptr_from_vertex( const igraph_integer_t vertex ) const;
+
+            Result<std::vector<igraph_integer_t>> get_vertices_from_ptrs( const std::vector<const void *> &ptrs ) const;
+
+            Result<std::vector<std::pair<const void *, PtrType>>>
+            get_ptrs_from_vertices( const std::vector<igraph_integer_t> &vertices ) const;
+
             const std::vector<const Gate *> get_gates() const;
 
             const std::vector<const Net *> get_nets() const;

plugins/clock_tree_extractor/python/python_bindings.cpp

@@ -162,7 +162,84 @@ namespace hal
                     return result;
                 },
                 R"()" )
-            .def( "get_vertex_from_ptr", &cte::ClockTree::get_vertex_from_ptr, R"()" )
+            .def(
+                "get_vertex_from_ptr",
+                []( const cte::ClockTree &self, const void *ptr ) -> py::object {
+                    auto result = self.get_vertex_from_ptr( ptr );
+                    if( result.is_ok() )
+                    {
+                        return py::int_( result.get() );
+                    }
+                    log_error( "clock_tree_extractor", "{}", result.get_error().get() );
+                    return py::none();
+                },
+                py::arg( "ptr" ),
+                R"()" )
+            .def(
+                "get_ptr_from_vertex",
+                []( const cte::ClockTree &self, const igraph_integer_t vertex ) -> py::object {
+                    auto result = self.get_ptr_from_vertex( vertex );
+                    if( result.is_ok() )
+                    {
+                        auto [ptr, type] = result.get();
+                        if( type == cte::PtrType::GATE )
+                        {
+                            return py::cast( (const Gate *) ptr );
+                        }
+                        else if( type == cte::PtrType::NET )
+                        {
+                            return py::cast( (const Net *) ptr );
+                        }
+                        return py::none();
+                    }
+                    log_error( "clock_tree_extractor", "{}", result.get_error().get() );
+                    return py::none();
+                },
+                py::arg( "vertex" ),
+                R"()" )
+            .def(
+                "get_vertices_from_ptrs",
+                []( const cte::ClockTree &self, const std::vector<const void *> &ptrs ) -> py::list {
+                    auto result = self.get_vertices_from_ptrs( ptrs );
+                    if( result.is_ok() )
+                    {
+                        return py::cast( result.get() );
+                    }
+                    log_error( "clock_tree_extractor", "{}", result.get_error().get() );
+                    return py::none();
+                },
+                py::arg( "ptrs" ),
+                R"()" )
+            .def(
+                "get_ptrs_from_vertices",
+                []( const cte::ClockTree &self, const std::vector<igraph_integer_t> &vertices ) -> py::list {
+                    auto res = self.get_ptrs_from_vertices( vertices );
+                    if( res.is_ok() )
+                    {
+                        py::list result;
+                        for( const auto &[ptr, type] : res.get() )
+                        {
+                            if( type == cte::PtrType::GATE )
+                            {
+                                result.append( py::cast( (const Gate *) ptr ) );
+                            }
+                            else if( type == cte::PtrType::NET )
+                            {
+                                result.append( py::cast( (const Net *) ptr ) );
+                            }
+                            else
+                            {
+                                log_error( "clock_tree_extractor", "unknown ptr type" );
+                                return py::none();
+                            }
+                        }
+                        return result;
+                    }
+                    log_error( "clock_tree_extractor", "{}", res.get_error().get() );
+                    return py::none();
+                },
+                py::arg( "vertices" ),
+                R"()" )
             .def( "get_gates", &cte::ClockTree::get_gates, R"()" )
             .def( "get_nets", &cte::ClockTree::get_nets, R"()" )
             .def( "get_netlist", &cte::ClockTree::get_netlist, R"()" );

plugins/clock_tree_extractor/src/clock_tree.cpp

@@ -195,6 +195,9 @@ namespace hal
                 }
                 else if( clk->get_num_of_sources() == 0 )
                 {
+                    log_warning( "clock_tree_extractor",
+                                 "unrouted clock net with ID {} ignored",
+                                 std::to_string( clk->get_id() ) );
                     continue;
                 }
 
@@ -614,6 +617,55 @@ namespace hal
             return OK( it->second );
         }
 
+        Result<std::pair<const void *, PtrType>> ClockTree::get_ptr_from_vertex( const igraph_integer_t vertex ) const
+        {
+            auto it = m_vertices_to_ptrs.find( vertex );
+            if( it == m_vertices_to_ptrs.end() )
+            {
+                return ERR( "object is not part of clock tree" );
+            }
+
+            return OK( std::make_pair( it->second, m_ptrs_to_types.at( it->second ) ) );
+        }
+
+        Result<std::vector<igraph_integer_t>>
+        ClockTree::get_vertices_from_ptrs( const std::vector<const void *> &ptrs ) const
+        {
+            std::vector<igraph_integer_t> result;
+
+            for( const void *ptr : ptrs )
+            {
+                auto res = get_vertex_from_ptr( ptr );
+                if( res.is_error() )
+                {
+                    return ERR( res.get_error().get() );
+                }
+
+                result.push_back( res.get() );
+            }
+
+            return OK( result );
+        }
+
+        Result<std::vector<std::pair<const void *, PtrType>>>
+        ClockTree::get_ptrs_from_vertices( const std::vector<igraph_integer_t> &vertices ) const
+        {
+            std::vector<std::pair<const void *, PtrType>> result;
+
+            for( const igraph_integer_t vertex : vertices )
+            {
+                auto res = get_ptr_from_vertex( vertex );
+                if( res.is_error() )
+                {
+                    return ERR( res.get_error().get() );
+                }
+
+                result.push_back( res.get() );
+            }
+
+            return OK( result );
+        }
+
         const std::vector<const Gate *> ClockTree::get_gates() const
         {
             std::vector<const Gate *> result;