%177 = "tf.Reshape"(%176, %9) {device = ""} : (tensor<i32>, tensor<0xi32>) -> tensor<i32>
  %178 = "tf.Pack"(%7, %177) {axis = 0 : i64, device = ""} : (tensor<i32>, tensor<i32>) -> tensor<2xi32>
  %179 = "tf.Tile"(%115, %178) {device = ""} : (tensor<?x1xi64>, tensor<2xi32>) -> tensor<?x?xi64>
  %180 = "tf.Mul"(%177, %118) {device = ""} : (tensor<i32>, tensor<i32>) -> tensor<i32>

    func.return %1, %3 : tensor<*xi32>, tensor<*xi1>
  }
}

// -----

// Tests inputs are correctly split and fed into TPU computation for tiled input
// sharding.

// The following OpSharding is used for TPU computation inputs in below test:
// Proto debug string:
//  input 0
//   type: OTHER
//   tile_assignment_dimensions: 1

	if err != nil {
		panic(err)
	}
	s.hashes = append(s.hashes, hashes...)

	return id, nil
}

func (s *TestServer) ReadTileData(ctx context.Context, t tlog.Tile) ([]byte, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	return tlog.ReadTileData(t, s.hashes)

  %multiples = "tf.Const"() { device = "/device:CPU:0", value = dense<[7,3]> : tensor<2xi32> } : () -> tensor<2xi32>
  // CHECK: T = !corert.string
  %output = "tf.Tile"(%arg, %multiples) { device = "/device:CPU:0" } : (tensor<1x2x!tf_type.string>, tensor<2xi32>) -> tensor<?x6x!tf_type.string>
  func.return %output : tensor<?x6x!tf_type.string>
}

// CHECK-LABEL: func @shape

    const int64_t tensor_rank = ranked_type.getRank();
    int tile_assignment_rank = sharding->tile_assignment_dimensions_size();

    // When a tensor is partial or subgroup tiled, its tile assignment will
    // have one or more dimension(s) than its rank; so, we subtract them to
    // determine which rank the sharding is compatible with.
    tile_assignment_rank -= (int)sharding->replicate_on_last_tile_dim();

  %2 = "tf.ExpandDims"(%1, %const_0) : (tensor<10000xi32>, tensor<i32>) -> tensor<1x10000xi32>
  %3 = "tf.Tile"(%2, %const_64_1) : (tensor<1x10000xi32>, tensor<2xi32>) -> tensor<64x10000xi32>
  // CHECK-NOT: tf.Range
  // CHECK-NOT: tf.ExpandDims
  // CHECK: [[TILE:%.*]] = "tf.Tile"
  // CHECK: return [[TILE]]
  func.return %3 : tensor<64x10000xi32>
}

		{"SHR", Const, 0},
		{"SHR_ASSIGN", Const, 0},
		{"STRING", Const, 0},
		{"STRUCT", Const, 0},
		{"SUB", Const, 0},
		{"SUB_ASSIGN", Const, 0},
		{"SWITCH", Const, 0},
		{"TILDE", Const, 18},
		{"TYPE", Const, 0},
		{"Token", Type, 0},
		{"UnaryPrec", Const, 0},
		{"VAR", Const, 0},
		{"XOR", Const, 0},
		{"XOR_ASSIGN", Const, 0},
	},
	"go/types": {

// CHECK-LABEL: func @cluster_func
// CHECK-SAME: ({{.+}}: tensor<*xf32> {mhlo.sharding = ""})
func.func @cluster_func(%arg0: tensor<*xf32>) {
  func.return
}

// -----

// Tests TPIv2 with a "partially tiled" XLA annotation where:
//   type: OTHER
//   tile_assignment_dimensions: [4, 1, 1, 1, 2]
//   tile_assignment_devices: [0, 1, 2, 3, 4, 5, 6, 7]
//   replicate_on_last_tile_dim: true
// Serialized string:

      %outputs_61, %control_62 = tf_executor.island wraps "tf.Tile"(%outputs_59, %outputs_29) {_tpu_replicate = "cluster_sample_sequence", device = ""} : (tensor<*xf32>, tensor<4xi32>) -> tensor<*xf32>

* Titiz bir çalışmanın sonucunda yukarıdaki standartlara uygun bir framework oluşturduk. Standartları pastanın üzerine sonradan eklenmiş bir çilek olarak görmedik.
* Ayrıca bu bir çok dilde kullanılabilecek **client code generator** kullanımına da izin veriyor.

### Otomatik dokümantasyon