Fix slab allocator for Windows

Summary: Use `_aligned_malloc` on Windows and don't support locking.

Reviewed By: mpage

Differential Revision: D91526693

fbshipit-source-id: 375631fbfc4d9387ae6dbc7dd330e2e11ebfdcb1

Author: DinoV

cinderx/Common/slab.h

@@ -4,7 +4,9 @@
 
 #include "cinderx/Common/log.h"
 #include "cinderx/Common/util.h"
+#ifndef WIN32
 #include "sys/mman.h"
+#endif
 
 #include <cstddef>
 #include <cstdlib>
@@ -64,8 +66,13 @@ class Slab {
         increment >= sizeof(T),
         "Trying to fit a slab object into too little memory");
     void* ptr;
+#ifndef WIN32
     int result = posix_memalign(&ptr, kPageSize, kSlabSize);
     JIT_CHECK(result == 0, "Failed to allocate {} bytes", kSlabSize);
+#else
+    ptr = _aligned_malloc(kSlabSize, kPageSize);
+    JIT_CHECK(ptr != nullptr, "Failed to allocate {} bytes", kSlabSize);
+#endif
     base_.reset(static_cast<char*>(ptr));
     fill_ = base_.get();
   }
@@ -96,6 +103,7 @@ class Slab {
     return ptr;
   }
 
+#ifndef WIN32
   void mlock() {
     if (::mlock(base_.get(), kSlabSize) < 0) {
       JIT_LOG("Failed to mlock slab at {}", base_.get());
@@ -117,6 +125,7 @@ class Slab {
     }
     mlocks_--;
   }
+#endif
 
   iterator begin() const {
     return iterator{base_.get(), increment_};

cinderx/Common/slab_arena.h

@@ -123,23 +123,28 @@ class SlabArena {
   T* allocate(Args&&... args) {
     std::lock_guard<std::mutex> guard{mutex_};
 
+#ifndef WIN32
     if (mlocked_) {
       // It's not necessarily an error to allocate after locking but it's
       // probably not what we expect to happen in the common forking case.
       JIT_DLOG("Allocating while locked");
     }
+#endif
 
     void* mem = slabs_.back().allocate();
     if (mem == nullptr) {
       mem = slabs_.emplace_back(SizeTrait::size()).allocate();
       JIT_CHECK(mem != nullptr, "Empty slab failed to allocate");
+#ifndef WIN32
       if (mlocked_) {
         slabs_.back().mlock();
       }
+#endif
     }
     return new (mem) T(std::forward<Args>(args)...);
   }
 
+#ifndef WIN32
   // Pin the contents to physical memory.
   void mlock() {
     std::lock_guard<std::mutex> guard{mutex_};
@@ -155,6 +160,7 @@ class SlabArena {
       slab.munlock();
     }
   }
+#endif
 
   iterator begin() {
     return iterator{&slabs_};
@@ -167,7 +173,9 @@ class SlabArena {
  private:
   std::vector<Slab<T, kSlabSize>> slabs_;
   std::mutex mutex_;
+#ifndef WIN32
   bool mlocked_{false};
+#endif
 };
 
 } // namespace jit