[XLA] Unify spelling of 'fusible'

Of {fusable, fusile, fusible} my dictionary only knows about fusible.

PiperOrigin-RevId: 210373347

1 files changed, 12 insertions, 12 deletions

diff --git a/tensorflow/compiler/xla/service/instruction_fusion.cc b/tensorflow/compiler/xla/service/instruction_fusion.cc
index be59ce8281..6207cdfb0d 100644
--- a/tensorflow/compiler/xla/service/instruction_fusion.cc
+++ b/tensorflow/compiler/xla/service/instruction_fusion.cc
@@ -189,13 +189,13 @@ bool InstructionFusion::CanFuseOnAllPaths(
   if (consumer == producer) {
     return true;
   }
-  if (!consumer->IsFusable()) {
+  if (!consumer->IsFusible()) {
     return false;
   }
   for (int64 i = 0, e = consumer->operand_count(); i < e; ++i) {
     auto* consumer_operand = consumer->mutable_operand(i);
     // If the operand is not on a path to the producer, it doesn't matter
-    // whether it's fusable.
+    // whether it's fusible.
     if (!reachability_->IsReachable(producer, consumer_operand)) {
       continue;
     }
@@ -205,7 +205,7 @@ bool InstructionFusion::CanFuseOnAllPaths(
     }
     // The producer is reachable from consumer_operand which means we need
     // to be able to fuse consumer_operand into consumer in order for
-    // producer to be fusable into consumer on all paths.
+    // producer to be fusible into consumer on all paths.
     // Perform the recursive step: make sure producer can be fused into
     // consumer_operand on all paths.
     if (!CanFuseOnAllPaths(producer, consumer_operand, do_not_duplicate)) {
@@ -216,7 +216,7 @@ bool InstructionFusion::CanFuseOnAllPaths(
 }
 
 InstructionFusion::HloInstructionSet
-InstructionFusion::ComputeGloballyUnfusable(
+InstructionFusion::ComputeGloballyUnfusible(
     tensorflow::gtl::ArraySlice<HloInstruction*> post_order) {
   // Forbid fusion of producers that:
   // a) Need to be duplicated, unless they can be fused into all consumers
@@ -270,19 +270,19 @@ InstructionFusion::ComputeGloballyUnfusable(
       // all of its consumers on all paths.
       //
       // That means, that for:
-      // A --> B (fusable)
-      //   \-> C (non-fusable)
+      // A --> B (fusible)
+      //   \-> C (non-fusible)
       // A will be not allowed to be fused into B, as it cannot be fused into C.
       //
       // Similarly, for:
       // A -------------> B
       //   \-> C -> D -/
       // If:
-      // - A is fusable into B and C, and D is fusable into B
-      // - C is *not* fusable into D
+      // - A is fusible into B and C, and D is fusible into B
+      // - C is *not* fusible into D
       // A will be not allowed to be fused into B, as it cannot be fused via
       // all paths.
-      if (producer->IsFusable() &&
+      if (producer->IsFusible() &&
           CanFuseOnAllPaths(producer, consumer, do_not_duplicate)) {
         continue;
       }
@@ -318,7 +318,7 @@ StatusOr<bool> InstructionFusion::Run(HloModule* module) {
       InsertOrDie(&post_order_index, post_order[i], i);
     }
 
-    HloInstructionSet do_not_duplicate = ComputeGloballyUnfusable(post_order);
+    HloInstructionSet do_not_duplicate = ComputeGloballyUnfusible(post_order);
 
     // Instruction fusion effectively fuses edges in the computation graph
     // (producer instruction -> consumer instruction) so we iterate over all
@@ -341,7 +341,7 @@ StatusOr<bool> InstructionFusion::Run(HloModule* module) {
       // consistent.
       post_order_index.erase(instruction);
 
-      if (!instruction->IsFusable() &&
+      if (!instruction->IsFusible() &&
           instruction->opcode() != HloOpcode::kFusion) {
         continue;
       }
@@ -413,7 +413,7 @@ StatusOr<bool> InstructionFusion::Run(HloModule* module) {
       for (int64 i : sorted_operand_numbers) {
         HloInstruction* operand = instruction->mutable_operand(i);
 
-        if (!operand->IsFusable()) {
+        if (!operand->IsFusible()) {
           continue;
         }