Updating all call-sites of the legacy dispatcher registration API in fbcode to the new API. (#48178)

Summary:
Pull Request resolved: pytorch/pytorch#48178

I migrated all call sites that used the legacy dispatcher registration API (RegisterOperators()) to use the new API (TORCH_LIBRARY...). I found all call-sites by running `fbgs RegisterOperators()`. This includes several places, including other OSS code (nestedtensor, torchtext, torchvision). A few things to call out:

For simple ops that only had one registered kernel without a dispatch key, I replaced them with:
```
TORCH_LIBRARY_FRAGMENT(ns, m) {
   m.def("opName", fn_name);
}
```

For ops that registered to a specific dispatch key / had multiple kernels registered, I registered the common kernel (math/cpu) directly inside a `TORCH_LIBRARY_FRAGMENT` block, and registered any additional kernels from other files (e.g. cuda) in a separate `TORCH_LIBRARY_IMPL` block.

```
// cpu file
TORCH_LIBRARY_FRAGMENT(ns, m) {
  m.def("opName(schema_inputs) -> schema_outputs");
  m.impl("opName", torch::dispatch(c10::DispatchKey::CPU, TORCH_FN(cpu_kernel)));
}

// cuda file
TORCH_LIBRARY_IMPL(ns, CUDA, m) {
  m.impl("opName", torch::dispatch(c10::DispatchKey::CUDA, TORCH_FN(cuda_kernel)));
}
```
Special cases:

I found a few ops that used a (legacy) `CPUTensorId`/`CUDATensorId` dispatch key. Updated those to use CPU/CUDA- this seems safe because the keys are aliased to one another in `DispatchKey.h`

There were a handful of ops that registered a functor (function class) to the legacy API. As far as I could tell we don't allow this case in the new API, mainly because you can accomplish the same thing more cleanly with lambdas. Rather than delete the class I wrote a wrapper function on top of the class, which I passed to the new API.

There were a handful of ops that were registered only to a CUDA dispatch key. I put them inside a TORCH_LIBRARY_FRAGMENT block, and used a `def()` and `impl()` call like in case two above.

Test Plan: Imported from OSS

Reviewed By: ezyang

Differential Revision: D25056090

Pulled By: bdhirsh

fbshipit-source-id: 8f868b45f545e5da2f21924046e786850eba70d9

Author: bdhirsh

nestedtensor/csrc/mha.cpp

@@ -62,8 +62,9 @@ at::Tensor min_mha(
   return attn_output;
 }
 
-static auto registry =
-    torch::RegisterOperators().op("nestedtensor::min_mha", &min_mha);
+TORCH_LIBRARY_FRAGMENT(nestedtensor, m) {
+    m.def("min_mha", min_mha);
+}
 
 } // namespace nested_tensor
 } // namespace torch

nestedtensor/csrc/py_init.cpp

@@ -145,36 +145,34 @@ inline std::vector<std::string> split_str(
   result.push_back(s);
   return result;
 }
-
-static auto registry =
-    torch::RegisterOperators()
-        .op("nestedtensor::is_nested_tensor_impl",
-            [](Tensor tensor) { return is_nested_tensor_impl(tensor); })
-        .op("nestedtensor::nested_dim",
+TORCH_LIBRARY_FRAGMENT(nestedtensor, m) {
+    m.def("is_nested_tensor_impl",
+            [](Tensor tensor) { return is_nested_tensor_impl(tensor); });
+    m.def("nested_dim",
             [](Tensor tensor) {
               return get_nested_tensor_impl(tensor)->nested_dim();
-            })
-        .op("nestedtensor::stack",
+            });
+    m.def("stack",
             [](std::vector<Tensor> tensors, int64_t dim) {
               return at::stack(TensorList(tensors), dim);
-            })
-        .op("nestedtensor::cat",
+            });
+    m.def("cat",
             [](std::vector<Tensor> tensors, int64_t dim) {
               return at::cat(TensorList(tensors), dim);
-            })
-        .op("nestedtensor::to_nested_tensor",
+            });
+    m.def("to_nested_tensor",
             [](Tensor tensor, c10::optional<int64_t> dim) {
               return get_nested_tensor_impl(tensor)->to_nested_tensor(dim);
-            })
-        .op("nestedtensor::sizes",
+            });
+    m.def("sizes",
             [](Tensor tensor) {
               return get_nested_tensor_impl(tensor)->opt_sizes();
-            })
-        .op("nestedtensor::len",
+            });
+    m.def("len",
             [](Tensor self) {
               return (int64_t)(get_nested_tensor_structure(self).degree());
-            })
-        .op("nestedtensor::str", [](Tensor tensor) {
+            });
+    m.def("str", [](Tensor tensor) {
           auto node = get_nested_tensor_structure(tensor);
           return NestedNode___str__(
               node,
@@ -203,6 +201,8 @@ static auto registry =
                 return result;
               });
         });
+}
+
 } // namespace
 } // namespace nested_tensor
 } // namespace torch

nestedtensor/csrc/totensor.cpp

@@ -109,10 +109,11 @@ Tensor NestedTensor_to_tensor(Tensor tensor, c10::optional<int64_t> dim_) {
   // return wrap_tensor_node(TensorNode(std::move(result)));
 }
 
-static auto registry = torch::RegisterOperators().op(
-    "nestedtensor::to_tensor",
+TORCH_LIBRARY_FRAGMENT(nestedtensor, m) {
+    m.def("to_tensor",
     [](Tensor tensor, c10::optional<int64_t> dim) {
       return NestedTensor_to_tensor(tensor, dim);
     });
+}
 
 } // namespace at