support for windows

.github/workflows/main.yml

@@ -20,6 +20,22 @@ jobs:
     - run: RUSTFLAGS='--cfg test_lots' cargo test --release
     - run: RUSTFLAGS='--cfg test_lots' cargo test --release --features debug
 
+  windows-test:
+    name: Test-windows
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        rust: [stable, beta, nightly]
+    steps:
+      - uses: actions/checkout@master
+      - name: Install Rust (
+        run: rustup update ${{ matrix.rust }} && rustup default ${{ matrix.rust }}
+      - run: cargo test
+      - run: cargo test --features debug
+      - run: cargo test --features global
+      - run: cargo test --release
+      - run: cargo test --features debug --release
+
   rustfmt:
     name: Rustfmt
     runs-on: ubuntu-latest

Cargo.toml

@@ -25,6 +25,17 @@ libc = { version = "0.2", default-features = false }
 # `src/tools/rustc-std-workspace` folder
 core = { version = '1.0.0', optional = true, package = 'rustc-std-workspace-core' }
 compiler_builtins = { version = '0.1.0', optional = true }
+once_cell = "1.9.0"
+[target.'cfg(target_os = "windows")'.dependencies]
+windows = { version = "0.33.0", features = [
+    "alloc",
+    "Win32_System_Memory",
+    "Win32_Foundation",
+    "Win32_System_Threading",
+    "Win32_Security",
+    "Win32_System_Diagnostics",
+    "Win32_System_Diagnostics_Debug"
+] }
 
 [dev-dependencies]
 rand = "0.3"

src/lib.rs

@@ -15,6 +15,10 @@
 #![no_std]
 #![deny(missing_docs)]
 #![cfg_attr(target_arch = "wasm64", feature(simd_wasm64))]
+#[macro_use]
+extern crate once_cell;
+#[cfg(target_os = "windows")]
+extern crate windows;
 
 use core::cmp;
 use core::ptr;
@@ -81,7 +85,11 @@ mod sys;
 #[path = "unix.rs"]
 mod sys;
 
-#[cfg(not(any(target_os = "linux", target_os = "macos", target_family = "wasm")))]
+#[cfg(target_os = "windows")]
+#[path = "windows.rs"]
+mod sys;
+
+#[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows", target_family = "wasm")))]
 #[path = "dummy.rs"]
 mod sys;
 

src/windows.rs

@@ -0,0 +1,79 @@
+use core::ptr;
+use core::ffi::{c_void};
+use once_cell::sync::Lazy;
+use Allocator;
+
+pub struct System {
+    _priv: (),
+}
+
+
+impl System {
+    pub const fn new() -> System { System { _priv: () } }
+}
+
+unsafe impl Allocator for System {
+    fn alloc(&self, size: usize) -> (*mut u8, usize, u32) {
+            let addr = unsafe {
+                windows::Win32::System::Memory::VirtualAlloc(
+                    ptr::null_mut(),
+                    size,
+                    windows::Win32::System::Memory::MEM_RESERVE | windows::Win32::System::Memory::MEM_COMMIT,
+                    windows::Win32::System::Memory::PAGE_READWRITE,
+                )
+            };
+
+            if addr == ptr::null_mut() {
+                (ptr::null_mut(), 0, 0)
+            } else {
+                (addr as *mut u8, size, 0)
+            }
+    }
+
+    fn remap(&self, ptr: *mut u8, oldsize: usize, newsize: usize, can_move: bool) -> *mut u8 {
+        ptr::null_mut()
+    }
+
+    fn free_part(&self, ptr: *mut u8, oldsize: usize, newsize: usize) -> bool { false }
+
+    fn free(&self, ptr: *mut u8, size: usize) -> bool {
+        unsafe {
+            windows::Win32::System::Memory::VirtualFree(
+                ptr as *mut c_void,
+                0,
+                windows::Win32::System::Memory::MEM_RELEASE).0 != 0
+        }
+    }
+
+    fn can_release_part(&self, _flags: u32) -> bool { true }
+
+    fn allocates_zeros(&self) -> bool { true }
+
+    fn page_size(&self) -> usize { 4096 }
+}
+
+#[cfg(feature = "global")]
+static LOCK: Lazy<windows::Win32::Foundation::HANDLE> = unsafe {
+    Lazy::new(|| {
+        windows::Win32::System::Threading::CreateMutexA(
+            ptr::null_mut(),
+            false,
+            windows::core::PCSTR::default())
+    })
+};
+
+#[cfg(feature = "global")]
+pub fn acquire_global_lock() {
+    unsafe { assert_ne!(windows::Win32::System::Threading::WaitForSingleObject(*LOCK, u32::MAX), u32::MAX) };
+}
+
+#[cfg(feature = "global")]
+pub fn release_global_lock() {
+    unsafe { assert_ne!(windows::Win32::System::Threading::ReleaseMutex(*LOCK).0, 0) };
+}
+
+/// Under consideration
+#[cfg(feature = "global")]
+pub unsafe fn enable_alloc_after_fork() {
+    // TODO(threadedstream): do I need to implement it?
+}