auto num_selected = UnsortedSegmentSum(
      scope, Cast(scope, is_selected, grad.type()), op.input(1), op.input(2));
  // Compute the gradient for each segment.The gradient for the ith segment is
  // divided evenly among the selected elements in that segment.
  auto weighted_grads = Div(scope, grad, num_selected);
  auto gathered_grads = GatherDropNegatives(scope, weighted_grads,

      # We should change it at some point, but note #18545 when changing this.
      group_name="${NODE_INSTANCE_PREFIX}-group"
    fi
    # Spread the remaining number of nodes evenly
    this_mig_size=$((instances_left / (NUM_MIGS - i + 1)))
    instances_left=$((instances_left - this_mig_size))

    # Run instance-groups creation in parallel.
    {

// It must be very cheap to calculate.
// For now, align to goarch.PtrSize and reduce mod the number of entries.
// In practice, this appears to be fairly randomly and evenly distributed.
func pcvalueCacheKey(targetpc uintptr) uintptr {
	return (targetpc / goarch.PtrSize) % uintptr(len(pcvalueCache{}.entries))
}

// Returns the PCData value, and the PC where this value starts.

        then:
        0 * _

        when:
        renderer.onOutput(end)

        then:
        1 * listener.onOutput(event1)
        1 * listener.onOutput(event2)
        1 * listener.onOutput(event3)
        1 * listener.onOutput(end)
        0 * _
    }

    def "flushes events on flush event"() {
        def event1 = event('1')
        def event2 = event('2')
        def event3 = event('3')

	e.eventRecorder.Eventf(object, eventtype, reason, messageFmt, args...)
}

// Shutdown terminates the event recorder. This must be called upon completion of writing events, and events should not be
// written once terminated.
func (e *EventRecorder) Shutdown() {
	e.eventBroadcaster.Shutdown()

			// that we emit an in-progress event if this is
			// the first event for the goroutine in the trace
			// or trace generation. Also, do this between
			// acquire/release because this is part of the
			// goroutine's trace state, and it must be atomic
			// with respect to the tracer.
			gp.inMarkAssist = false
			traceRelease(trace)
		} else {
			// This state is tracked even if tracing isn't enabled.

	// Send a couple events before closing the broadcast channel.
	t.Log("Sending event 1")
	m.Action(event1.Type, event1.Object)
	t.Log("Sending event 2")
	m.Action(event2.Type, event2.Object)
	m.Shutdown()

	// Pull events from the queue.
	wg := sync.WaitGroup{}
	wg.Add(len(watches))
	for i := range watches {
		// Verify that each watcher only gets the first event because its watch
		// queue of length one was full from the first one.

        RenderableOutputEvent event1 = new StyledTextOutputEvent(tenAm, 'category', LogLevel.INFO, null, 'message')
        RenderableOutputEvent event2 = new StyledTextOutputEvent(tenAm, 'category', LogLevel.INFO, null, toNative('\n'))

        when:
        renderer.onOutput(new LogLevelChangeEvent(LogLevel.DEBUG))
        renderer.onOutput(event1)
        renderer.onOutput(event2)

        then:

    }

    def "serializes TestStartEvent"() {
        def id = new CompositeIdGenerator.CompositeId(1L, 2L)
        def event1 = new TestStartEvent(123L, id)
        def event2 = new TestStartEvent(456L)

        when:
        def result1 = serialize(event1)
        def result2 = serialize(event2)

        then:
        result1 instanceof TestStartEvent
        result1.parentId == id
        result1.startTime == 123L

//  tile_assignment_dimensions: 1
//  tile_assignment_devices: 1
// Serialized string:
//  "\08\01\1A\01\01\22\01\01"
//
// -----


// Tests tile sharding of inputs with number of splits that does not evenly divide
// the input results in an error.