torch-rb 0.23.0 → 0.24.0

data/ext/torch/ivalue.cpp

@@ -53,7 +53,7 @@ void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
       [](torch::IValue& self) {
         auto list = self.toListRef();
         Rice::Array obj;
-        for (auto& elem : list) {
+        for (const auto& elem : list) {
           auto v = torch::IValue{elem};
           obj.push(Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(v)), false);
         }
@@ -74,7 +74,7 @@ void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
       [](torch::IValue& self) {
         auto dict = self.toGenericDict();
         Rice::Hash obj;
-        for (auto& pair : dict) {
+        for (const auto& pair : dict) {
           auto k = torch::IValue{pair.key()};
           auto v = torch::IValue{pair.value()};
           obj[Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(k))] = Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(v));
@@ -91,7 +91,7 @@ void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
       "from_list",
       [](Rice::Array obj) {
         c10::impl::GenericList list(c10::AnyType::get());
-        for (auto entry : obj) {
+        for (const auto& entry : obj) {
           list.push_back(Rice::detail::From_Ruby<torch::IValue>().convert(entry.value()));
         }
         return torch::IValue(list);
@@ -125,7 +125,7 @@ void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
         auto value_type = c10::AnyType::get();
         c10::impl::GenericDict elems(key_type, value_type);
         elems.reserve(obj.size());
-        for (auto entry : obj) {
+        for (const auto& entry : obj) {
           elems.insert(Rice::detail::From_Ruby<torch::IValue>().convert(entry.first), Rice::detail::From_Ruby<torch::IValue>().convert((Rice::Object) entry.second));
         }
         return torch::IValue(std::move(elems));

data/ext/torch/nn.cpp

@@ -1,3 +1,4 @@
+#include <optional>
 #include <utility>
 
 #include <torch/torch.h>
@@ -95,7 +96,7 @@ void init_nn(Rice::Module& m) {
       "grad",
       [](Parameter& self) {
         auto grad = self.grad();
-        return grad.defined() ? Rice::Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Rice::Nil;
+        return grad.defined() ? std::optional<torch::Tensor>{grad} : std::nullopt;
       })
     // can't use grad=
     // assignment methods fail with Ruby 3.0

data/ext/torch/ruby_arg_parser.cpp

@@ -117,11 +117,11 @@ bool is_tensor_list(VALUE obj, int argnum, bool throw_error) {
   }
   auto size = RARRAY_LEN(obj);
   for (int idx = 0; idx < size; idx++) {
-    VALUE iobj = rb_ary_entry(obj, idx);
+    VALUE iobj = Rice::detail::protect(rb_ary_entry, obj, idx);
     if (!THPVariable_Check(iobj)) {
       if (throw_error) {
-        rb_raise(rb_eArgError, "expected Tensor as element %d in argument %d, but got %s",
-            static_cast<int>(idx), argnum, rb_obj_classname(obj));
+        throw Rice::Exception(rb_eArgError, "expected Tensor as element %d in argument %d, but got %s",
+            static_cast<int>(idx), argnum, Rice::detail::protect(rb_obj_classname, obj));
       }
       return false;
     }
@@ -136,7 +136,7 @@ static bool is_int_list(VALUE obj, int broadcast_size) {
       return true;
     }
 
-    auto item = rb_ary_entry(obj, 0);
+    auto item = Rice::detail::protect(rb_ary_entry, obj, 0);
     bool int_first = false;
     if (THPUtils_checkIndex(item)) {
       // we still have to check that the rest of items are NOT symint nodes
@@ -178,7 +178,7 @@ static bool is_int_or_symint_list(VALUE obj, int broadcast_size) {
     if (RARRAY_LEN(obj) == 0) {
       return true;
     }
-    auto item = rb_ary_entry(obj, 0);
+    auto item = Rice::detail::protect(rb_ary_entry, obj, 0);
 
     if (is_int_or_symint(item)) {
       return true;
@@ -583,10 +583,10 @@ static void extra_args(const FunctionSignature& signature, ssize_t nargs) {
   const long min_args = signature.min_args;
   const long nargs_ = nargs;
   if (min_args != max_pos_args) {
-    rb_raise(rb_eArgError, "%s() takes from %ld to %ld positional arguments but %ld were given",
+    throw Rice::Exception(rb_eArgError, "%s() takes from %ld to %ld positional arguments but %ld were given",
         signature.name.c_str(), min_args, max_pos_args, nargs_);
   }
-  rb_raise(rb_eArgError, "%s() takes %ld positional argument%s but %ld %s given",
+  throw Rice::Exception(rb_eArgError, "%s() takes %ld positional argument%s but %ld %s given",
       signature.name.c_str(),
       max_pos_args, max_pos_args == 1 ? "" : "s",
       nargs_, nargs == 1 ? "was" : "were");
@@ -608,7 +608,7 @@ static void missing_args(const FunctionSignature& signature, int idx) {
     }
   }
 
-  rb_raise(rb_eArgError, "%s() missing %d required positional argument%s: %s",
+  throw Rice::Exception(rb_eArgError, "%s() missing %d required positional argument%s: %s",
       signature.name.c_str(),
       num_missing,
       num_missing == 1 ? "s" : "",
@@ -631,28 +631,28 @@ static ssize_t find_param(FunctionSignature& signature, VALUE name) {
 static void extra_kwargs(FunctionSignature& signature, VALUE kwargs, ssize_t num_pos_args) {
   VALUE key;
 
-  VALUE keys = rb_funcall(kwargs, rb_intern("keys"), 0);
+  VALUE keys = Rice::detail::protect(rb_funcall, kwargs, rb_intern("keys"), 0);
   if (RARRAY_LEN(keys) > 0) {
-    key = rb_ary_entry(keys, 0);
+    key = Rice::detail::protect(rb_ary_entry, keys, 0);
 
     if (!THPUtils_checkSymbol(key)) {
-      rb_raise(rb_eArgError, "keywords must be symbols, not %s", rb_obj_classname(key));
+      throw Rice::Exception(rb_eArgError, "keywords must be symbols, not %s", Rice::detail::protect(rb_obj_classname, key));
     }
 
     auto param_idx = find_param(signature, key);
     if (param_idx < 0) {
-      rb_raise(rb_eArgError, "%s() got an unexpected keyword argument '%s'",
-          signature.name.c_str(), rb_id2name(rb_to_id(key)));
+      throw Rice::Exception(rb_eArgError, "%s() got an unexpected keyword argument '%s'",
+          signature.name.c_str(), Rice::detail::protect(rb_id2name, Rice::detail::protect(rb_to_id, key)));
     }
 
     if (param_idx < num_pos_args) {
-      rb_raise(rb_eArgError, "%s() got multiple values for argument '%s'",
-          signature.name.c_str(), rb_id2name(rb_to_id(key)));
+      throw Rice::Exception(rb_eArgError, "%s() got multiple values for argument '%s'",
+          signature.name.c_str(), Rice::detail::protect(rb_id2name, Rice::detail::protect(rb_to_id, key)));
     }
   }
 
   // this should never be hit
-  rb_raise(rb_eArgError, "invalid keyword arguments");
+  throw Rice::Exception(rb_eArgError, "invalid keyword arguments");
 }
 
 VALUE missing = Qundef;
@@ -703,14 +703,14 @@ bool FunctionSignature::parse(VALUE self, VALUE args, VALUE kwargs, VALUE dst[],
         }
         return false;
       }
-      obj = rb_ary_entry(args, arg_pos);
+      obj = Rice::detail::protect(rb_ary_entry, args, arg_pos);
     } else if (!NIL_P(kwargs)) {
-      obj = rb_hash_lookup2(kwargs, param.ruby_name, missing);
+      obj = Rice::detail::protect(rb_hash_lookup2, kwargs, param.ruby_name, missing);
       // for (VALUE numpy_name: param.numpy_python_names) {
       //   if (obj) {
       //     break;
       //   }
-      //   obj = rb_hash_aref(kwargs, numpy_name);
+      //   obj = Rice::detail::protect(rb_hash_aref, kwargs, numpy_name);
       // }
       is_kwd = true;
     }
@@ -740,14 +740,14 @@ bool FunctionSignature::parse(VALUE self, VALUE args, VALUE kwargs, VALUE dst[],
     } else if (raise_exception) {
       if (is_kwd) {
         // foo(): argument 'other' must be str, not int
-        rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, not %s",
+        throw Rice::Exception(rb_eArgError, "%s(): argument '%s' must be %s, not %s",
             name.c_str(), param.name.c_str(), param.type_name().c_str(),
-            rb_obj_classname(obj));
+            Rice::detail::protect(rb_obj_classname, obj));
       } else {
         // foo(): argument 'other' (position 2) must be str, not int
-        rb_raise(rb_eArgError, "%s(): argument '%s' (position %ld) must be %s, not %s",
+        throw Rice::Exception(rb_eArgError, "%s(): argument '%s' (position %ld) must be %s, not %s",
             name.c_str(), param.name.c_str(), static_cast<long>(arg_pos + 1),
-            param.type_name().c_str(), rb_obj_classname(obj));
+            param.type_name().c_str(), Rice::detail::protect(rb_obj_classname, obj));
       }
     } else {
       return false;

data/ext/torch/ruby_arg_parser.h

@@ -165,10 +165,10 @@ inline std::array<at::Tensor, N> RubyArgs::tensorlist_n(int i) {
   Check_Type(arg, T_ARRAY);
   auto size = RARRAY_LEN(arg);
   if (size != N) {
-    rb_raise(rb_eArgError, "expected array of %d elements but got %d", N, static_cast<int>(size));
+    throw Rice::Exception(rb_eArgError, "expected array of %d elements but got %d", N, static_cast<int>(size));
   }
   for (int idx = 0; idx < size; idx++) {
-    VALUE obj = rb_ary_entry(arg, idx);
+    VALUE obj = Rice::detail::protect(rb_ary_entry, arg, idx);
     res[idx] = Rice::detail::From_Ruby<Tensor>().convert(obj);
   }
   return res;
@@ -202,13 +202,13 @@ inline std::vector<int64_t> RubyArgs::intlistWithDefault(int i, std::vector<int6
   size = RARRAY_LEN(arg);
   std::vector<int64_t> res(size);
   for (idx = 0; idx < size; idx++) {
-    VALUE obj = rb_ary_entry(arg, idx);
+    VALUE obj = Rice::detail::protect(rb_ary_entry, arg, idx);
     if (FIXNUM_P(obj)) {
       res[idx] = Rice::detail::From_Ruby<int64_t>().convert(obj);
     } else {
-      rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
+      throw Rice::Exception(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
           signature.name.c_str(), signature.params[i].name.c_str(),
-          signature.params[i].type_name().c_str(), rb_obj_classname(obj), idx + 1);
+          signature.params[i].type_name().c_str(), Rice::detail::protect(rb_obj_classname, obj), idx + 1);
     }
   }
   return res;
@@ -270,7 +270,7 @@ inline ScalarType RubyArgs::scalartype(int i) {
 
   auto it = dtype_map.find(args[i]);
   if (it == dtype_map.end()) {
-    rb_raise(rb_eArgError, "invalid dtype: %s", rb_id2name(rb_to_id(args[i])));
+    throw Rice::Exception(rb_eArgError, "invalid dtype: %s", Rice::detail::protect(rb_id2name, Rice::detail::protect(rb_to_id, args[i])));
   }
   return it->second;
 }
@@ -317,13 +317,13 @@ inline c10::OptionalArray<double> RubyArgs::doublelistOptional(int i) {
   auto size = RARRAY_LEN(arg);
   std::vector<double> res(size);
   for (idx = 0; idx < size; idx++) {
-    VALUE obj = rb_ary_entry(arg, idx);
+    VALUE obj = Rice::detail::protect(rb_ary_entry, arg, idx);
     if (FIXNUM_P(obj) || RB_FLOAT_TYPE_P(obj)) {
       res[idx] = Rice::detail::From_Ruby<double>().convert(obj);
     } else {
-      rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
+      throw Rice::Exception(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
           signature.name.c_str(), signature.params[i].name.c_str(),
-          signature.params[i].type_name().c_str(), rb_obj_classname(obj), idx + 1);
+          signature.params[i].type_name().c_str(), Rice::detail::protect(rb_obj_classname, obj), idx + 1);
     }
   }
   return res;
@@ -338,7 +338,7 @@ inline at::Layout RubyArgs::layout(int i) {
 
   auto it = layout_map.find(args[i]);
   if (it == layout_map.end()) {
-    rb_raise(rb_eArgError, "invalid layout: %s", rb_id2name(rb_to_id(args[i])));
+    throw Rice::Exception(rb_eArgError, "invalid layout: %s", Rice::detail::protect(rb_id2name, Rice::detail::protect(rb_to_id, args[i])));
   }
   return it->second;
 }
@@ -358,7 +358,7 @@ inline at::Device RubyArgs::device(int i) {
     return at::Device("cpu");
   }
   if (RB_TYPE_P(args[i], T_STRING)) {
-    const std::string &device_str = THPUtils_unpackString(args[i]);
+    const std::string& device_str = THPUtils_unpackString(args[i]);
     return at::Device(device_str);
   }
   return Rice::detail::From_Ruby<at::Device>().convert(args[i]);
@@ -461,22 +461,22 @@ struct RubyArgParser {
 
       // Check deprecated signatures last
       std::stable_partition(signatures_.begin(), signatures_.end(),
-        [](const FunctionSignature & sig) {
+        [](const FunctionSignature& sig) {
           return !sig.deprecated;
         });
     }
 
     template<int N>
-    inline RubyArgs parse(VALUE self, int argc, VALUE* argv, ParsedArgs<N> &dst) {
+    inline RubyArgs parse(VALUE self, int argc, VALUE* argv, ParsedArgs<N>& dst) {
       if (N < max_args) {
-        rb_raise(rb_eArgError, "RubyArgParser: dst ParsedArgs buffer does not have enough capacity, expected %d (got %d)", static_cast<int>(max_args), N);
+        throw Rice::Exception(rb_eArgError, "RubyArgParser: dst ParsedArgs buffer does not have enough capacity, expected %d (got %d)", static_cast<int>(max_args), N);
       }
       return raw_parse(self, argc, argv, dst.args);
     }
 
     inline RubyArgs raw_parse(VALUE self, int argc, VALUE* argv, VALUE parsed_args[]) {
       VALUE args, kwargs;
-      rb_scan_args(argc, argv, "*:", &args, &kwargs);
+      Rice::detail::protect(rb_scan_args, argc, argv, "*:", &args, &kwargs);
 
       if (signatures_.size() == 1) {
         auto& signature = signatures_[0];
@@ -493,7 +493,7 @@ struct RubyArgParser {
       print_error(self, args, kwargs, parsed_args);
 
       // TODO better message
-      rb_raise(rb_eArgError, "No matching signatures");
+      throw Rice::Exception(rb_eArgError, "No matching signatures");
     }
 
     void print_error(VALUE self, VALUE args, VALUE kwargs, VALUE parsed_args[]) {

data/ext/torch/templates.h

@@ -54,8 +54,8 @@ namespace Rice::detail {
 
     explicit To_Ruby(Arg* arg) : arg_(arg) { }
 
-    VALUE convert(c10::complex<T> const& x) {
-      return rb_dbl_complex_new(x.real(), x.imag());
+    VALUE convert(const c10::complex<T>& x) {
+      return protect(rb_dbl_complex_new, x.real(), x.imag());
     }
 
   private:
@@ -72,8 +72,8 @@ namespace Rice::detail {
     double is_convertible(VALUE value) { return Convertible::Exact; }
 
     c10::complex<T> convert(VALUE x) {
-      VALUE real = rb_funcall(x, rb_intern("real"), 0);
-      VALUE imag = rb_funcall(x, rb_intern("imag"), 0);
+      VALUE real = protect(rb_funcall, x, rb_intern("real"), 0);
+      VALUE imag = protect(rb_funcall, x, rb_intern("imag"), 0);
       return c10::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imag));
     }
 

data/ext/torch/tensor.cpp

@@ -1,4 +1,6 @@
+#include <optional>
 #include <string>
+#include <string_view>
 #include <vector>
 
 #include <torch/torch.h>
@@ -28,15 +30,15 @@ Array flat_data(Tensor& tensor) {
 Rice::Class rb_cTensor;
 
 std::vector<TensorIndex> index_vector(Array a) {
-  Object obj;
-
   std::vector<TensorIndex> indices;
   indices.reserve(a.size());
 
   for (long i = 0; i < a.size(); i++) {
-    obj = a[i];
+    Object obj(a[i]);
 
-    if (obj.is_instance_of(rb_cInteger)) {
+    if (obj.is_nil()) {
+      indices.push_back(torch::indexing::None);
+    } else if (obj.is_instance_of(rb_cInteger)) {
       indices.push_back(Rice::detail::From_Ruby<int64_t>().convert(obj.value()));
     } else if (obj.is_instance_of(rb_cRange)) {
       torch::optional<c10::SymInt> start_index = torch::nullopt;
@@ -64,12 +66,10 @@ std::vector<TensorIndex> index_vector(Array a) {
       indices.push_back(torch::indexing::Slice(start_index, stop_index));
     } else if (obj.is_instance_of(rb_cTensor)) {
       indices.push_back(Rice::detail::From_Ruby<Tensor>().convert(obj.value()));
-    } else if (obj.is_nil()) {
-      indices.push_back(torch::indexing::None);
-    } else if (obj == Rice::True || obj == Rice::False) {
+    } else if (obj.value() == Qtrue || obj.value() == Qfalse) {
       indices.push_back(Rice::detail::From_Ruby<bool>().convert(obj.value()));
     } else {
-      throw Rice::Exception(rb_eArgError, "Unsupported index type: %s", rb_obj_classname(obj));
+      throw Rice::Exception(rb_eArgError, "Unsupported index type: %s", Rice::detail::protect(rb_obj_classname, obj.value()));
     }
   }
   return indices;
@@ -102,15 +102,13 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
   add_tensor_functions(rb_cTensor);
   THPVariableClass = rb_cTensor.value();
 
-  rb_define_method(rb_cTensor, "backward", (VALUE (*)(...)) tensor__backward, -1);
+  rb_define_method(rb_cTensor, "backward", tensor__backward, -1);
 
   rb_cTensor
     .define_method("cuda?", [](Tensor& self) { return self.is_cuda(); })
     .define_method("mps?", [](Tensor& self) { return self.is_mps(); })
     .define_method("sparse?", [](Tensor& self) { return self.is_sparse(); })
     .define_method("quantized?", [](Tensor& self) { return self.is_quantized(); })
-    .define_method("dim", [](Tensor& self) { return self.dim(); })
-    .define_method("numel", [](Tensor& self) { return self.numel(); })
     .define_method("element_size", [](Tensor& self) { return self.element_size(); })
     .define_method("requires_grad", [](Tensor& self) { return self.requires_grad(); })
     .define_method(
@@ -128,7 +126,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
       "shape",
       [](Tensor& self) {
         Array a;
-        for (auto &size : self.sizes()) {
+        for (const auto& size : self.sizes()) {
           a.push(size, false);
         }
         return a;
@@ -137,7 +135,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
       "_strides",
       [](Tensor& self) {
         Array a;
-        for (auto &stride : self.strides()) {
+        for (const auto& stride : self.strides()) {
           a.push(stride, false);
         }
         return a;
@@ -154,11 +152,6 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
         auto vec = index_vector(indices);
         return self.index_put_(vec, value);
       })
-    .define_method(
-      "contiguous?",
-      [](Tensor& self) {
-        return self.is_contiguous();
-      })
     .define_method(
       "_requires_grad!",
       [](Tensor& self, bool requires_grad) {
@@ -168,7 +161,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
       "grad",
       [](Tensor& self) {
         auto grad = self.grad();
-        return grad.defined() ? Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Rice::Nil;
+        return grad.defined() ? std::optional<torch::Tensor>{grad} : std::nullopt;
       })
     // can't use grad=
     // assignment methods fail with Ruby 3.0
@@ -184,15 +177,15 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
 
         // TODO support sparse grad
         if (!grad.options().type_equal(self.options())) {
-          rb_raise(rb_eArgError, "assigned grad has data of a different type");
+          throw Rice::Exception(rb_eArgError, "assigned grad has data of a different type");
         }
 
         if (self.is_cuda() && grad.get_device() != self.get_device()) {
-          rb_raise(rb_eArgError, "assigned grad has data located on a different device");
+          throw Rice::Exception(rb_eArgError, "assigned grad has data located on a different device");
         }
 
         if (!self.sizes().equals(grad.sizes())) {
-          rb_raise(rb_eArgError, "assigned grad has data of a different size");
+          throw Rice::Exception(rb_eArgError, "assigned grad has data of a different size");
         }
 
         self.mutable_grad() = grad;
@@ -234,8 +227,8 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
           tensor = tensor.contiguous();
         }
 
-        auto data_ptr = (const char *) tensor.data_ptr();
-        return std::string(data_ptr, tensor.numel() * tensor.element_size());
+        auto data_ptr = static_cast<const char *>(tensor.data_ptr());
+        return Rice::String(std::string_view(data_ptr, tensor.numel() * tensor.element_size()));
       })
     // for TorchVision
     .define_method(

data/ext/torch/torch.cpp

@@ -12,7 +12,7 @@
 #include "utils.h"
 
 template<typename T>
-torch::Tensor make_tensor(Rice::Array a, const std::vector<int64_t> &size, const torch::TensorOptions &options) {
+torch::Tensor make_tensor(Rice::Array a, const std::vector<int64_t>& size, const torch::TensorOptions& options) {
   std::vector<T> vec;
   vec.reserve(a.size());
   for (long i = 0; i < a.size(); i++) {
@@ -61,13 +61,13 @@ void init_torch(Rice::Module& m) {
     // begin operations
     .define_singleton_function(
       "_save",
-      [](const torch::IValue &value) {
+      [](const torch::IValue& value) {
         auto v = torch::pickle_save(value);
-        return Rice::Object(rb_str_new(v.data(), v.size()));
+        return Rice::Object(Rice::detail::protect(rb_str_new, v.data(), v.size()));
       })
     .define_singleton_function(
       "_load",
-      [](const std::string &filename) {
+      [](const std::string& filename) {
         // https://github.com/pytorch/pytorch/issues/20356#issuecomment-567663701
         std::ifstream input(filename, std::ios::binary);
         std::vector<char> bytes(
@@ -78,13 +78,13 @@ void init_torch(Rice::Module& m) {
       })
     .define_singleton_function(
       "_from_blob",
-      [](Rice::String s, const std::vector<int64_t> &size, const torch::TensorOptions &options) {
+      [](Rice::String s, const std::vector<int64_t>& size, const torch::TensorOptions& options) {
         void *data = const_cast<char *>(s.c_str());
         return torch::from_blob(data, size, options);
       })
     .define_singleton_function(
       "_tensor",
-      [](Rice::Array a, const std::vector<int64_t> &size, const torch::TensorOptions &options) {
+      [](Rice::Array a, const std::vector<int64_t>& size, const torch::TensorOptions& options) {
         auto dtype = options.dtype();
         if (dtype == torch::kByte) {
           return make_tensor<uint8_t>(a, size, options);

data/ext/torch/utils.h

@@ -8,7 +8,7 @@
 #include <rice/stl.hpp>
 
 static_assert(
-  TORCH_VERSION_MAJOR == 2 && TORCH_VERSION_MINOR == 10,
+  TORCH_VERSION_MAJOR == 2 && TORCH_VERSION_MINOR == 12,
   "Incompatible LibTorch version"
 );
 
@@ -50,17 +50,17 @@ inline bool THPUtils_checkScalar(VALUE obj) {
 }
 
 inline bool THPDevice_Check(VALUE obj) {
-  return rb_obj_is_kind_of(obj, THPDeviceClass);
+  return Rice::detail::protect(rb_obj_is_kind_of, obj, THPDeviceClass);
 }
 
 inline bool THPGenerator_Check(VALUE obj) {
-  return rb_obj_is_kind_of(obj, THPGeneratorClass);
+  return Rice::detail::protect(rb_obj_is_kind_of, obj, THPGeneratorClass);
 }
 
 inline bool THPVariable_Check(VALUE obj) {
-  return rb_obj_is_kind_of(obj, THPVariableClass);
+  return Rice::detail::protect(rb_obj_is_kind_of, obj, THPVariableClass);
 }
 
 inline bool THPVariable_CheckExact(VALUE obj) {
-  return rb_obj_is_instance_of(obj, THPVariableClass);
+  return Rice::detail::protect(rb_obj_is_instance_of, obj, THPVariableClass);
 }

data/ext/torch/wrap_outputs.h

@@ -15,32 +15,34 @@ inline VALUE wrap(double x) {
   return Rice::detail::To_Ruby<double>().convert(x);
 }
 
-inline VALUE wrap(torch::Tensor x) {
+inline VALUE wrap(const torch::Tensor& x) {
   return Rice::detail::To_Ruby<torch::Tensor>().convert(x);
 }
 
-inline VALUE wrap(torch::Scalar x) {
+inline VALUE wrap(const torch::Scalar& x) {
   return Rice::detail::To_Ruby<torch::Scalar>().convert(x);
 }
 
-inline VALUE wrap(torch::ScalarType x) {
+inline VALUE wrap(const torch::ScalarType& x) {
   return Rice::detail::To_Ruby<torch::ScalarType>().convert(x);
 }
 
-inline VALUE wrap(torch::QScheme x) {
+inline VALUE wrap(const torch::QScheme& x) {
   return Rice::detail::To_Ruby<torch::QScheme>().convert(x);
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     2,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x))
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, torch::Tensor>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     3,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -48,8 +50,9 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     4,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -58,8 +61,9 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch:
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     5,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -69,8 +73,9 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch:
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     4,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -79,8 +84,9 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_
   );
 }
 
-inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<torch::Tensor, torch::Tensor, double, int64_t>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     4,
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
@@ -89,16 +95,17 @@ inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
   );
 }
 
-inline VALUE wrap(torch::TensorList x) {
-  auto a = rb_ary_new2(x.size());
-  for (auto t : x) {
-    rb_ary_push(a, Rice::detail::To_Ruby<torch::Tensor>().convert(t));
+inline VALUE wrap(const torch::TensorList& x) {
+  auto a = Rice::detail::protect(rb_ary_new2, x.size());
+  for (const auto& t : x) {
+    Rice::detail::protect(rb_ary_push, a, Rice::detail::To_Ruby<torch::Tensor>().convert(t));
   }
   return a;
 }
 
-inline VALUE wrap(std::tuple<double, double> x) {
-  return rb_ary_new3(
+inline VALUE wrap(const std::tuple<double, double>& x) {
+  return Rice::detail::protect(
+    rb_ary_new3,
     2,
     Rice::detail::To_Ruby<double>().convert(std::get<0>(x)),
     Rice::detail::To_Ruby<double>().convert(std::get<1>(x))