[Commit-gnuradio] r4947 - gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime

[jcorgan]

Author: jcorgan
Date: 2007-04-11 11:45:48 -0600 (Wed, 11 Apr 2007)
New Revision: 4947

Modified:
   
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.cc
   
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.h
   
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.cc
   
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.h
Log:
Converted gr_simple_flowgraph to use gr_basic_blocks instead of gr_blocks, in 
order to be able to reuse this in gr_hier_block2.

Modified: 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.cc
===================================================================
--- 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.cc
     2007-04-11 07:29:05 UTC (rev 4946)
+++ 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.cc
     2007-04-11 17:45:48 UTC (rev 4947)
@@ -46,8 +46,8 @@
 }
 
 void
-gr_simple_flowgraph::connect(gr_block_sptr src_block, int src_port,
-                            gr_block_sptr dst_block, int dst_port)
+gr_simple_flowgraph::connect(gr_basic_block_sptr src_block, int src_port,
+                            gr_basic_block_sptr dst_block, int dst_port)
 {
   d_detail->connect(gr_endpoint(src_block, src_port), gr_endpoint(dst_block, 
dst_port));
 }

Modified: 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.h
===================================================================
--- 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.h
      2007-04-11 07:29:05 UTC (rev 4946)
+++ 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph.h
      2007-04-11 17:45:48 UTC (rev 4947)
@@ -34,12 +34,12 @@
 class gr_endpoint
 {
 private:
-  gr_block_sptr d_block;
+  gr_basic_block_sptr d_block;
   int d_port;
 
 public:
-  gr_endpoint(gr_block_sptr block, int port) { d_block = block; d_port = port; 
}
-  gr_block_sptr block() const { return d_block; }
+  gr_endpoint(gr_basic_block_sptr block, int port) { d_block = block; d_port = 
port; }
+  gr_basic_block_sptr block() const { return d_block; }
   int port() const { return d_port; }
 };    
 
@@ -66,8 +66,8 @@
 public:
   ~gr_simple_flowgraph();
 
-  void connect(gr_block_sptr src_block, int src_port,
-              gr_block_sptr dst_block, int dst_port);
+  void connect(gr_basic_block_sptr src_block, int src_port,
+              gr_basic_block_sptr dst_block, int dst_port);
   void validate();
 };
 

Modified: 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.cc
===================================================================
--- 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.cc
      2007-04-11 07:29:05 UTC (rev 4946)
+++ 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.cc
      2007-04-11 17:45:48 UTC (rev 4947)
