improve submit messages (#384)

Author: ckrause

.vscode/settings.json

@@ -82,7 +82,9 @@
         "bit": "cpp",
         "charconv": "cpp",
         "execution": "cpp",
-        "numbers": "cpp"
+        "numbers": "cpp",
+        "forward_list": "cpp",
+        "print": "cpp"
     },
     "makefile.makeDirectory": "src",
     "c-cpp-flylint.clang.includePaths": [

CHANGELOG.md

@@ -2,6 +2,12 @@ To install or update LODA, please follow the [installation instructions](https:/
 
 ## [Unreleased]
 
+## v25.5.8
+
+### Enhancements
+
+* Improved log messages of `submit` command
+
 ## v25.3.29
 
 ### Features

src/cmd/commands.cpp

@@ -698,7 +698,7 @@ void Commands::lists() {
 }
 
 void Commands::compare(const std::string& path1, const std::string& path2) {
-  initLog(true);
+  initLog(false);
   Program p1 = OeisProgram::getProgramAndSeqId(path1).first;
   Program p2 = OeisProgram::getProgramAndSeqId(path2).first;
   auto id_str = Comments::getSequenceIdFromProgram(p1);
@@ -709,10 +709,7 @@ void Commands::compare(const std::string& path1, const std::string& path2) {
   if (seq.id < manager.getStats().program_usages.size()) {
     num_usages = manager.getStats().program_usages[seq.id];
   }
-  auto result = manager.getFinder().isOptimizedBetter(
-      p1, p2, seq, OeisSequence::EXTENDED_SEQ_LENGTH, num_usages);
-  if (result.empty()) {
-    result = "Worse or Equal";
-  }
-  std::cout << result << std::endl;
+  Log::get().info(manager.getFinder().compare(p1, p2, "First", "Second", seq,
+                                              OeisSequence::EXTENDED_SEQ_LENGTH,
+                                              num_usages));
 }

src/mine/README.md

@@ -9,6 +9,12 @@ the [Matcher](matcher.hpp) class. If a generated program matches a sequence and
 ![Mining architecture](../../images/mining-arch.svg)
 
 There are multiple generator and matcher implementations available. They are configured and combined in the central mining configuration file [miners.json](../../miners.default.json).
+A miner profile has the following basic properties:
+
+- "enabled": Boolean to easily enable or disable a profile.
+- "backoff": Boolean to control the back-off strategy during sequence matching.
+- "overwrite": Controls whether existing programs should be overwritten. Possible values are "none", "auto" or "all".
+
 See below for further details on the [program generation](#program-generation) and [sequence matching](#sequence-matching).
 
 ## Program Generation
@@ -115,8 +121,8 @@ Matchers are used to match generated programs to integer sequences. They include
 
 Matchers perform two operations:
 
-* **Reduce Sequences:** extract parameters from sequences and reduce sequences to more basic sequences.
-* **Extend Programs:** extend generated programs using the extracted sequence parameters so that they match a target sequence.
+- **Reduce Sequences:** extract parameters from sequences and reduce sequences to more basic sequences.
+- **Extend Programs:** extend generated programs using the extracted sequence parameters so that they match a target sequence.
 
 See the examples in the following sections for better understanding of the process.
 

src/mine/finder.cpp

@@ -141,10 +141,12 @@ void Finder::notifyUnfoldOrMinimizeProblem(const Program &p,
   ProgramUtil::print(p, out);
 }
 
-std::pair<std::string, Program> Finder::checkProgramExtended(
-    Program program, Program existing, bool is_new, const OeisSequence &seq,
-    bool full_check, size_t num_usages) {
-  std::pair<std::string, Program> result;
+check_result_t Finder::checkProgramExtended(Program program, Program existing,
+                                            bool is_new,
+                                            const OeisSequence &seq,
+                                            bool full_check,
+                                            size_t num_usages) {
+  check_result_t result;
 
   // get the extended sequence and number of required terms
   auto num_check = OeisProgram::getNumCheckTerms(full_check);
@@ -161,57 +163,59 @@ std::pair<std::string, Program> Finder::checkProgramExtended(
   }
 
   // the program is correct => update result
-  result.second = program;
+  result.program = program;
 
   // auto-unfold seq operations
   Subprogram::autoUnfold(program);
 
   // minimize based on number of terminating terms
   minimizer.optimizeAndMinimize(program, num_minimize);
-  if (program != result.second) {
+  if (program != result.program) {
     // minimization changed program => check the minimized program
     num_required = OeisProgram::getNumRequiredTerms(program);
     auto check_minimized =
         evaluator.check(program, extended_seq, num_required, seq.id);
     if (check_minimized.first == status_t::ERROR) {
       if (check_vanilla.first == status_t::OK) {
         // looks like the minimization changed the semantics of the program
-        notifyUnfoldOrMinimizeProblem(result.second,
+        notifyUnfoldOrMinimizeProblem(result.program,
                                       ProgramUtil::idStr(seq.id));
       }
       // we ignore the case where the base program has a warning and minimized
       // program an error, because it indicates a problem in the base program
-      result.second.ops.clear();
+      result.program.ops.clear();
       return result;  // program not ok
     }
   }
 
   // update result with minimized program
-  result.second = program;
+  result.program = program;
 
   if (is_new) {
     // no additional checks needed for new programs
-    result.first = "Found";
+    result.status = "Found";
   } else {
     // now we are in the "update" case
     // compare (minimized) program with existing programs
-    result.first = isOptimizedBetter(existing, result.second, seq.id,
-                                     full_check, num_usages);
+    result.status = isOptimizedBetter(existing, result.program, seq.id,
+                                      full_check, num_usages);
   }
 
   // clear result program if it's no good
-  if (result.first.empty()) {
-    result.second.ops.clear();
+  if (result.status.empty()) {
+    result.program.ops.clear();
   }
   return result;
 }
 
-std::pair<std::string, Program> Finder::checkProgramBasic(
-    const Program &program, const Program &existing, bool is_new,
-    const OeisSequence &seq, const std::string &change_type,
-    size_t previous_hash, bool full_check, size_t num_usages) {
+check_result_t Finder::checkProgramBasic(const Program &program,
+                                         const Program &existing, bool is_new,
+                                         const OeisSequence &seq,
+                                         const std::string &change_type,
+                                         size_t previous_hash, bool full_check,
+                                         size_t num_usages) {
   static const std::string first = "Found";
-  std::pair<std::string, Program> result;  // empty string indicates no update
+  check_result_t result;  // empty string indicates no update
 
   // additional metadata checks for program update
   if (!is_new) {
@@ -248,8 +252,8 @@ std::pair<std::string, Program> Finder::checkProgramBasic(
   }
 
   // the program is correct => update result
-  result.first = is_new ? first : change_type;
-  result.second = program;
+  result.status = is_new ? first : change_type;
+  result.program = program;
   return result;
 }
 
@@ -423,6 +427,22 @@ std::string Finder::isOptimizedBetter(Program existing, Program optimized,
   return not_better;  // not better or worse => no change
 }
 
+std::string Finder::compare(Program p1, Program p2, const std::string &name1,
+                            const std::string &name2, const OeisSequence &seq,
+                            size_t num_terms, size_t num_usages) {
+  auto result = isOptimizedBetter(p1, p2, seq, num_terms, num_usages);
+  if (!result.empty()) {
+    lowerString(result);
+    return name2 + " program is " + result;
+  }
+  result = isOptimizedBetter(p2, p1, seq, num_terms, num_usages);
+  if (!result.empty()) {
+    lowerString(result);
+    return name1 + " program is " + result;
+  }
+  return "Both programs are equivalent";
+}
+
 void Finder::notifyInvalidMatch(size_t id) {
   if (invalid_matches.find(id) == invalid_matches.end()) {
     invalid_matches[id] = 1;

src/mine/finder.hpp

@@ -8,6 +8,11 @@
 
 class OeisSequence;
 
+struct check_result_t {
+  std::string status;
+  Program program;
+};
+
 class Finder {
  public:
   Finder(const Settings &settings, Evaluator &evaluator);
@@ -22,14 +27,16 @@ class Finder {
       const Program &p, Sequence &norm_seq,
       const std::vector<OeisSequence> &sequences);
 
-  std::pair<std::string, Program> checkProgramExtended(
-      Program program, Program existing, bool is_new, const OeisSequence &seq,
-      bool full_check, size_t num_usages);
+  check_result_t checkProgramExtended(Program program, Program existing,
+                                      bool is_new, const OeisSequence &seq,
+                                      bool full_check, size_t num_usages);
 
-  std::pair<std::string, Program> checkProgramBasic(
-      const Program &program, const Program &existing, bool is_new,
-      const OeisSequence &seq, const std::string &change_type,
-      size_t previous_hash, bool full_check, size_t num_usages);
+  check_result_t checkProgramBasic(const Program &program,
+                                   const Program &existing, bool is_new,
+                                   const OeisSequence &seq,
+                                   const std::string &change_type,
+                                   size_t previous_hash, bool full_check,
+                                   size_t num_usages);
 
   std::vector<std::unique_ptr<Matcher>> &getMatchers() { return matchers; }
 
@@ -39,6 +46,10 @@ class Finder {
                                 const OeisSequence &seq, bool full_check,
                                 size_t num_usages);
 
+  std::string compare(Program p1, Program p2, const std::string &name1,
+                      const std::string &name2, const OeisSequence &seq,
+                      size_t num_terms, size_t num_usages);
+
  private:
   static constexpr double THRESHOLD_BETTER = 1.05;
   static constexpr double THRESHOLD_FASTER = 1.1;

src/mine/generator.cpp

@@ -341,21 +341,8 @@ MultiGenerator::MultiGenerator(const Settings &settings, const Stats &stats,
 
   // print info
   if (print_info) {
-    std::string overwrite;
-    switch (config.overwrite_mode) {
-      case OverwriteMode::NONE:
-        overwrite = "none";
-        break;
-      case OverwriteMode::ALL:
-        overwrite = "all";
-        break;
-      case OverwriteMode::AUTO:
-        overwrite = "auto";
-        break;
-    }
     Log::get().info("Initialized " + std::to_string(generators.size()) +
-                    " generators (profile: " + config.name +
-                    ", overwrite: " + overwrite + ")");
+                    " generators");
   }
 }
 

src/mine/miner.cpp

@@ -396,21 +396,33 @@ void Miner::reportCPUHour() {
   num_reported_hours++;
 }
 
-void Miner::submit(const std::string &path, std::string id) {
+void Miner::submit(const std::string &path, std::string id_str) {
+  reload();
   Parser parser;
   auto program = parser.parse(path);
   submit_mode = true;
-  reload();
-  if (id.empty()) {
-    id = Comments::getSequenceIdFromProgram(program);
+  if (id_str.empty()) {
+    id_str = Comments::getSequenceIdFromProgram(program);
+  }
+  if (id_str.empty()) {
+    Log::get().error("Missing sequence ID in program", true);
+  }
+  auto id = OeisSequence(id_str).id;
+  id_str = ProgramUtil::idStr(id);
+  Log::get().info("Loaded program for " + id_str);
+  if (manager->isIgnored(id)) {
+    Log::get().error(
+        "Sequence " + id_str + " is ignored by the active miner profile", true);
   }
   OeisSequence seq(id);
   Settings settings(this->settings);
   settings.print_as_b_file = false;
-  Log::get().info("Validating program for " + ProgramUtil::idStr(seq.id));
   Evaluator evaluator(settings);
   auto terms = seq.getTerms(OeisSequence::FULL_SEQ_LENGTH);
   auto num_required = OeisProgram::getNumRequiredTerms(program);
+  Log::get().info(
+      "Validating program against " + std::to_string(terms.size()) + " (>=" +
+      std::to_string(std::min(num_required, terms.size())) + ") terms");
   auto result = evaluator.check(program, terms, num_required, seq.id);
   if (result.first == status_t::ERROR) {
     Log::get().error("Validation failed", false);
@@ -425,8 +437,17 @@ void Miner::submit(const std::string &path, std::string id) {
   const auto mode = Setup::getMiningMode();
   auto seq_programs = manager->getFinder().findSequence(
       program, norm_seq, manager->getSequences());
-  size_t matches = 0;
+  Log::get().info("Found " + std::to_string(seq_programs.size()) +
+                  " potential matches");
+  size_t num_updated = 0;
+  std::unordered_set<size_t> updated_ids;
   for (auto s : seq_programs) {
+    const std::string skip_msg =
+        "Skipping submission for " + ProgramUtil::idStr(s.first);
+    if (updated_ids.find(s.first) != updated_ids.end()) {
+      Log::get().info(skip_msg + ": already updated");
+      continue;
+    }
     program = s.second;
     updateSubmittedBy(program);
     auto r = manager->updateProgram(s.first, program, ValidationMode::EXTENDED);
@@ -438,21 +459,35 @@ void Miner::submit(const std::string &path, std::string id) {
         Comments::addComment(program,
                              Comments::PREFIX_MINER_PROFILE + " manual");
         api_client->postProgram(program);
+      } else {
+        Log::get().info(skip_msg + ": not in client mode");
+      }
+      updated_ids.insert(s.first);
+      num_updated++;
+    } else {
+      size_t num_usages = 0;
+      if (seq.id < manager->getStats().program_usages.size()) {
+        num_usages = manager->getStats().program_usages[seq.id];
       }
-      matches++;
+      auto existing = manager->getExistingProgram(s.first);
+      auto msg = manager->getFinder().compare(
+          program, existing, "new", "existing", seq,
+          OeisSequence::EXTENDED_SEQ_LENGTH, num_usages);
+      lowerString(msg);
+      Log::get().info(skip_msg + ": " + msg);
     }
   }
-  if (matches > 0) {
+  if (num_updated > 0) {
     if (mode == MINING_MODE_LOCAL) {
-      Log::get().info("Stored programs for " + std::to_string(matches) +
-                      " matched sequences in local programs directory");
-      Log::get().warn("Skipping submission to server due to local mode");
+      Log::get().info("Stored " + std::to_string(num_updated) +
+                      " programs in local programs directory");
+      Log::get().warn("Skipping submissions to server due to local mode");
     } else {
-      Log::get().info("Submitted programs for " + std::to_string(matches) +
-                      " matched sequences");
+      Log::get().info("Submitted " + std::to_string(num_updated) +
+                      " programs to server");
     }
   } else {
-    Log::get().info("No matches or existing programs are better");
+    Log::get().info("No programs submitted to server");
   }
 }
 

src/mine/miner.hpp

@@ -23,14 +23,19 @@ class Miner {
     ValidationMode validation_mode;
     std::vector<Generator::Config> generators;
     std::vector<Matcher::Config> matchers;
+
+    bool usesBackoff() const {
+      return std::any_of(matchers.begin(), matchers.end(),
+                         [](const auto &m) { return m.backoff; });
+    }
   };
 
   explicit Miner(const Settings &settings,
                  ProgressMonitor *progress_monitor = nullptr);
 
   void mine();
 
-  void submit(const std::string &path, std::string id);
+  void submit(const std::string &path, std::string id_str);
 
   void setBaseProgram(const Program &p) { base_program = p; }