[XLS] Switch from external-adapter channel legalization to internal arbitration

To support relaxed channel strictness settings (allowing multiple operations per channel per activation), we previously translated all operations to take place on their own channels, then inserted an external arbitrating adapter to mux the channels back together. This resulted in duplicated control-flow logic, and was difficult to optimize well without full-powered proc inlining - which ran into its own problems.

Instead, we now implement relaxed strictnesses by implementing additional legalizations within the proc: adding token-typed state to avoid cross-activation conflicts, and adding scheduling constraints to avoid having multiple (non-mutually-exclusive) operations in the same activation trigger at the same time. To support this, we also modify codegen to allow multiple operations per channel, relying on earlier compilation steps to ensure that we never see more than one trigger in a given cycle.

This passes all existing tests, except for a few where it revealed issues that were previously hidden by our choices in implementing the external adapter. We modify those tests accordingly. As best as I can tell, this should be no worse for performance than the previous version.

NOTE: This will also allow us to support proven-mutually-exclusive channels with mutually-exclusive operations that can't be merged, which reduces merging to an optimization; we'll remove the forced-merge logic for this case in a followup CL.

Fixes #2180

PiperOrigin-RevId: 760612461

Author: ericastor

xls/codegen/BUILD

@@ -217,6 +217,7 @@ cc_library(
         "//xls/common/status:status_macros",
         "//xls/ir",
         "//xls/ir:op",
+        "//xls/ir:proc_elaboration",
         "//xls/ir:state_element",
         "//xls/ir:xls_ir_interface_cc_proto",
         "//xls/passes:pass_base",
@@ -228,6 +229,7 @@ cc_library(
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",
+        "@com_google_absl//absl/types:span",
     ],
 )
 
