unique ptr and backend_t = raw ptr

Author: ethanalee

system/lib/wasmfs/backend.h

@@ -20,7 +20,7 @@ namespace wasmfs {
 // extend its storage capabilities. Files and directories will be represented in
 // the file system structure, but their underlying backing could exist in
 // persistent storage, another thread, etc.
-class Backend : public std::enable_shared_from_this<Backend> {
+class Backend {
 
 public:
   virtual std::shared_ptr<DataFile> createFile(mode_t mode) = 0;
@@ -32,5 +32,5 @@ class Backend : public std::enable_shared_from_this<Backend> {
 // Note: Backends will be defined in cpp files, but functions to acquire them
 // will be defined in this header. This is so that any unused backends are not
 // linked in if they are not called.
-std::shared_ptr<Backend> createMemoryFileBackend();
+std::unique_ptr<Backend> createMemoryFileBackend();
 } // namespace wasmfs

system/lib/wasmfs/file.h

@@ -23,7 +23,7 @@ namespace wasmfs {
 
 class Backend;
 // This specifies a reference to a directory's associated backend.
-using backend_t = std::shared_ptr<Backend>;
+using backend_t = Backend*;
 
 class File : public std::enable_shared_from_this<File> {
 

system/lib/wasmfs/memory_file.cpp

@@ -0,0 +1,31 @@
+
+#include "memory_file.h"
+
+namespace wasmfs {
+__wasi_errno_t MemoryFile::write(const uint8_t* buf, size_t len, off_t offset) {
+  if (offset + len >= buffer.size()) {
+    buffer.resize(offset + len);
+  }
+  memcpy(&buffer[offset], buf, len);
+
+  return __WASI_ERRNO_SUCCESS;
+}
+
+__wasi_errno_t MemoryFile::read(uint8_t* buf, size_t len, off_t offset) {
+  assert(offset + len - 1 < buffer.size());
+  std::memcpy(buf, &buffer[offset], len);
+
+  return __WASI_ERRNO_SUCCESS;
+}
+
+void MemoryFile::Handle::preloadFromJS(int index) {
+  getFile()->buffer.resize(
+    EM_ASM_INT({return wasmFS$preloadedFiles[$0].fileData.length}, index));
+  // Ensure that files are preloaded from the main thread.
+  assert(emscripten_is_main_runtime_thread());
+  // TODO: Replace every EM_ASM with EM_JS.
+  EM_ASM({ HEAPU8.set(wasmFS$preloadedFiles[$1].fileData, $0); },
+         getFile()->buffer.data(),
+         index);
+}
+} // namespace wasmfs

system/lib/wasmfs/memory_file.h

@@ -15,21 +15,9 @@ namespace wasmfs {
 // This class describes a file that lives in Wasm Memory.
 class MemoryFile : public DataFile {
   std::vector<uint8_t> buffer;
-  __wasi_errno_t write(const uint8_t* buf, size_t len, off_t offset) override {
-    if (offset + len >= buffer.size()) {
-      buffer.resize(offset + len);
-    }
-    memcpy(&buffer[offset], buf, len);
+  __wasi_errno_t write(const uint8_t* buf, size_t len, off_t offset) override;
 
-    return __WASI_ERRNO_SUCCESS;
-  }
-
-  __wasi_errno_t read(uint8_t* buf, size_t len, off_t offset) override {
-    assert(offset + len - 1 < buffer.size());
-    std::memcpy(buf, &buffer[offset], len);
-
-    return __WASI_ERRNO_SUCCESS;
-  }
+  __wasi_errno_t read(uint8_t* buf, size_t len, off_t offset) override;
 
   size_t getSize() override { return buffer.size(); }
 
@@ -43,16 +31,7 @@ class MemoryFile : public DataFile {
   public:
     Handle(std::shared_ptr<File> dataFile) : DataFile::Handle(dataFile) {}
     // This function copies preloaded files from JS Memory to Wasm Memory.
-    void preloadFromJS(int index) {
-      getFile()->buffer.resize(
-        EM_ASM_INT({return wasmFS$preloadedFiles[$0].fileData.length}, index));
-      // Ensure that files are preloaded from the main thread.
-      assert(emscripten_is_main_browser_thread());
-      // TODO: Replace every EM_ASM with EM_JS.
-      EM_ASM({ HEAPU8.set(wasmFS$preloadedFiles[$1].fileData, $0); },
-             getFile()->buffer.data(),
-             index);
-    }
+    void preloadFromJS(int index);
   };
 
   Handle locked() { return Handle(shared_from_this()); }

system/lib/wasmfs/memory_file_backend.cpp

@@ -22,11 +22,11 @@ class MemoryFileBackend : public Backend {
     return std::make_shared<MemoryFile>(mode);
   }
   std::shared_ptr<Directory> createDirectory(mode_t mode) override {
-    return std::make_shared<Directory>(mode, shared_from_this());
+    return std::make_shared<Directory>(mode, this);
   }
 };
 
-std::shared_ptr<Backend> createMemoryFileBackend() {
-  return std::make_shared<MemoryFileBackend>();
+std::unique_ptr<Backend> createMemoryFileBackend() {
+  return std::make_unique<MemoryFileBackend>();
 }
 } // namespace wasmfs

system/lib/wasmfs/wasmfs.cpp

@@ -27,12 +27,11 @@ __attribute__((init_priority(100))) WasmFS wasmFS;
 # 28 "wasmfs.cpp"
 
 std::shared_ptr<Directory> WasmFS::initRootDirectory() {
-  auto rootBackend = createMemoryFileBackend();
-  backendTable.push_back(rootBackend);
+  backendTable.push_back(createMemoryFileBackend());
   auto rootDirectory =
-    std::make_shared<Directory>(S_IRUGO | S_IXUGO, rootBackend);
+    std::make_shared<Directory>(S_IRUGO | S_IXUGO, backendTable[0].get());
   auto devDirectory =
-    std::make_shared<Directory>(S_IRUGO | S_IXUGO, rootBackend);
+    std::make_shared<Directory>(S_IRUGO | S_IXUGO, backendTable[0].get());
   rootDirectory->locked().setEntry("dev", devDirectory);
 
   auto dir = devDirectory->locked();

system/lib/wasmfs/wasmfs.h

@@ -37,7 +37,7 @@ class WasmFS {
   void preloadFiles();
 
 public:
-  std::vector<std::shared_ptr<Backend>> backendTable;
+  std::vector<std::unique_ptr<Backend>> backendTable;
   // Files will be preloaded in this constructor.
   // This global constructor has init_priority 100. Please see wasmfs.cpp.
   // The current working directory is initialized to the root directory.