@@ -102,7 +102,7 @@
 {
   d_blocks = calc_used_blocks();
 
-  for (gr_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {
+  for (gr_basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {
     std::vector<int> used_ports;
     int ninputs, noutputs;
 
@@ -120,7 +120,7 @@
 }
 
 std::vector<int>
-gr_simple_flowgraph_detail::calc_used_ports(gr_block_sptr block, bool 
check_inputs)
+gr_simple_flowgraph_detail::calc_used_ports(gr_basic_block_sptr block, bool 
check_inputs)
 {
   if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
     std::cout << "Calculating used " << (check_inputs ? "input " : "output ")
@@ -148,7 +148,7 @@
 }
 
 gr_edge_vector_t
-gr_simple_flowgraph_detail::calc_connections(gr_block_sptr block, bool 
check_inputs)
+gr_simple_flowgraph_detail::calc_connections(gr_basic_block_sptr block, bool 
check_inputs)
 {
   gr_edge_vector_t result;
 
@@ -167,7 +167,7 @@
 }
 
 void
-gr_simple_flowgraph_detail::check_contiguity(gr_block_sptr block,
+gr_simple_flowgraph_detail::check_contiguity(gr_basic_block_sptr block,
                                              const std::vector<int> 
&used_ports,
                                              bool check_inputs)
 {
@@ -214,8 +214,8 @@
 void
 gr_simple_flowgraph_detail::setup_connections()
 {
-  // Assign block details to component blocks
-  for (gr_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {
+  // Assign block details to blocks
+  for (gr_basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {
     if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
       std::cout << "Allocating output buffers for " << (*p)->name() << "..." 
<< std::endl;
 
@@ -224,13 +224,18 @@
     gr_block_detail_sptr detail = gr_make_block_detail(ninputs, noutputs);
     for (int i = 0; i < noutputs; i++)
       detail->set_output(i, allocate_buffer(*p, i));
-    (*p)->set_detail(detail);
+
+    boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(*p)->set_detail(detail);
   }
 
   // Connect inputs to outputs for each block
-  for(gr_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {
+  for(gr_basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {
+    gr_block_sptr grblock(boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(*p));
+    if (!grblock)
+      throw std::runtime_error("setup_connections found non-gr_block");
+
     // Get its detail and edges that feed into it
-    gr_block_detail_sptr detail = (*p)->detail();
+    gr_block_detail_sptr detail = grblock->detail();
     gr_edge_vector_t in_edges = calc_upstream_edges(*p);
 
     if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
@@ -243,34 +248,43 @@
       // buffer on the source port
       int dst_port = (*e)->dst().port();
       int src_port = (*e)->src().port();
-      gr_block_sptr src_block = (*e)->src().block();
-      gr_buffer_sptr src_buffer = src_block->detail()->output(src_port);
+      gr_basic_block_sptr src_block = (*e)->src().block();
+      gr_block_sptr src_grblock(boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(src_block));
+      if (!grblock)
+       throw std::runtime_error("setup_connections found non-gr_block");
+      gr_buffer_sptr src_buffer = src_grblock->detail()->output(src_port);
 
       if (GR_SIMPLE_FLOWGRAPH_DETAIL_DEBUG)
        std::cout << "Setting input on " << (*e)->dst() << std::endl;
 
-      detail->set_input(dst_port, gr_buffer_add_reader(src_buffer, 
(*p)->history()-1));
+      detail->set_input(dst_port, gr_buffer_add_reader(src_buffer, 
grblock->history()-1));
     }
   }
 }
 
 gr_buffer_sptr
-gr_simple_flowgraph_detail::allocate_buffer(gr_block_sptr block, int port)
+gr_simple_flowgraph_detail::allocate_buffer(gr_basic_block_sptr block, int 
port)
 {
+  gr_block_sptr grblock(boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(block));
+  if (!grblock)
+    throw std::runtime_error("allocate_buffer found non-gr_block");
   int item_size = block->output_signature()->sizeof_stream_item(port);
   int nitems = s_fixed_buffer_size/item_size;
 
   // Make sure there are at least twice the output_multiple no. of items
-  if (nitems < 2*block->output_multiple())     // Note: this means 
output_multiple()
-    nitems = 2*block->output_multiple();       // can't be changed by block 
dynamically
+  if (nitems < 2*grblock->output_multiple())   // Note: this means 
output_multiple()
+    nitems = 2*grblock->output_multiple();     // can't be changed by block 
dynamically
 
   // If any downstream blocks are decimators and/or have a large 
output_multiple,
   // ensure we have a buffer at least twice their decimation 
factor*output_multiple
-  gr_block_vector_t blocks = calc_downstream_blocks(block, port);
-  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
-    int decimation = (int)(1.0/(*p)->relative_rate());
-    int multiple   = (*p)->output_multiple();
-    int history    = (*p)->history();
+  gr_basic_block_vector_t blocks = calc_downstream_blocks(block, port);
+  for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
+    gr_block_sptr dgrblock(boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(*p));
+      if (!dgrblock)
+       throw std::runtime_error("allocate_buffer found non-gr_block");
+    int decimation = (int)(1.0/dgrblock->relative_rate());
+    int multiple   = dgrblock->output_multiple();
+    int history    = dgrblock->history();
     nitems = std::max(nitems, 2*(decimation*multiple+history));
   }
 
@@ -281,11 +295,11 @@
   return gr_make_buffer(nitems, item_size);
 }
 
-gr_block_vector_t
-gr_simple_flowgraph_detail::calc_downstream_blocks(gr_block_sptr block, int 
port)
+gr_basic_block_vector_t
+gr_simple_flowgraph_detail::calc_downstream_blocks(gr_basic_block_sptr block, 
int port)
 {
-  gr_block_vector_t tmp, result;
-  std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
+  gr_basic_block_vector_t tmp, result;
+  std::insert_iterator<gr_basic_block_vector_t> inserter(result, 
result.begin());
 
   for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
     if ((*p)->src().block() == block && (*p)->src().port() == port)
@@ -297,11 +311,11 @@
   return result;
 }
 
-gr_block_vector_t
-gr_simple_flowgraph_detail::calc_downstream_blocks(gr_block_sptr block)
+gr_basic_block_vector_t
+gr_simple_flowgraph_detail::calc_downstream_blocks(gr_basic_block_sptr block)
 {
-  gr_block_vector_t tmp, result;
-  std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
+  gr_basic_block_vector_t tmp, result;
+  std::insert_iterator<gr_basic_block_vector_t> inserter(result, 
result.begin());
 
   for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)
     if ((*p)->src().block() == block)
@@ -314,7 +328,7 @@
 }
 
 gr_edge_vector_t
-gr_simple_flowgraph_detail::calc_upstream_edges(gr_block_sptr block)
+gr_simple_flowgraph_detail::calc_upstream_edges(gr_basic_block_sptr block)
 {
   gr_edge_vector_t result;
 
@@ -325,11 +339,11 @@
   return result; // Assume no duplicates
 }
 
-gr_block_vector_t
+gr_basic_block_vector_t
 gr_simple_flowgraph_detail::calc_used_blocks()
 {
-  gr_block_vector_t tmp, result;
-  std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
+  gr_basic_block_vector_t tmp, result;
+  std::insert_iterator<gr_basic_block_vector_t> inserter(result, 
result.begin());
 
   for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) {
     tmp.push_back((*p)->src().block());
@@ -350,36 +364,36 @@
 gr_simple_flowgraph_detail::partition()
 {
   std::vector<gr_block_vector_t> result;
-  gr_block_vector_t blocks = calc_used_blocks();
-  gr_block_vector_t graph;
+  gr_basic_block_vector_t blocks = calc_used_blocks();
+  gr_basic_block_vector_t graph;
 
   while (blocks.size() > 0) {
     graph = calc_reachable_blocks(blocks[0], blocks);
     assert(graph.size());
     result.push_back(topological_sort(graph));
 
-    for (gr_block_viter_t p = graph.begin(); p != graph.end(); p++)
+    for (gr_basic_block_viter_t p = graph.begin(); p != graph.end(); p++)
       blocks.erase(find(blocks.begin(), blocks.end(), *p));
   }
 
   return result;
 }
 
-gr_block_vector_t
-gr_simple_flowgraph_detail::calc_reachable_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks)
+gr_basic_block_vector_t
+gr_simple_flowgraph_detail::calc_reachable_blocks(gr_basic_block_sptr block, 
gr_basic_block_vector_t &blocks)
 {
-  gr_block_vector_t result;
+  gr_basic_block_vector_t result;
 
   // Mark all blocks as unvisited
-  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++)
-    (*p)->detail()->set_color(gr_block_detail::WHITE);
+  for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++)
+    boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(*p)->detail()->set_color(gr_block_detail::WHITE);
 
   // Recursively mark all reachable blocks
   reachable_dfs_visit(block, blocks);
 
   // Collect all the blocks that have been visited
-  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++)
-    if ((*p)->detail()->color() == gr_block_detail::BLACK)
+  for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++)
+    if ((boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(*p))->detail()->color() == gr_block_detail::BLACK)
       result.push_back(*p);
 
   return result;
@@ -387,25 +401,25 @@
 
 // Recursively mark all reachable blocks from given block and block list
 void 
-gr_simple_flowgraph_detail::reachable_dfs_visit(gr_block_sptr block, 
gr_block_vector_t &blocks)
+gr_simple_flowgraph_detail::reachable_dfs_visit(gr_basic_block_sptr block, 
gr_basic_block_vector_t &blocks)
 {
   // Mark the current one as visited
-  block->detail()->set_color(gr_block_detail::BLACK);
+  boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(block)->detail()->set_color(gr_block_detail::BLACK);
 
   // Recurse into adjacent vertices
-  gr_block_vector_t adjacent = calc_adjacent_blocks(block, blocks);
+  gr_basic_block_vector_t adjacent = calc_adjacent_blocks(block, blocks);
 
-  for (gr_block_viter_t p = adjacent.begin(); p != adjacent.end(); p++)
-    if ((*p)->detail()->color() == gr_block_detail::WHITE)
+  for (gr_basic_block_viter_t p = adjacent.begin(); p != adjacent.end(); p++)
+    if (boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(*p)->detail()->color() == gr_block_detail::WHITE)
       reachable_dfs_visit(*p, blocks);
 }
 
 // Return a list of block adjacent to a given block along any edge
-gr_block_vector_t 
-gr_simple_flowgraph_detail::calc_adjacent_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks)
+gr_basic_block_vector_t 
+gr_simple_flowgraph_detail::calc_adjacent_blocks(gr_basic_block_sptr block, 
gr_basic_block_vector_t &blocks)
 {
-  gr_block_vector_t tmp, result;
-  std::insert_iterator<gr_block_vector_t> inserter(result, result.begin());
+  gr_basic_block_vector_t tmp, result;
+  std::insert_iterator<gr_basic_block_vector_t> inserter(result, 
result.begin());
     
   // Find any blocks that are inputs or outputs
   for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) {
@@ -423,17 +437,18 @@
 }
 
 gr_block_vector_t
-gr_simple_flowgraph_detail::topological_sort(gr_block_vector_t &blocks)
+gr_simple_flowgraph_detail::topological_sort(gr_basic_block_vector_t &blocks)
 {
-  gr_block_vector_t result, tmp;
+  gr_basic_block_vector_t tmp;
+  gr_block_vector_t result;
   tmp = sort_sources_first(blocks);
 
   // Start 'em all white
-  for (gr_block_viter_t p = tmp.begin(); p != tmp.end(); p++)
-    (*p)->detail()->set_color(gr_block_detail::WHITE);
+  for (gr_basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++)
+    boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(*p)->detail()->set_color(gr_block_detail::WHITE);
 
-  for (gr_block_viter_t p = tmp.begin(); p != tmp.end(); p++) {
-    if ((*p)->detail()->color() == gr_block_detail::WHITE)
+  for (gr_basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) {
+    if (boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(*p)->detail()->color() == gr_block_detail::WHITE)
       topological_dfs_visit(*p, result);
   }    
 
@@ -443,41 +458,41 @@
 }
 
 bool
-gr_simple_flowgraph_detail::source_p(gr_block_sptr block)
+gr_simple_flowgraph_detail::source_p(gr_basic_block_sptr block)
 {
   return (calc_upstream_edges(block).size() == 0);
 }
 
-gr_block_vector_t
-gr_simple_flowgraph_detail::sort_sources_first(gr_block_vector_t &blocks)
+gr_basic_block_vector_t
+gr_simple_flowgraph_detail::sort_sources_first(gr_basic_block_vector_t &blocks)
 {
-  gr_block_vector_t sources, nonsources, result;
+  gr_basic_block_vector_t sources, nonsources, result;
 
-  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
+  for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
     if (source_p(*p))
       sources.push_back(*p);
     else
       nonsources.push_back(*p);
   }
 
-  for (gr_block_viter_t p = sources.begin(); p != sources.end(); p++)
+  for (gr_basic_block_viter_t p = sources.begin(); p != sources.end(); p++)
     result.push_back(*p);
 
-  for (gr_block_viter_t p = nonsources.begin(); p != nonsources.end(); p++)
+  for (gr_basic_block_viter_t p = nonsources.begin(); p != nonsources.end(); 
p++)
     result.push_back(*p);
 
   return result;
 }
 
 void
-gr_simple_flowgraph_detail::topological_dfs_visit(gr_block_sptr block, 
gr_block_vector_t &output)
+gr_simple_flowgraph_detail::topological_dfs_visit(gr_basic_block_sptr block, 
gr_block_vector_t &output)
 {
-  block->detail()->set_color(gr_block_detail::GREY);
+  boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(block)->detail()->set_color(gr_block_detail::GREY);
 
-  gr_block_vector_t blocks(calc_downstream_blocks(block));
+  gr_basic_block_vector_t blocks(calc_downstream_blocks(block));
 
-  for (gr_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
-    switch ((*p)->detail()->color()) {
+  for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {
+    switch (boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(*p)->detail()->color()) {
     case gr_block_detail::WHITE:           
       topological_dfs_visit(*p, output);
       break;
@@ -493,8 +508,10 @@
     }
   }
 
-  block->detail()->set_color(gr_block_detail::BLACK);
-  output.push_back(block);
+  gr_block_sptr result_block(boost::dynamic_pointer_cast<gr_block, 
gr_basic_block>(block));
+
+  result_block->detail()->set_color(gr_block_detail::BLACK);
+  output.push_back(result_block);
 }
 
 void

Modified: 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.h
===================================================================
--- 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.h
       2007-04-11 07:29:05 UTC (rev 4946)
+++ 
gnuradio/branches/developers/jcorgan/hier2/gnuradio-core/src/lib/runtime/gr_simple_flowgraph_detail.h
       2007-04-11 17:45:48 UTC (rev 4947)
@@ -23,7 +23,7 @@
 #ifndef INCLUDED_GR_SIMPLE_FLOWGRAPH_DETAIL_H
 #define INCLUDED_GR_SIMPLE_FLOWGRAPH_DETAIL_H
 
-#include <gr_block.h>
+#include <gr_basic_block.h>
 #include <gr_simple_flowgraph.h>
 #include <iostream>
 
@@ -61,7 +61,7 @@
     
   gr_simple_flowgraph_detail() : d_blocks(), d_edges() { }
 
-  gr_block_vector_t d_blocks;
+  gr_basic_block_vector_t d_blocks;
   gr_edge_vector_t  d_edges;
   static const unsigned int s_fixed_buffer_size = GR_FIXED_BUFFER_SIZE;
     
@@ -71,38 +71,31 @@
   void check_dst_not_used(const gr_endpoint &dst);
   void check_type_match(const gr_endpoint &src, const gr_endpoint &dst);
   void validate();
-  gr_edge_vector_t calc_connections(gr_block_sptr block, bool check_inputs); 
// false=use outputs
-  std::vector<int> calc_used_ports(gr_block_sptr block, bool check_inputs); 
-  void check_contiguity(gr_block_sptr block, const std::vector<int> 
&used_ports, bool check_inputs);
+  gr_edge_vector_t calc_connections(gr_basic_block_sptr block, bool 
check_inputs); // false=use outputs
+  std::vector<int> calc_used_ports(gr_basic_block_sptr block, bool 
check_inputs); 
+  void check_contiguity(gr_basic_block_sptr block, const std::vector<int> 
&used_ports, bool check_inputs);
   void setup_connections();
   void merge_connections(gr_simple_flowgraph_sptr sfg);
 
-  gr_buffer_sptr allocate_buffer(gr_block_sptr block, int port);
-  gr_block_vector_t calc_downstream_blocks(gr_block_sptr block, int port);
-  gr_block_vector_t calc_downstream_blocks(gr_block_sptr block);
-  gr_edge_vector_t calc_upstream_edges(gr_block_sptr block);
-  gr_block_vector_t calc_used_blocks();
+  gr_buffer_sptr allocate_buffer(gr_basic_block_sptr block, int port);
+  gr_basic_block_vector_t calc_downstream_blocks(gr_basic_block_sptr block, 
int port);
+  gr_basic_block_vector_t calc_downstream_blocks(gr_basic_block_sptr block);
+  gr_edge_vector_t calc_upstream_edges(gr_basic_block_sptr block);
+  gr_basic_block_vector_t calc_used_blocks();
   std::vector<gr_block_vector_t> partition();
-  gr_block_vector_t calc_reachable_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks);
-  gr_block_vector_t topological_sort(gr_block_vector_t &blocks);
-  void reachable_dfs_visit(gr_block_sptr block, gr_block_vector_t &blocks);
-  gr_block_vector_t calc_adjacent_blocks(gr_block_sptr block, 
gr_block_vector_t &blocks);
-  bool source_p(gr_block_sptr block);
-  gr_block_vector_t sort_sources_first(gr_block_vector_t &blocks);
-  void topological_dfs_visit(gr_block_sptr block, gr_block_vector_t &output);
+  gr_basic_block_vector_t calc_reachable_blocks(gr_basic_block_sptr block, 
gr_basic_block_vector_t &blocks);
+  gr_block_vector_t topological_sort(gr_basic_block_vector_t &blocks);
+  void reachable_dfs_visit(gr_basic_block_sptr block, gr_basic_block_vector_t 
&blocks);
+  gr_basic_block_vector_t calc_adjacent_blocks(gr_basic_block_sptr block, 
gr_basic_block_vector_t &blocks);
+  bool source_p(gr_basic_block_sptr block);
+  gr_basic_block_vector_t sort_sources_first(gr_basic_block_vector_t &blocks);
+  void topological_dfs_visit(gr_basic_block_sptr block, gr_block_vector_t 
&output);
         
 public:
   ~gr_simple_flowgraph_detail();
 };
 
 inline std::ostream&
-operator <<(std::ostream& os, const gr_block_sptr p)
-{
-  os << "<gr_block " << p->name() << " (" << p->unique_id() << ")>";
-  return os;
-}
-
-inline std::ostream&
 operator <<(std::ostream &os, const gr_endpoint endp)
 {
   os << endp.block()->name() << ":" << endp.port();