@@ -438,26 +440,30 @@ cc_library(
     srcs = ["conversion_utils.cc"],
     hdrs = ["conversion_utils.h"],
     deps = [
-        ":codegen_checker",
         ":codegen_options",
         ":codegen_pass",
-        ":codegen_wrapper_pass",
         ":register_legalization_pass",
         "//xls/codegen/vast",
+        "//xls/common:casts",
         "//xls/common/status:ret_check",
         "//xls/common/status:status_macros",
         "//xls/ir",
+        "//xls/ir:bits",
         "//xls/ir:channel",
         "//xls/ir:node_util",
         "//xls/ir:op",
+        "//xls/ir:proc_elaboration",
         "//xls/ir:register",
         "//xls/ir:source_location",
+        "//xls/ir:value",
         "//xls/ir:xls_ir_interface_cc_proto",
         "//xls/passes:dataflow_simplification_pass",
         "//xls/passes:dce_pass",
         "//xls/passes:optimization_pass",
         "//xls/passes:pass_base",
         "@com_google_absl//absl/algorithm:container",
+        "@com_google_absl//absl/container:btree",
+        "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/log:check",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",

xls/codegen/block_conversion.cc

@@ -296,9 +296,10 @@ absl::Status AddCombinationalFlowControl(
     std::vector<std::vector<StreamingInput>>& streaming_inputs,
     std::vector<std::vector<StreamingOutput>>& streaming_outputs,
     std::vector<std::optional<Node*>>& stage_valid,
-    const CodegenOptions& options, Block* block) {
+    const CodegenOptions& options, Proc* proc, Block* block) {
   std::string_view valid_suffix = options.streaming_channel_valid_suffix();
   std::string_view ready_suffix = options.streaming_channel_ready_suffix();
+  std::string_view data_suffix = options.streaming_channel_data_suffix();
 
   XLS_ASSIGN_OR_RETURN(
       std::vector<Node*> all_active_outputs_ready,
@@ -316,10 +317,14 @@ absl::Status AddCombinationalFlowControl(
   std::vector<Node*> next_stage_open{literal_1};
   XLS_RETURN_IF_ERROR(MakeOutputValidPortsForOutputChannels(
       all_active_inputs_valid, pipelined_valids, next_stage_open,
-      streaming_outputs, valid_suffix, block));
+      streaming_outputs, valid_suffix, proc, {}, block));
+  XLS_RETURN_IF_ERROR(MakeOutputDataPortsForOutputChannels(
+      all_active_inputs_valid, pipelined_valids, next_stage_open,
+      streaming_outputs, data_suffix, block));
 
   XLS_RETURN_IF_ERROR(MakeOutputReadyPortsForInputChannels(
-      all_active_outputs_ready, streaming_inputs, ready_suffix, block));
+      all_active_outputs_ready, streaming_inputs, ready_suffix, proc, {},
+      block));
 
   XLS_RET_CHECK(stage_valid.empty());
   XLS_RET_CHECK_EQ(all_active_inputs_valid.size(), 1);
@@ -634,7 +639,8 @@ absl::StatusOr<Node*> AddZeroLatencyBufferToRDVNodes(
 }
 
 absl::StatusOr<std::vector<FunctionBase*>> GetBlockConversionOrder(
-    Package* package, absl::Span<Proc* const> procs_to_convert) {
+    Package* package, absl::Span<Proc* const> procs_to_convert,
+    const std::optional<ProcElaboration>& proc_elab) {
   FunctionBase* top = *package->GetTop();
   if (top->IsFunction()) {
     XLS_RET_CHECK(procs_to_convert.empty());
@@ -643,17 +649,18 @@ absl::StatusOr<std::vector<FunctionBase*>> GetBlockConversionOrder(
   CHECK(top->IsProc());
   if (package->ChannelsAreProcScoped()) {
     XLS_RET_CHECK(procs_to_convert.empty());
+    XLS_RET_CHECK(proc_elab.has_value());
     // The order of block conversion must be from the leaf up as *instantiated*
     // procs must be converted before *instantiating* proc.
-    XLS_ASSIGN_OR_RETURN(ProcElaboration elab,
-                         ProcElaboration::Elaborate(top->AsProcOrDie()));
-    std::vector<FunctionBase*> order(elab.procs().begin(), elab.procs().end());
+    std::vector<FunctionBase*> order(proc_elab->procs().begin(),
+                                     proc_elab->procs().end());
     std::reverse(order.begin(), order.end());
     return order;
   }
   // For the non-proc-scoped channels case, the set of procs to convert must be
   // given.
   XLS_RET_CHECK(!procs_to_convert.empty());
+  XLS_RET_CHECK(!proc_elab.has_value());
   std::vector<FunctionBase*> order(procs_to_convert.begin(),
                                    procs_to_convert.end());
   std::sort(order.begin(), order.end(), FunctionBase::NameLessThan);
@@ -686,8 +693,16 @@ absl::StatusOr<CodegenContext> PackageToPipelinedBlocks(
       }
     }
   }
-  XLS_ASSIGN_OR_RETURN(std::vector<FunctionBase*> conversion_order,
-                       GetBlockConversionOrder(package, procs_to_convert));
+
+  std::optional<ProcElaboration> proc_elab;
+  if (top->IsProc() && package->ChannelsAreProcScoped()) {
+    XLS_ASSIGN_OR_RETURN(proc_elab,
+                         ProcElaboration::Elaborate(top->AsProcOrDie()));
+  }
+
+  XLS_ASSIGN_OR_RETURN(
+      std::vector<FunctionBase*> conversion_order,
+      GetBlockConversionOrder(package, procs_to_convert, proc_elab));
 
   // Make `unit` optional because we haven't created the top block yet. We will
   // create it on the first iteration and emplace `unit`.
@@ -732,8 +747,13 @@ absl::StatusOr<CodegenContext> PackageToPipelinedBlocks(
           package->AddBlock(std::make_unique<Block>(sub_block_name, package));
     }
     if (fb->IsProc()) {
+      absl::Span<ProcInstance* const> instances;
+      if (package->ChannelsAreProcScoped()) {
+        XLS_RET_CHECK(proc_elab.has_value());
+        instances = proc_elab->GetInstances(fb->AsProcOrDie());
+      }
       XLS_RETURN_IF_ERROR(SingleProcToPipelinedBlock(
-          schedule, options, context, fb->AsProcOrDie(), sub_block,
+          schedule, options, context, fb->AsProcOrDie(), instances, sub_block,
           converted_blocks));
     } else if (fb->IsFunction()) {
       XLS_RET_CHECK_EQ(conversion_order.size(), 1);
@@ -888,9 +908,9 @@ absl::StatusOr<CodegenContext> ProcToCombinationalBlock(
 
   XLS_RET_CHECK_EQ(streaming_io.pipeline_registers.size(), 0);
 
-  XLS_RETURN_IF_ERROR(
-      AddCombinationalFlowControl(streaming_io.inputs, streaming_io.outputs,
-                                  streaming_io.stage_valid, options, block));
+  XLS_RETURN_IF_ERROR(AddCombinationalFlowControl(
+      streaming_io.inputs, streaming_io.outputs, streaming_io.stage_valid,
+      options, proc, block));
 
   // TODO(tedhong): 2021-09-23 Remove and add any missing functionality to
   //                codegen pipeline.

xls/codegen/block_conversion.h

@@ -35,6 +35,7 @@
 #include "xls/ir/node.h"
 #include "xls/ir/nodes.h"
 #include "xls/ir/proc.h"
+#include "xls/ir/proc_elaboration.h"
 #include "xls/scheduling/pipeline_schedule.h"
 
 namespace xls::verilog {
@@ -131,7 +132,7 @@ absl::Status AddCombinationalFlowControl(
     std::vector<std::vector<StreamingInput>>& streaming_inputs,
     std::vector<std::vector<StreamingOutput>>& streaming_outputs,
     std::vector<std::optional<Node*>>& stage_valid,
-    const CodegenOptions& options, Block* block);
+    const CodegenOptions& options, Proc* proc, Block* block);
 
 // Update io channel metadata with latest information from block conversion.
 absl::Status UpdateChannelMetadata(const StreamingIOPipeline& io, Block* block);
@@ -143,7 +144,8 @@ absl::StatusOr<std::string> StreamingIOName(Node* node);
 // bottom up in the tree of proc instantiations. `procs_to_convert` is the set
 // of Procs to convert. `procs_to_convert` must not be specified otherwise.
 absl::StatusOr<std::vector<FunctionBase*>> GetBlockConversionOrder(
-    Package* package, absl::Span<Proc* const> procs_to_convert = {});
+    Package* package, absl::Span<Proc* const> procs_to_convert = {},
+    const std::optional<ProcElaboration>& proc_elab = std::nullopt);
 
 }  // namespace xls::verilog