This code previously did not work:

```python
import torch

def test():
    graph = torch.cuda.CUDAGraph()

    with torch.cuda.graph(graph, capture_error_mode="global"):
        data = torch.randn(8)
        data_gpu = torch.randn(8, device="cuda")
        data = data.pin_memory()
        data_gpu.to(data, non_blocking=True)

    graph2 = torch.cuda.CUDAGraph()
    with torch.cuda.graph(graph2, capture_error_mode="global"):
        data2 = torch.randn(8)
        data2_gpu = torch.randn(8, device="cuda")
        data2 = data2.pin_memory()
        data2_gpu.to(data2, non_blocking=True)

if __name__ == "__main__":
    test()
```

We use events to signal when a particular usage of a pinned host
memory block has completed. Every time we call pin_memory(),
cudaEventQuery() gets called to see if we we can reuse existing blocks
rather than allocating new blocks. cudaEventQuery() is not allowed
during stream capture unless we set the thread to relaxed capture
mode. (This is safe in this case so long as we make sure that the
pinned buffer is live until the cuda graph is destroyed.)

I haven't fully thought this through. I need to make sure that a
pinned memory tensor does in fact stay live until its corresponding
cuda graph is destroyed. (I haven't done this yet!)

Draft.

Use external flag only when in stream capture mode.

Initial correct implementation with proper ownership.

Cleanup + working on pools across multiple graphs.

Rudimentary test that capture into same pool across multiple graphs works.