results.clear();

  // Collect all of the blocks within each of the island operations, these will
  // be used to detect when an operation has a use within one of the merged
  // islands.
  llvm::SmallPtrSet<Block*, 8> islandBlocks;
  for (IslandOp island : merged_island.islands)
    island->walk([&](Block* block) { islandBlocks.insert(block); });

  for (IslandOp island : merged_island.islands) {

            sleep 1000
            // Try to get broadcaster, should not block
            def broadcaster = manager.getBroadcaster(TestBazListener)
            // Notify broadcaster, should not block
            broadcaster.baz()
        } as TestFooListener
        def listener2 = {
            sleep 20
            // Try to remove listener, should be blocked until listener 1 is done
            manager.removeListener(listener1)

                workerLeaseService.blocking {
                    assert !lockIsHeld(lease)
                    assert lockIsHeld(projectLock)
                }
                assert lockIsHeld(lease)
                assert lockIsHeld(projectLock)
            }
        }
    }

    def "releases and reacquires project locks in blocking action when changes to locks are allowed"() {

        0 * _
    }

    def "blocks transition while another thread is performing transition"() {
        def controller = controller(TestState.A)

        when:
        async {
            start {
                asWorker {
                    controller.transition(TestState.A, TestState.B) {
                        instant.first
                        thread.block()
                    }
                }

		monotonically.

	/sync/mutex/wait/total:seconds
		Approximate cumulative time goroutines have spent blocked on a
		sync.Mutex, sync.RWMutex, or runtime-internal lock. This metric
		is useful for identifying global changes in lock contention.
		Collect a mutex or block profile using the runtime/pprof package
		for more detailed contention data.
*/

  }
}

// Replaces control flow op block arguments with new block arguments
// of types `types`. The last element of the new block argument (token) is
// returned.
Value UpdateControlFlowBlockArgWithToken(OpBuilder& builder, Block& block,
                                         ArrayRef<Type> types) {
  builder.setInsertionPointToStart(&block);

  auto old_args_size = block.getNumArguments();

  block.addArguments(

LogicalResult FormClustersInBlock(
    Block* block,
    const mlir::TF::SideEffectAnalysis::Info& side_effect_analysis,
    bool strict_clusters) {
  MetadataMap metadata_map;
  LogicalResult result = CollectMetadata(block, &metadata_map);
  if (failed(result)) return result;

  // If there is no TPUReplicateMetadata op in this block, process blocks in
  // regions attached to the op's in the block.

		<td> <a href="/io?name={{.Name}}">graph</a> <a href="/io?name={{.Name}}&raw=1" download="io.profile">(download)</a></td>
	</tr>
	<tr>
		<td>Sync block profile:</td>
		<td> <a href="/block?name={{.Name}}">graph</a> <a href="/block?name={{.Name}}&raw=1" download="block.profile">(download)</a></td>
	</tr>
	<tr>
		<td>Syscall profile:</td>

					return ObjectLocked{}
				}

				if !ret.RetainUntilDate.Before(t) {
					return ObjectLocked{}
				}
				return nil
			}
			// https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock-overview.html#object-lock-retention-modes
			// If you try to delete objects protected by governance mode and have s3:BypassGovernanceRetention, the operation will succeed.

			buf.Reset()
			bytebufferpool.Put(buf)
		}()

		block := newMetacacheWriter(buf, 1<<20)
		defer block.Close()
		finishBlock := func() {
			if err := block.Close(); err != nil {
				w.streamErr = err
				return
			}
			current.data = buf.Bytes()
			w.streamErr = nextBlock(&current)
			// Prepare for next
			current.n++
			buf.Reset()
			block.Reset(buf)
			current.First = ""
		}