Extending PM1 Stage 1

Author: cherubrock-seb

include/core/AlgoUtils.hpp

@@ -447,6 +447,33 @@ static inline void write_u16(std::ofstream& o, uint16_t v){ o.write(reinterpret_
 static inline void write_f64(std::ofstream& o, double v){ o.write(reinterpret_cast<const char*>(&v),8); }
 static inline void write_u8 (std::ofstream& o, uint8_t  v){ o.write(reinterpret_cast<const char*>(&v),1); }
 
+
+static inline bool read_u32(std::ifstream& in, uint32_t& v){
+    in.read(reinterpret_cast<char*>(&v), 4);
+    return (bool)in;
+}
+static inline bool read_i32(std::ifstream& in, int32_t& v){
+    in.read(reinterpret_cast<char*>(&v), 4);
+    return (bool)in;
+}
+static inline bool read_u64(std::ifstream& in, uint64_t& v){
+    in.read(reinterpret_cast<char*>(&v), 8);
+    return (bool)in;
+}
+static inline bool read_u16(std::ifstream& in, uint16_t& v){
+    in.read(reinterpret_cast<char*>(&v), 2);
+    return (bool)in;
+}
+static inline bool read_f64(std::ifstream& in, double& v){
+    in.read(reinterpret_cast<char*>(&v), 8);
+    return (bool)in;
+}
+static inline bool read_u8(std::ifstream& in, uint8_t& v){
+    in.read(reinterpret_cast<char*>(&v), 1);
+    return (bool)in;
+}
+
+
 static inline bool read_text_file(const std::string& path, std::string& out){
     std::ifstream f(path);
     if(!f) return false;
@@ -562,7 +589,7 @@ static inline bool write_prime95_s1_from_bytes(const std::string& outPath, uint3
     #elif defined(__arm__) || defined(_M_ARM)
     arch_str = "ARM";
     #else
-    arch_str = "unknown";
+    arch_str = "";
     #endif
 
     std::string json = std::string("{\"programs\":[{\"work\":{\"type\":\"PM1\",\"stage\":\"1\"},\"program\":{\"name\":\"prmers\",\"version\":\"" + core::PRMERS_VERSION + "\"},\"os\":{\"os\":\"") + os_str + "\",\"architecture\":\"" + arch_str + "\"},\"date_start\":\"" + ds + "\",\"date_end\":\"" + de + "\"}]}";
@@ -595,6 +622,83 @@ static inline bool write_prime95_s1_from_bytes(const std::string& outPath, uint3
     return (bool)out;
 }
 
+static inline bool read_prime95_s1_to_bytes(const std::string& path,
+                                            uint32_t& p_out,
+                                            uint64_t& B1_out,
+                                            std::vector<uint8_t>& data_out)
+{
+    std::ifstream in(path, std::ios::binary);
+    if (!in) {
+        std::cerr << "Error: cannot open Prime95 S1 file " << path << " for reading\n";
+        return false;
+    }
+
+    uint32_t magic = 0;
+    uint32_t ver   = 0;
+    double   fver  = 0.0;
+    int32_t  type  = 0;
+    uint32_t p     = 0;
+    int32_t  unused_n = 0;
+    uint8_t  stage0 = 0, stage1 = 0;
+    uint16_t reserved = 0;
+    uint64_t zero     = 0;
+    double   f1       = 0.0;
+    uint32_t chk_file = 0;
+    int32_t  flag5    = 0;
+    uint64_t B1_a     = 0;
+    uint64_t B1_b     = 0;
+    int32_t  flag1    = 0;
+    int32_t  nWords   = 0;
+
+    // Lire l’en-tête dans le même ordre que write_prime95_s1_from_bytes
+    if (!read_u32(in, magic))   return false;
+    if (!read_u32(in, ver))     return false;
+    if (!read_f64(in, fver))    return false;
+    if (!read_i32(in, type))    return false;
+    if (!read_u32(in, p))       return false;
+    if (!read_i32(in, unused_n))return false;
+    if (!read_u8(in, stage0))   return false;
+    if (!read_u8(in, stage1))   return false;
+    if (!read_u16(in, reserved))return false;
+    if (!read_u64(in, zero))    return false;
+    if (!read_f64(in, f1))      return false;
+    if (!read_u32(in, chk_file))return false;
+    if (!read_i32(in, flag5))   return false;
+    if (!read_u64(in, B1_a))    return false;
+    if (!read_u64(in, B1_b))    return false;
+    if (!read_i32(in, flag1))   return false;
+    if (!read_i32(in, nWords))  return false;
+
+    if (nWords < 0) {
+        std::cerr << "Error: negative word count in Prime95 S1 file " << path << "\n";
+        return false;
+    }
+
+    size_t nBytes = static_cast<size_t>(nWords) * 4u;
+    data_out.assign(nBytes, 0);
+
+    in.read(reinterpret_cast<char*>(data_out.data()),
+            static_cast<std::streamsize>(nBytes));
+    if (!in) {
+        std::cerr << "Error: truncated Prime95 S1 data in " << path << "\n";
+        return false;
+    }
+
+    // Sorties
+    p_out  = p;
+    B1_out = B1_a;              // B1_a == B1_b dans ton writer
+
+    // Vérifier le checksum (même formule que lors de l’écriture)
+    uint32_t chk_calc = checksum_prime95_s1(B1_out, data_out);
+    if (chk_calc != chk_file) {
+        std::cerr << "Warning: checksum mismatch in Prime95 S1 file " << path
+                  << " (file=" << chk_file << ", computed=" << chk_calc << ")\n";
+        // On continue quand même : les données sont probablement correctes.
+    }
+
+    return true;
+}
+
 
 static inline mpz_class compute_X_with_dots(engine* eng, engine::Reg reg, const mpz_class& Mp) {
     using namespace std::chrono;

include/core/Version.hpp

@@ -4,7 +4,7 @@
 #include <string>
 
 namespace core {
-    const std::string PRMERS_VERSION = "4.15.35-alpha";
+    const std::string PRMERS_VERSION = "4.15.36-alpha";
 } // namespace core
 
 #endif // VERSION_HPP

include/io/CliParser.hpp

@@ -29,6 +29,8 @@ struct CliOptions {
     bool verify = true;
     bool gerbiczli = true;
     uint64_t B1 = 10000;
+    uint64_t B1old = 0;
+    uint64_t B1_new = 0;
     uint64_t B2 = 0;
     uint64_t checklevel = 0;
     uint64_t gerbicz_error_count = 0;
@@ -57,6 +59,7 @@ struct CliOptions {
     std::string computer_name;
     std::string config_path;
     std::string worktodo_path = "worktodo.txt";
+    std::string pm1_extend_save_path = "";
     int max_local_size1 = 0;
     int max_local_size2 = 0;
     int max_local_size3 = 0;

src/io/CliParser.cpp

@@ -58,6 +58,9 @@ void printUsage(const char* progName) {
     std::cout << "  -pm1                 : (Optional) Run factoring P-1" << std::endl;
     std::cout << "  -b1                  : (Optional) B1 for factoring P-1" << std::endl;
     std::cout << "  -b2                  : (Optional) B2 for factoring P-1" << std::endl;
+    std::cout << "  -b1old               : (Optional) Continue P-1 factoring stage 1 from a previous run. "
+             "Loads a file named 'resume_p[Exponent]_B1_[oldB1].save (GMP-ECM) or .p95 (if .save not found) '. "
+             "Use -b1 to specify the new B1 bound for extension." << std::endl;
     std::cout << "  -K <value>           : Exponent K for the n^K variant of P-1 stage 2" << std::endl;
     std::cout << "  -nmax <value>        : Maximum value of n for the n^K variant of P-1 stage 2" << std::endl;
     std::cout << "  -t <seconds>         : (Optional) Specify backup interval in seconds (default: 120)" << std::endl;
@@ -82,6 +85,7 @@ void printUsage(const char* progName) {
     std::cout << "  -checklevel <value>  : (Optional) Will force gerbicz check every B*<value> by default check is done every 10 min and at the end." << std::endl;
     std::cout << "  -wagstaff            : (Optional) will check PRP if (2^p + 1)/3 is probably prime" << std::endl;
     std::cout << "  -ecm -b1 <B1> [-b2 <B2>] -K <curves> : Run ECM factoring with bounds B1 [and optional B2], on given number of curves" << std::endl;
+    
     std::cout << "  -montgomery          : (Optional) compute in Montgomery and use Montgomery (compute done in montgomery)" << std::endl;
     std::cout << "  -edwards             : (Optional) compute in Montgomery and use (twisted) Edwards curve converted to Montgomery (compute done in Montgomery)" << std::endl;
     std::cout << "  -ced                 : (Optional) compute in Edwards and use (twisted) Edwards curves (notorsion twisted or torsion 2x8 possible no twist a=1) " << std::endl;
@@ -287,6 +291,10 @@ CliOptions CliParser::parse(int argc, char** argv ) {
             opts.B1 = std::strtoull(argv[i + 1], nullptr, 10);  // base 10
             ++i;
         }
+        else if (std::strcmp(argv[i], "-b1old") == 0 && i + 1 < argc) {
+            opts.B1old = std::strtoull(argv[i + 1], nullptr, 10);  // base 10
+            ++i;
+        }
         else if (std::strcmp(argv[i], "-b2") == 0 && i + 1 < argc) {
             opts.B2 = std::strtoull(argv[i + 1], nullptr, 10);  // base 10
             ++i;
@@ -398,6 +406,7 @@ CliOptions CliParser::parse(int argc, char** argv ) {
         else if (strcmp(argv[i], "-factors") == 0 && i + 1 < argc) {
             opts.knownFactors = util::split(argv[++i], ',');
         }
+        
         else if (argv[i][0] != '-') {
             if (opts.exponent == 0) {
                 opts.exponent = std::strtoull(argv[i], nullptr, 10);

src/io/JsonBuilder.cpp

@@ -270,8 +270,11 @@ static std::string generatePrimeNetJson(
         << ",\"version\":"  << jsonEscape(programVersion)
         << ",\"port\":"     << programPort << "},"
         << "\"os\":{"
-        << "\"os\":"        << jsonEscape(osName)
-        << ",\"architecture\":" << jsonEscape(osArchitecture)
+        << "\"os\":"        << jsonEscape(osName);
+        if(!osArchitecture.empty()){
+          oss  << ",\"architecture\":" << jsonEscape(osArchitecture);
+        }
+        oss
         << "},"
         << "\"user\":"      << jsonEscape(user);
     if (!computer.empty()) oss << ",\"computer\":" << jsonEscape(computer);
@@ -306,7 +309,7 @@ static std::string generatePrimeNetJson(
     canon << ";";
     if (canonWT == "PRP") canon << toLower(res2048);
     canon << ";";
-    canon << "0_3_1;";
+    canon << "0_3_" << residueType << ";";
     canon << fftLength << ";";
     canon << "gerbicz:" << gerbiczError << ";";
     canon << programName << ";";
@@ -367,7 +370,7 @@ std::string JsonBuilder::generate(const CliOptions& opts,
                 << "\"port\":" << opts.portCode
             << "},"
             << "\"timestamp\":" << jsonEscape(timestampBuf) << ","
-            << "\"user\":" << jsonEscape(opts.user.empty() ? "prmers" : opts.user);
+            << "\"user\":" << jsonEscape(opts.user.empty() ? "" : opts.user);
         if (!opts.computer_name.empty())
             oss << ",\"computer\":" << jsonEscape(opts.computer_name);
         if (!opts.aid.empty())