remove try-catch and move to static function

Author: johnathan79717

barretenberg/cpp/src/barretenberg/polynomials/backing_memory.hpp

@@ -52,27 +52,38 @@ template <typename Fr> class BackingMemory {
     {
 #ifndef __wasm__
         if (slow_low_memory) {
-            size_t required_bytes = size * sizeof(Fr);
-            size_t current_usage = current_storage_usage.load();
-
-            // Check if we're under the storage budget
-            if (current_usage + required_bytes <= storage_budget) {
-                // Try to use FileBackedMemory
-                try {
-                    auto result = std::shared_ptr<BackingMemory<Fr>>(new FileBackedMemory<Fr>(size));
-                    current_storage_usage.fetch_add(required_bytes);
-                    return result;
-                } catch (const std::exception& e) {
-                    // FileBackedMemory allocation failed, fall back to AlignedMemory
-                    return std::shared_ptr<BackingMemory<Fr>>(new AlignedMemory<Fr>(size));
-                }
+            auto file_backed = try_allocate_file_backed(size);
+            if (file_backed) {
+                return file_backed;
             }
-            // Over budget, use AlignedMemory
         }
 #endif
         return std::shared_ptr<BackingMemory<Fr>>(new AlignedMemory<Fr>(size));
     }
 
+  private:
+#ifndef __wasm__
+    static std::shared_ptr<BackingMemory<Fr>> try_allocate_file_backed(size_t size)
+    {
+        size_t required_bytes = size * sizeof(Fr);
+        size_t current_usage = current_storage_usage.load();
+
+        // Check if we're under the storage budget
+        if (current_usage + required_bytes > storage_budget) {
+            return nullptr; // Over budget
+        }
+
+        // Attempt to create FileBackedMemory without exceptions
+        // We'll need to modify FileBackedMemory constructor to be noexcept
+        auto file_backed = FileBackedMemory<Fr>::try_create(size);
+        if (file_backed) {
+            current_storage_usage.fetch_add(required_bytes);
+        }
+        return file_backed;
+    }
+#endif
+
+  public:
     virtual ~BackingMemory() = default;
 };
 
@@ -104,36 +115,17 @@ template <typename T> class FileBackedMemory : public BackingMemory<T> {
 
     T* raw_data() { return memory; }
 
-    ~FileBackedMemory()
+    // Try to create file-backed memory, returns nullptr on failure
+    static std::shared_ptr<BackingMemory<T>> try_create(size_t size)
     {
-        if (file_size == 0) {
-            return;
-        }
-        if (memory != nullptr && file_size > 0) {
-            munmap(memory, file_size);
-            // Decrement storage usage when FileBackedMemory is freed
-            current_storage_usage.fetch_sub(file_size);
-        }
-        if (fd >= 0) {
-            close(fd);
-        }
-        if (!filename.empty()) {
-            std::filesystem::remove(filename);
-        }
-    }
-
-  private:
-    // Create a new file-backed memory region
-    FileBackedMemory(size_t size)
-        : BackingMemory<T>()
-        , file_size(size * sizeof(T))
-    {
-        if (file_size == 0) {
-            return;
+        if (size == 0) {
+            return std::shared_ptr<BackingMemory<T>>(new FileBackedMemory<T>());
         }
 
+        size_t file_size = size * sizeof(T);
         static std::atomic<size_t> file_counter{ 0 };
         size_t id = file_counter.fetch_add(1);
+
         std::filesystem::path temp_dir;
         try {
             temp_dir = std::filesystem::temp_directory_path();
@@ -142,28 +134,65 @@ template <typename T> class FileBackedMemory : public BackingMemory<T> {
             temp_dir = std::filesystem::current_path();
         }
 
-        filename = temp_dir / ("poly-mmap-" + std::to_string(getpid()) + "-" + std::to_string(id));
+        std::string filename = temp_dir / ("poly-mmap-" + std::to_string(getpid()) + "-" + std::to_string(id));
 
-        fd = open(filename.c_str(), O_CREAT | O_RDWR | O_TRUNC, 0644);
-        // Create file
+        int fd = open(filename.c_str(), O_CREAT | O_RDWR | O_TRUNC, 0644);
         if (fd < 0) {
-            throw_or_abort("Failed to create backing file: " + filename);
+            return nullptr; // Failed to create file
         }
 
         // Set file size
         if (ftruncate(fd, static_cast<off_t>(file_size)) != 0) {
-            throw_or_abort("Failed to set file size");
+            close(fd);
+            std::filesystem::remove(filename);
+            return nullptr; // Failed to set file size
         }
 
         // Memory map the file
         void* addr = mmap(nullptr, file_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
         if (addr == MAP_FAILED) {
-            throw_or_abort("Failed to mmap file: " + std::string(std::strerror(errno)));
+            close(fd);
+            std::filesystem::remove(filename);
+            return nullptr; // Failed to mmap
         }
 
-        memory = static_cast<T*>(addr);
+        // Create the FileBackedMemory object using private constructor
+        auto memory = new FileBackedMemory<T>();
+        memory->file_size = file_size;
+        memory->filename = filename;
+        memory->fd = fd;
+        memory->memory = static_cast<T*>(addr);
+
+        return std::shared_ptr<BackingMemory<T>>(memory);
+    }
+
+    ~FileBackedMemory()
+    {
+        if (file_size == 0) {
+            return;
+        }
+        if (memory != nullptr && file_size > 0) {
+            munmap(memory, file_size);
+            // Decrement storage usage when FileBackedMemory is freed
+            current_storage_usage.fetch_sub(file_size);
+        }
+        if (fd >= 0) {
+            close(fd);
+        }
+        if (!filename.empty()) {
+            std::filesystem::remove(filename);
+        }
     }
 
+  private:
+    // Default constructor for empty file-backed memory
+    FileBackedMemory()
+        : BackingMemory<T>()
+        , file_size(0)
+        , fd(-1)
+        , memory(nullptr)
+    {}
+
     size_t file_size;
     std::string filename;
     int fd;