backend add locking mechanism

Author: caillonantoine

src/backend/backend.cpp

@@ -4,7 +4,6 @@
 #include <iostream>
 #include <stdlib.h>
 
-
 #define CUDA torch::kCUDA
 #define CPU torch::kCPU
 
@@ -51,6 +50,7 @@ void Backend::perform(std::vector<float *> in_buffer,
 
   // PROCESS TENSOR
   at::Tensor tensor_out;
+  std::unique_lock<std::mutex> model_lock(m_model_mutex);
   try {
     tensor_out = m_model.get_method(method)(inputs).toTensor();
     tensor_out = tensor_out.repeat_interleave(out_ratio).reshape(
@@ -59,6 +59,8 @@ void Backend::perform(std::vector<float *> in_buffer,
     std::cerr << e.what() << '\n';
     return;
   }
+  model_lock.unlock();
+
   int out_batches(tensor_out.size(0)), out_channels(tensor_out.size(1)),
       out_n_vec(tensor_out.size(2));
 
@@ -94,6 +96,7 @@ int Backend::load(std::string path) {
     }
     m_model = model;
     m_loaded = 1;
+    m_available_methods = get_available_methods();
     m_path = path;
     return 0;
   } catch (const std::exception &e) {
@@ -102,11 +105,10 @@ int Backend::load(std::string path) {
   }
 }
 
-int Backend::reload(){
-  return load(m_path);
-}
+int Backend::reload() { return load(m_path); }
 
 bool Backend::has_method(std::string method_name) {
+  std::unique_lock<std::mutex> model_lock(m_model_mutex);
   for (const auto &m : m_model.get_methods()) {
     if (m.name() == method_name)
       return true;
@@ -126,25 +128,32 @@ std::vector<std::string> Backend::get_available_methods() {
   std::vector<std::string> methods;
   try {
     std::vector<c10::IValue> dumb_input = {};
+
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     auto methods_from_model =
         m_model.get_method("get_methods")(dumb_input).toList();
+    model_lock.unlock();
+
     for (int i = 0; i < methods_from_model.size(); i++) {
       methods.push_back(methods_from_model.get(i).toStringRef());
     }
   } catch (...) {
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     for (const auto &m : m_model.get_methods()) {
       try {
         auto method_params = m_model.attr(m.name() + "_params");
         methods.push_back(m.name());
       } catch (...) {
       }
     }
+    model_lock.unlock();
   }
   return methods;
 }
 
 std::vector<std::string> Backend::get_available_attributes() {
   std::vector<std::string> attributes;
+  std::unique_lock<std::mutex> model_lock(m_model_mutex);
   for (const auto &attribute : m_model.named_attributes())
     attributes.push_back(attribute.name);
   return attributes;
@@ -154,44 +163,56 @@ std::vector<std::string> Backend::get_settable_attributes() {
   std::vector<std::string> attributes;
   try {
     std::vector<c10::IValue> dumb_input = {};
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     auto methods_from_model =
         m_model.get_method("get_attributes")(dumb_input).toList();
+    model_lock.unlock();
     for (int i = 0; i < methods_from_model.size(); i++) {
       attributes.push_back(methods_from_model.get(i).toStringRef());
     }
   } catch (...) {
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     for (const auto &a : m_model.named_attributes()) {
       try {
         auto method_params = m_model.attr(a.name + "_params");
         attributes.push_back(a.name);
       } catch (...) {
       }
     }
+    model_lock.unlock();
   }
   return attributes;
 }
 
 std::vector<c10::IValue> Backend::get_attribute(std::string attribute_name) {
   std::string attribute_getter_name = "get_" + attribute_name;
   try {
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     auto attribute_getter = m_model.get_method(attribute_getter_name);
+    model_lock.unlock();
   } catch (...) {
     throw "getter for attribute " + attribute_name + " not found in model";
   }
   std::vector<c10::IValue> getter_inputs = {}, attributes;
   try {
     try {
+      std::unique_lock<std::mutex> model_lock(m_model_mutex);
       attributes = m_model.get_method(attribute_getter_name)(getter_inputs)
                        .toList()
                        .vec();
+      model_lock.unlock();
     } catch (...) {
+      std::unique_lock<std::mutex> model_lock(m_model_mutex);
       auto output_tuple =
           m_model.get_method(attribute_getter_name)(getter_inputs).toTuple();
       attributes = (*output_tuple.get()).elements();
+      model_lock.unlock();
     }
   } catch (...) {
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     attributes.push_back(
         m_model.get_method(attribute_getter_name)(getter_inputs));
+    model_lock.unlock();
   }
   return attributes;
 }
@@ -201,7 +222,9 @@ std::string Backend::get_attribute_as_string(std::string attribute_name) {
   // finstringd arguments
   torch::Tensor setter_params;
   try {
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     setter_params = m_model.attr(attribute_name + "_params").toTensor();
+    model_lock.unlock();
   } catch (...) {
     throw "parameters to set attribute " + attribute_name +
         " not found in model";
@@ -248,14 +271,18 @@ void Backend::set_attribute(std::string attribute_name,
   // find setter
   std::string attribute_setter_name = "set_" + attribute_name;
   try {
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     auto attribute_setter = m_model.get_method(attribute_setter_name);
+    model_lock.unlock();
   } catch (...) {
     throw "setter for attribute " + attribute_name + " not found in model";
   }
   // find arguments
   torch::Tensor setter_params;
   try {
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     setter_params = m_model.attr(attribute_name + "_params").toTensor();
+    model_lock.unlock();
   } catch (...) {
     throw "parameters to set attribute " + attribute_name +
         " not found in model";
@@ -288,7 +315,9 @@ void Backend::set_attribute(std::string attribute_name,
     }
   }
   try {
+    std::unique_lock<std::mutex> model_lock(m_model_mutex);
     auto setter_out = m_model.get_method(attribute_setter_name)(setter_inputs);
+    model_lock.unlock();
     int setter_result = setter_out.toInt();
     if (setter_result != 0) {
       throw "setter returned -1";
@@ -299,12 +328,14 @@ void Backend::set_attribute(std::string attribute_name,
 }
 
 std::vector<int> Backend::get_method_params(std::string method) {
-  auto am = get_available_methods();
   std::vector<int> params;
 
-  if (std::find(am.begin(), am.end(), method) != am.end()) {
+  if (std::find(m_available_methods.begin(), m_available_methods.end(),
+                method) != m_available_methods.end()) {
     try {
+      std::unique_lock<std::mutex> model_lock(m_model_mutex);
       auto p = m_model.attr(method + "_params").toTensor();
+      model_lock.unlock();
       for (int i(0); i < 4; i++)
         params.push_back(p[i].item().to<int>());
     } catch (...) {
@@ -315,8 +346,7 @@ std::vector<int> Backend::get_method_params(std::string method) {
 
 int Backend::get_higher_ratio() {
   int higher_ratio = 1;
-  auto model_methods = get_available_methods();
-  for (const auto &method : model_methods) {
+  for (const auto &method : m_available_methods) {
     auto params = get_method_params(method);
     if (!params.size())
       continue; // METHOD NOT USABLE, SKIPPING

src/backend/backend.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <mutex>
 #include <string>
 #include <torch/script.h>
 #include <torch/torch.h>
@@ -9,6 +10,8 @@ class Backend {
   torch::jit::script::Module m_model;
   int m_loaded;
   std::string m_path;
+  std::mutex m_model_mutex;
+  std::vector<std::string> m_available_methods;
 
 public:
   Backend();

src/frontend/maxmsp/mcs.nn_tilde/mcs.nn_tilde.cpp

@@ -38,6 +38,7 @@ class mc_bnn_tilde : public object<mc_bnn_tilde>, public mc_operator<> {
   // INLETS OUTLETS
   std::vector<std::unique_ptr<inlet<>>> m_inlets;
   std::vector<std::unique_ptr<outlet<>>> m_outlets;
+
   // CHANNELS
   std::vector<int> input_chans;
   int get_batches();

src/frontend/maxmsp/nn_tilde/nn_tilde.cpp

@@ -54,8 +54,6 @@ class nn : public object<nn>, public vector_operator<> {
   void operator()(audio_bundle input, audio_bundle output);
   void perform(audio_bundle input, audio_bundle output);
 
-  // using vector_operator::operator();
-
   // ONLY FOR DOCUMENTATION
   argument<symbol> path_arg{this, "model path",
                             "Absolute path to the pretrained model."};