refactor: Migrate raw function pointers to std::function

cs/cli/vowpalwabbit.cpp

@@ -17,6 +17,8 @@
 #include "vw/json_parser/parse_example_json.h"
 #include "vw/core/shared_data.h"
 
+#include <functional>
+
 using namespace System;
 using namespace System::Collections::Generic;
 using namespace System::Text;
@@ -34,12 +36,12 @@ VowpalWabbit::VowpalWabbit(VowpalWabbitSettings^ settings)
     auto total = settings->ParallelOptions->MaxDegreeOfParallelism;
 
     if (settings->Root == nullptr)
-    { m_vw->all_reduce = new all_reduce_threads(total, settings->Node);
+    { m_vw->all_reduce.reset(new all_reduce_threads(total, settings->Node));
     }
     else
-    { auto parent_all_reduce = (all_reduce_threads*)settings->Root->m_vw->all_reduce;
+    { auto parent_all_reduce = (all_reduce_threads*)settings->Root->m_vw->all_reduce.get();
 
-      m_vw->all_reduce = new all_reduce_threads(parent_all_reduce, total, settings->Node);
+      m_vw->all_reduce.reset(new all_reduce_threads(parent_all_reduce, total, settings->Node));
     }
   }
 
@@ -172,7 +174,7 @@ void VowpalWabbit::Learn(List<VowpalWabbitExample^>^ examples)
     m_vw->learn(ex_coll);
 
     // as this is not a ring-based example it is not freed
-    as_multiline(m_vw->l)->finish_example(*m_vw, ex_coll);
+    require_multiline(m_vw->l)->finish_example(*m_vw, ex_coll);
   }
   CATCHRETHROW
   finally{ }
@@ -189,10 +191,10 @@ void VowpalWabbit::Predict(List<VowpalWabbitExample^>^ examples)
       ex_coll.push_back(pex);
     }
 
-    as_multiline(m_vw->l)->predict(ex_coll);
+    require_multiline(m_vw->l)->predict(ex_coll);
 
     // as this is not a ring-based example it is not freed
-    as_multiline(m_vw->l)->finish_example(*m_vw, ex_coll);
+    require_multiline(m_vw->l)->finish_example(*m_vw, ex_coll);
   }
   CATCHRETHROW
     finally{ }
@@ -210,7 +212,7 @@ void VowpalWabbit::Learn(VowpalWabbitExample^ ex)
   { m_vw->learn(*ex->m_example);
 
     // as this is not a ring-based example it is not free'd
-    as_singleline(m_vw->l)->finish_example(*m_vw, *ex->m_example);
+    require_singleline(m_vw->l)->finish_example(*m_vw, *ex->m_example);
   }
   CATCHRETHROW
 }
@@ -231,7 +233,7 @@ generic<typename T> T VowpalWabbit::Learn(VowpalWabbitExample^ ex, IVowpalWabbit
     auto prediction = predictionFactory->Create(m_vw, ex->m_example);
 
     // as this is not a ring-based example it is not free'd
-    as_singleline(m_vw->l)->finish_example(*m_vw, *ex->m_example);
+    require_singleline(m_vw->l)->finish_example(*m_vw, *ex->m_example);
 
     return prediction;
   }
@@ -246,10 +248,10 @@ void VowpalWabbit::Predict(VowpalWabbitExample^ ex)
 #endif
 
   try
-  { as_singleline(m_vw->l)->predict(*ex->m_example);
+  { require_singleline(m_vw->l)->predict(*ex->m_example);
 
     // as this is not a ring-based example it is not free'd
-  as_singleline(m_vw->l)->finish_example(*m_vw, *ex->m_example);
+  require_singleline(m_vw->l)->finish_example(*m_vw, *ex->m_example);
   }
   CATCHRETHROW
 }
