Merge pull request #6471 from Carlyle-Foster/master

rename DEFAULT_PAGE_SIZE to PAGE_SIZE

core/crypto/argon2id/argon2id.odin

@@ -143,7 +143,7 @@ derive :: proc(
 	m_ := 4 * u64(p) * (m / u64(4 * p))
 	b := mem.alloc_bytes_non_zeroed(
 		int(m_) * BLOCK_SIZE_BYTES,
-		alignment = mem.DEFAULT_PAGE_SIZE,
+		alignment = mem.PAGE_SIZE,
 		allocator = allocator,
 	) or_return
 	defer delete(b, allocator)

core/mem/alloc.odin

@@ -255,11 +255,10 @@ alignment is not specified explicitly.
 DEFAULT_ALIGNMENT :: 2*align_of(rawptr)
 
 /*
-Default page size.
-
-This value is the default page size for the current platform.
+On platforms where we were able to query a configurable size, we use that value instead.
+See `query_page_size_init()`
 */
-DEFAULT_PAGE_SIZE ::
+PAGE_SIZE: int =
 	64 * 1024 when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 else
 	16 * 1024 when ODIN_OS == .Darwin && ODIN_ARCH == .arm64 else
 	4 * 1024

core/mem/mem_posix.odin

@@ -0,0 +1,13 @@
+#+build linux, darwin, netbsd, freebsd, openbsd
+package mem
+
+import "core:sys/posix"
+
+@(init, private, no_sanitize_address)
+query_page_size_init :: proc "contextless" () {
+	size := posix.sysconf(._PAGESIZE)
+	PAGE_SIZE = max(PAGE_SIZE, int(size))
+
+	// is power of two
+	assert_contextless(PAGE_SIZE != 0 && (PAGE_SIZE & (PAGE_SIZE-1)) == 0)
+}

core/mem/mem_windows.odin

@@ -0,0 +1,16 @@
+#+build windows
+package mem
+
+import "core:sys/windows"
+
+@(init, private, no_sanitize_address)
+query_page_size_init :: proc "contextless" () {
+	info: windows.SYSTEM_INFO
+	windows.GetSystemInfo(&info)
+
+	size := info.dwPageSize
+	PAGE_SIZE = max(PAGE_SIZE, int(size))
+
+	// is power of two
+	assert_contextless(PAGE_SIZE != 0 && (PAGE_SIZE & (PAGE_SIZE-1)) == 0)
+}

core/mem/virtual/arena.odin

@@ -126,11 +126,11 @@ arena_alloc_unguarded :: proc(arena: ^Arena, size: uint, alignment: uint, loc :=
 		if err == .Out_Of_Memory {
 			if arena.minimum_block_size == 0 {
 				arena.minimum_block_size = DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE
-				arena.minimum_block_size = mem.align_forward_uint(arena.minimum_block_size, DEFAULT_PAGE_SIZE)
+				arena.minimum_block_size = mem.align_forward_uint(arena.minimum_block_size, uint(mem.PAGE_SIZE))
 			}
 			if arena.default_commit_size == 0 {
 				arena.default_commit_size = min(DEFAULT_ARENA_GROWING_COMMIT_SIZE, arena.minimum_block_size)
-				arena.default_commit_size = mem.align_forward_uint(arena.default_commit_size, DEFAULT_PAGE_SIZE)
+				arena.default_commit_size = mem.align_forward_uint(arena.default_commit_size, uint(mem.PAGE_SIZE))
 			}
 
 			if arena.default_commit_size != 0 {

core/mem/virtual/virtual.odin

@@ -6,13 +6,6 @@ import "base:intrinsics"
 import "base:runtime"
 _ :: runtime
 
-DEFAULT_PAGE_SIZE := uint(4096)
-
-@(init, private)
-platform_memory_init :: proc "contextless" () {
-	_platform_memory_init()
-}
-
 Allocator_Error :: mem.Allocator_Error
 
 @(require_results, no_sanitize_address)
@@ -79,7 +72,7 @@ align_formula :: #force_inline proc "contextless" (size, align: uint) -> uint {
 
 @(require_results, no_sanitize_address)
 memory_block_alloc :: proc(committed, reserved: uint, alignment: uint = 0, flags: Memory_Block_Flags = {}) -> (block: ^Memory_Block, err: Allocator_Error) {
-	page_size := DEFAULT_PAGE_SIZE
+	page_size := uint(mem.PAGE_SIZE)
 	assert(mem.is_power_of_two(uintptr(page_size)))
 
 	committed := committed
@@ -144,7 +137,7 @@ alloc_from_memory_block :: proc(block: ^Memory_Block, min_size, alignment: uint,
 			// TODO(bill): determine a better heuristic for this behaviour
 			extra_size := max(size, block.committed>>1)
 			platform_total_commit := base_offset + block.used + extra_size
-			platform_total_commit = align_formula(platform_total_commit, DEFAULT_PAGE_SIZE)
+			platform_total_commit = align_formula(platform_total_commit, uint(mem.PAGE_SIZE))
 			platform_total_commit = min(max(platform_total_commit, default_commit_size), pmblock.reserved)
 
 			assert(pmblock.committed <= pmblock.reserved)

core/mem/virtual/virtual_linux.odin

@@ -43,12 +43,6 @@ _protect :: proc "contextless" (data: rawptr, size: uint, flags: Protect_Flags)
 	return errno == .NONE
 }
 
-_platform_memory_init :: proc "contextless" () {
-	DEFAULT_PAGE_SIZE = 4096
-	// is power of two
-	assert_contextless(DEFAULT_PAGE_SIZE != 0 && (DEFAULT_PAGE_SIZE & (DEFAULT_PAGE_SIZE-1)) == 0)
-}
-
 _map_file :: proc "contextless" (fd: uintptr, size: i64, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
 	prot: linux.Mem_Protection
 	if .Read in flags {

core/mem/virtual/virtual_other.odin

@@ -25,10 +25,6 @@ _protect :: proc "contextless" (data: rawptr, size: uint, flags: Protect_Flags)
 	return false
 }
 
-_platform_memory_init :: proc "contextless" () {
-
-}
-
 _map_file :: proc "contextless" (f: any, size: i64, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
 	return nil, .Map_Failure
 }

core/mem/virtual/virtual_posix.odin

@@ -28,15 +28,6 @@ _protect :: proc "contextless" (data: rawptr, size: uint, flags: Protect_Flags)
 	return posix.mprotect(data, size, transmute(posix.Prot_Flags)flags) == .OK
 }
 
-_platform_memory_init :: proc "contextless" () {
-	// NOTE: `posix.PAGESIZE` due to legacy reasons could be wrong so we use `sysconf`.
-	size := posix.sysconf(._PAGESIZE)
-	DEFAULT_PAGE_SIZE = uint(max(size, posix.PAGESIZE))
-
-	// is power of two
-	assert_contextless(DEFAULT_PAGE_SIZE != 0 && (DEFAULT_PAGE_SIZE & (DEFAULT_PAGE_SIZE-1)) == 0)
-}
-
 _map_file :: proc "contextless" (fd: uintptr, size: i64, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
 	#assert(i32(posix.Prot_Flag_Bits.READ)  == i32(Map_File_Flag.Read))
 	#assert(i32(posix.Prot_Flag_Bits.WRITE) == i32(Map_File_Flag.Write))

core/mem/virtual/virtual_windows.odin

@@ -146,18 +146,6 @@ _protect :: proc "contextless" (data: rawptr, size: uint, flags: Protect_Flags)
 	return bool(ok)
 }
 
-
-@(no_sanitize_address)
-_platform_memory_init :: proc "contextless" () {
-	sys_info: SYSTEM_INFO
-	GetSystemInfo(&sys_info)
-	DEFAULT_PAGE_SIZE = max(DEFAULT_PAGE_SIZE, uint(sys_info.dwPageSize))
-	
-	// is power of two
-	assert_contextless(DEFAULT_PAGE_SIZE != 0 && (DEFAULT_PAGE_SIZE & (DEFAULT_PAGE_SIZE-1)) == 0)
-}
-
-
 @(no_sanitize_address)
 _map_file :: proc "contextless" (fd: uintptr, size: i64, flags: Map_File_Flags) -> (data: []byte, error: Map_File_Error) {
 	page_flags: u32