// Non-parallel tensors from _EagerConst/tf.constant are implicitly
        // broadcast, i.e. set as the input to each parallel operation. This
        // allows code like "tf.constant(1.)" or "tf.reduce_sum(..., axis=1)"
        // (where the value starts on the host), without allowing other implicit
        // copies/broadcasts. Other implicit copies may be supported eventually,

     */

    public static final int P_NODE = 1;

    /**
     * Try Broadcast queries first, then try to resolve the name using the
     * nameserver.
     */

    public static final int M_NODE = 2;

    /**
     * A Hybrid node tries to resolve a name using the nameserver first. If
     * that fails use the broadcast address. This is the default if a nameserver

}

def XlaBroadcastPass : Pass<"tf-xla-broadcast", "mlir::func::FuncOp"> {
  let summary = "Moves a broadcast from host into XLA, encoded as XlaAllReduce";

  let description = [{
    This pass moves brodcasts from host TF ops into XLA. This enables use of
    the inter-device network, which is faster than the inter-host network.
    Broadcasts in XLA are encoded as XlaAllReduce. An all_reduce with all 0

func.func @broadcast_shift_right_unsigned(%arg0: tensor<4xui8>, %arg1: tensor<2x4xui8>) -> tensor<2x4xui8> {
  // CHECK: %[[BROADCAST:.*]] = "mhlo.broadcast_in_dim"(%arg0) <{broadcast_dimensions = dense<1> : tensor<1xi64>}> : (tensor<4xui8>) -> tensor<2x4xui8>
  // CHECK:  mhlo.shift_right_logical %[[BROADCAST]], %arg1 : tensor<2x4xui8>
  %0 = "tf.RightShift"(%arg0, %arg1) : (tensor<4xui8>, tensor<2x4xui8>) -> tensor<2x4xui8>

constexpr StringRef kEntryFuncAttrName = "_entry_function";

// Returns broadcasted user op of an input op. Returns null if
// the op is not broadcasted or not the intended type.
// Supports both static broadcast and dynamic broadcast.
// Note that the patterns below differ from lifted patterns as
// ShapeLegalizeToHloPass is ran prior to running this pass.
//
// Dynamically broadcasted bias due to unknown input batch size

 * be set.
 */

    public static final int P_NODE = 1;

/** 
 * Try Broadcast queries first, then try to resolve the name using the
 * nameserver.
 */

    public static final int M_NODE = 2;

/** 
 * A Hybrid node tries to resolve a name using the nameserver first. If
 * that fails use the broadcast address. This is the default if a nameserver

    // Rewire the output.
    rewriter.replaceOp(op, {nullptr, rnn_result});

    return success();
  }
};

// Put two TFL BroadcastTo ops in front of the given TF binary broadcast op to
// to make binary broadcast-able op conversion always successful and does not
// require flex delegate.
template <typename SourceOp>
class ApplyExplicitBroadcasting : public OpRewritePattern<SourceOp> {

      return failure();
    }
    lhs = rewriter.create<mhlo::BitcastConvertOp>(op->getLoc(), *lhs_quant_type,
                                                  adaptor.getLhs());

    // rhs (bias) is always 1D that broadcasts to the last dim of lhs.
    auto broadcast_dims =
        rewriter.getDenseI64ArrayAttr({lhs_type.getRank() - 1});

    auto rhs_type = GetUniformQuantizedType(

  return std::make_pair(std::move(broadcasted_input_shape),
                        std::move(broadcasted_weight_shape));
}

// Broadcasts batch dimensions of the input and weight of the BatchMatMul
// op. In XLA, shapes are all constants, so all operations created in this
// function, except BroadcastTo, are expected to be folded.
void BroadcastBatchDimensionsForBatchMatMul(OpBuilder &builder, Location loc,

            }
        })
        def broadcast1 = listenerManager.getBroadcaster(TestListener)

        then:
        0 * _

        when:
        broadcast1.something("12")

        then:
        1 * created.run()
        1 * listener.something("12")
        0 * _

        when:
        def broadcast2 = listenerManager.getBroadcaster(DifferentListener)