@@ -262,12 +264,12 @@ generic<typename T> T VowpalWabbit::Predict(VowpalWabbitExample^ ex, IVowpalWabb
 #endif
 
   try
-  { as_singleline(m_vw->l)->predict(*ex->m_example);
+  { require_singleline(m_vw->l)->predict(*ex->m_example);
 
     auto prediction = predictionFactory->Create(m_vw, ex->m_example);
 
     // as this is not a ring-based example it is not free'd
-    as_singleline(m_vw->l)->finish_example(*m_vw, *ex->m_example);
+    require_singleline(m_vw->l)->finish_example(*m_vw, *ex->m_example);
 
     return prediction;
   }
@@ -320,9 +322,9 @@ List<VowpalWabbitExample^>^ VowpalWabbit::ParseDecisionServiceJson(cli::array<By
 			VW::parsers::json::decision_service_interaction interaction;
 
 			if (m_vw->audit)
-				VW::parsers::json::read_line_decision_service_json<true>(*m_vw, examples, reinterpret_cast<char*>(data), length, copyJson, get_example_from_pool, &state, &interaction);
+				VW::parsers::json::read_line_decision_service_json<true>(*m_vw, examples, reinterpret_cast<char*>(data), length, copyJson, std::bind(get_example_from_pool, &state), &interaction);
 			else
-				VW::parsers::json::read_line_decision_service_json<false>(*m_vw, examples, reinterpret_cast<char*>(data), length, copyJson, get_example_from_pool, &state, &interaction);
+				VW::parsers::json::read_line_decision_service_json<false>(*m_vw, examples, reinterpret_cast<char*>(data), length, copyJson, std::bind(get_example_from_pool, &state), &interaction);
 
 			// finalize example
 			VW::setup_examples(*m_vw, examples);
@@ -384,9 +386,9 @@ List<VowpalWabbitExample^>^ VowpalWabbit::ParseDecisionServiceJson(cli::array<By
 			  interior_ptr<ParseJsonState^> state_ptr = &state;
 
 			  if (m_vw->audit)
-				VW::parsers::json::read_line_json<true>(*m_vw, examples, reinterpret_cast<char*>(valueHandle.AddrOfPinnedObject().ToPointer()), (size_t)bytes->Length, get_example_from_pool, &state);
+				VW::parsers::json::read_line_json<true>(*m_vw, examples, reinterpret_cast<char*>(valueHandle.AddrOfPinnedObject().ToPointer()), (size_t)bytes->Length, std::bind(get_example_from_pool, &state));
 			  else
-				VW::parsers::json::read_line_json<false>(*m_vw, examples, reinterpret_cast<char*>(valueHandle.AddrOfPinnedObject().ToPointer()), (size_t)bytes->Length, get_example_from_pool, &state);
+				VW::parsers::json::read_line_json<false>(*m_vw, examples, reinterpret_cast<char*>(valueHandle.AddrOfPinnedObject().ToPointer()), (size_t)bytes->Length, std::bind(get_example_from_pool, &state));
 
 			  // finalize example
 			  VW::setup_examples(*m_vw, examples);

cs/vw.net.native/vw.net.workspace.cc

@@ -206,15 +206,15 @@ API size_t WorkspaceHashFeature(
 API void WorkspaceSetUpAllReduceThreadsRoot(vw_net_native::workspace_context* workspace, size_t total, size_t node)
 {
   workspace->vw->selected_all_reduce_type = VW::all_reduce_type::THREAD;
-  workspace->vw->all_reduce = new VW::all_reduce_threads(total, node);
+  workspace->vw->all_reduce.reset(new VW::all_reduce_threads(total, node));
 }
 
 API void WorkspaceSetUpAllReduceThreadsNode(vw_net_native::workspace_context* workspace, size_t total, size_t node,
     vw_net_native::workspace_context* root_workspace)
 {
   workspace->vw->selected_all_reduce_type = VW::all_reduce_type::THREAD;
-  workspace->vw->all_reduce =
-      new VW::all_reduce_threads((VW::all_reduce_threads*)root_workspace->vw->all_reduce, total, node);
+  workspace->vw->all_reduce.reset(
+      new VW::all_reduce_threads((VW::all_reduce_threads*)root_workspace->vw->all_reduce.get(), total, node));
 }
 
 API vw_net_native::ERROR_CODE WorkspaceRunMultiPass(
@@ -269,11 +269,11 @@ API vw_net_native::ERROR_CODE WorkspacePredict(vw_net_native::workspace_context*
 {
   try
   {
-    as_singleline(workspace->vw->l)->predict(*ex);
+    require_singleline(workspace->vw->l)->predict(*ex);
 
     if (create_prediction != nullptr) { create_prediction(); }
 
-    as_singleline(workspace->vw->l)->finish_example(*workspace->vw, *ex);
+    require_singleline(workspace->vw->l)->finish_example(*workspace->vw, *ex);
 
     return VW::experimental::error_code::success;
   }
@@ -289,7 +289,7 @@ API vw_net_native::ERROR_CODE WorkspaceLearn(vw_net_native::workspace_context* w
 
     if (create_prediction != nullptr) { create_prediction(); }
 
-    as_singleline(workspace->vw->l)->finish_example(*workspace->vw, *ex);
+    require_singleline(workspace->vw->l)->finish_example(*workspace->vw, *ex);
 
     return VW::experimental::error_code::success;
   }
@@ -301,11 +301,11 @@ API vw_net_native::ERROR_CODE WorkspacePredictMulti(vw_net_native::workspace_con
 {
   try
   {
-    as_multiline(workspace->vw->l)->predict(*ex_coll);
+    require_multiline(workspace->vw->l)->predict(*ex_coll);
 
     if (create_prediction != nullptr) { create_prediction(); }
 
-    as_multiline(workspace->vw->l)->finish_example(*workspace->vw, *ex_coll);
+    require_multiline(workspace->vw->l)->finish_example(*workspace->vw, *ex_coll);
 
     return VW::experimental::error_code::success;
   }
@@ -321,7 +321,7 @@ API vw_net_native::ERROR_CODE WorkspaceLearnMulti(vw_net_native::workspace_conte
 
     if (create_prediction != nullptr) { create_prediction(); }
 
-    as_multiline(workspace->vw->l)->finish_example(*workspace->vw, *ex_coll);
+    require_multiline(workspace->vw->l)->finish_example(*workspace->vw, *ex_coll);
 
     return VW::experimental::error_code::success;
   }

cs/vw.net.native/vw.net.workspace_parse_json.cc

@@ -1,6 +1,8 @@
 #include "vw.net.workspace.h"
 #include "vw/json_parser/parse_example_json.h"
 
+#include <functional>
+
 API vw_net_native::ERROR_CODE WorkspaceParseJson(vw_net_native::workspace_context* workspace, char* json, size_t length,
     vw_net_native::example_pool_get_example_fn get_example, void* example_pool_context,
     VW::experimental::api_status* status)
@@ -15,12 +17,12 @@ API vw_net_native::ERROR_CODE WorkspaceParseJson(vw_net_native::workspace_contex
     if (workspace->vw->audit)
     {
       VW::parsers::json::read_line_json<true>(
-          *workspace->vw, examples, json, length, get_example, example_pool_context);
+          *workspace->vw, examples, json, length, std::bind(get_example, example_pool_context));
     }
     else
     {
       VW::parsers::json::read_line_json<false>(
-          *workspace->vw, examples, json, length, get_example, example_pool_context);
+          *workspace->vw, examples, json, length, std::bind(get_example, example_pool_context));
     }
 
     VW::setup_examples(*workspace->vw, examples);
@@ -48,13 +50,13 @@ API vw_net_native::ERROR_CODE WorkspaceParseDecisionServiceJson(vw_net_native::w
   {
     if (workspace->vw->audit)
     {
-      VW::parsers::json::read_line_decision_service_json<true>(
-          *workspace->vw, examples, actual_json, length, copy_json, get_example, example_pool_context, interaction);
+      VW::parsers::json::read_line_decision_service_json<true>(*workspace->vw, examples, actual_json, length, copy_json,
+          std::bind(get_example, example_pool_context), interaction);
     }
     else
     {
-      VW::parsers::json::read_line_decision_service_json<false>(
-          *workspace->vw, examples, actual_json, length, copy_json, get_example, example_pool_context, interaction);
+      VW::parsers::json::read_line_decision_service_json<false>(*workspace->vw, examples, actual_json, length,
+          copy_json, std::bind(get_example, example_pool_context), interaction);
     }
 
     VW::setup_examples(*workspace->vw, examples);

java/src/main/c++/jni_spark_vw.cc

@@ -843,7 +843,7 @@ JNIEXPORT void JNICALL Java_org_vowpalwabbit_spark_VowpalWabbitExample_learn(JNI
     all->learn(*ex);
 
     // as this is not a ring-based example it is not free'd
-    VW::LEARNER::as_singleline(all->l)->finish_example(*all, *ex);
+    all->l->finish_example(*all, *ex);
   }
   catch (...)
   {
@@ -862,7 +862,7 @@ JNIEXPORT jobject JNICALL Java_org_vowpalwabbit_spark_VowpalWabbitExample_predic
     all->predict(*ex);
 
     // as this is not a ring-based example it is not free'd
-    VW::LEARNER::as_singleline(all->l)->finish_example(*all, *ex);
+    all->l->finish_example(*all, *ex);
 
     return getJavaPrediction(env, all, ex);
   }

python/pylibvw.cc

@@ -81,15 +81,15 @@ class OptionManager : VW::config::typed_option_visitor
   // see pyvw.py class VWOption
   py::object m_py_opt_class;
   VW::config::options_i& m_opt;
-  std::vector<std::string>& m_enabled_reductions;
+  std::vector<std::string>& m_enabled_learners;
   std::string default_group_name;
 
   py::object* m_visitor_output_var;
 
 public:
-  OptionManager(VW::config::options_i& options, std::vector<std::string>& enabled_reductions, py::object py_class)
+  OptionManager(VW::config::options_i& options, std::vector<std::string>& enabled_learners, py::object py_class)
       : m_opt(options)
-      , m_enabled_reductions(enabled_reductions)
+      , m_enabled_learners(enabled_learners)
       , m_option_group_dic(options.get_collection_of_options())
       , m_py_opt_class(py_class)
   {
@@ -197,7 +197,7 @@ class OptionManager : VW::config::typed_option_visitor
     while (it != m_option_group_dic.end())
     {
       auto reduction_enabled =
-          std::find(m_enabled_reductions.begin(), m_enabled_reductions.end(), it->first) != m_enabled_reductions.end();
+          std::find(m_enabled_learners.begin(), m_enabled_learners.end(), it->first) != m_enabled_learners.end();
 
       if (((it->first).compare(default_group_name) != 0) && enabled_only && !reduction_enabled)
       {
@@ -347,7 +347,7 @@ py::dict get_learner_metrics(vw_ptr all)
 
   if (all->global_metrics.are_metrics_enabled())
   {
-    auto metrics = all->global_metrics.collect_metrics(all->l);
+    auto metrics = all->global_metrics.collect_metrics(all->l.get());
 
     python_dict_writer writer(dictionary);
     metrics.visit(writer);
@@ -370,9 +370,9 @@ search_ptr get_search_ptr(vw_ptr all)
 
 py::object get_options(vw_ptr all, py::object py_class, bool enabled_only)
 {
-  std::vector<std::string> enabled_reductions;
-  if (all->l) all->l->get_enabled_reductions(enabled_reductions);
-  auto opt_manager = OptionManager(*all->options, enabled_reductions, py_class);
+  std::vector<std::string> enabled_learners;
+  if (all->l) all->l->get_enabled_learners(enabled_learners);
+  auto opt_manager = OptionManager(*all->options, enabled_learners, py_class);
   return opt_manager.get_vw_option_pyobjects(enabled_only);
 }
 
@@ -391,14 +391,14 @@ std::string get_arguments(vw_ptr all)
   return serializer.str();
 }
 
-py::list get_enabled_reductions(vw_ptr all)
+py::list get_enabled_learners(vw_ptr all)
 {
-  py::list py_enabled_reductions;
-  std::vector<std::string> enabled_reductions;
-  if (all->l) all->l->get_enabled_reductions(enabled_reductions);
-  for (auto ex : enabled_reductions) { py_enabled_reductions.append(ex); }
+  py::list py_enabled_learners;
+  std::vector<std::string> enabled_learners;
+  if (all->l) all->l->get_enabled_learners(enabled_learners);
+  for (auto ex : enabled_learners) { py_enabled_learners.append(ex); }
 
-  return py_enabled_reductions;
+  return py_enabled_learners;
 }
 
 predictor_ptr get_predictor(search_ptr _sch, ptag my_tag)
@@ -529,25 +529,25 @@ multi_ex unwrap_example_list(py::list& ec)
   return ex_coll;
 }
 
-void my_finish_example(vw_ptr all, example_ptr ec) { as_singleline(all->l)->finish_example(*all, *ec); }
+void my_finish_example(vw_ptr all, example_ptr ec) { all->l->finish_example(*all, *ec); }
 
 void my_finish_multi_ex(vw_ptr& all, py::list& ec)
 {
   auto ex_col = unwrap_example_list(ec);
-  as_multiline(all->l)->finish_example(*all, ex_col);
+  all->l->finish_example(*all, ex_col);
 }
 
 void my_learn(vw_ptr all, example_ptr ec)
 {
-  if (ec->test_only) { as_singleline(all->l)->predict(*ec); }
+  if (ec->test_only) { all->l->predict(*ec); }
   else { all->learn(*ec.get()); }
 }
 
 std::string my_json_weights(vw_ptr all) { return all->dump_weights_to_json_experimental(); }
 
 float my_predict(vw_ptr all, example_ptr ec)
 {
-  as_singleline(all->l)->predict(*ec);
+  all->l->predict(*ec);
   return ec->partial_prediction;
 }
 
@@ -560,7 +560,7 @@ void predict_or_learn(vw_ptr& all, py::list& ec)
   if (learn)
     all->learn(ex_coll);
   else
-    as_multiline(all->l)->predict(ex_coll);
+    all->l->predict(ex_coll);
 }
 
 py::list my_parse(vw_ptr& all, char* str)
@@ -1420,7 +1420,11 @@ BOOST_PYTHON_MODULE(pylibvw)
       .def("audit_example", &my_audit_example, "print example audit information")
       .def("get_id", &get_model_id, "return the model id")
       .def("get_arguments", &get_arguments, "return the arguments after resolving all dependencies")
-      .def("get_enabled_reductions", &get_enabled_reductions, "return the list of names of the enabled reductions")
+
+      // this returns all learners, not just reduction learners, but the API was originally called
+      // get_enabled_reductions
+      .def("get_enabled_learners", &get_enabled_learners, "return the list of names of the enabled learners")
+      .def("get_enabled_reductions", &get_enabled_learners, "return the list of names of the enabled learners")
 
       .def("learn_multi", &my_learn_multi_ex, "given a list pyvw examples, learn (and predict) on those examples")
       .def("predict_multi", &my_predict_multi_ex, "given a list of pyvw examples, predict on that example")

test/benchmarks/CMakeLists.txt

@@ -8,6 +8,10 @@ if (NOT BUILD_ONLY_STANDALONE_BENCHMARKS)
   set(all_sources ${all_sources}
     input_format_benchmarks.cc
     benchmark_funcs.cc
+
+    # These are just for benchmarking specific standard library operations
+    #benchmark_std_function.cc
+    #benchmark_pointers.cc
   )
 endif()