Allocating a lot of memory

[LinusU]

I'm running into some problems with memory allocations, and I think that maybe there is currently a limit of 1 MB for allocations? I'm basing this off this code here:

retrowin32/win32/system/src/memory.rs

Lines 207 to 212 in baad402

	// Default process heap size is 1MB. It can be adjusted with linker flags, so we might
	// need to revisit this. Unfortunately currently we need a process heap in place before
	// we load the exe.
	let size = 1 << 20;
	let heap = self.new_heap(size, "process heap".into());
	self.process_heap = heap;

The program I'm currently trying to run starts of by requesting 10_000_000 bytes of memory. Currently this panics, but I've changed the behavior locally to return a null pointer instead:

diff --git a/win32/system/src/heap.rs b/win32/system/src/heap.rs
index 7aa8986d..54aec4f4 100644
--- a/win32/system/src/heap.rs
+++ b/win32/system/src/heap.rs
@@ -31,7 +31,8 @@ impl Heap {
         self.freelist
             .borrow_mut()
             .alloc(mem, size)
-            .unwrap_or_else(|| panic!("heap size {:x} oom {:x}", self.size, size))
+            .unwrap_or(0)
+            // .unwrap_or_else(|| panic!("heap size {:x} oom {:x}", self.size, size))
     }
 
     pub fn size(&self, mem: Mem, addr: u32) -> u32 {

This actually lets the program continue quite a bit, starting to load in files from disk, until it hits another failed allocation of 10_008 bytes, whereupon the program handles this failure, prints an "INSUFFICIENT MEMORY" message, and shuts down...

I need to go to bed now, but any pointers that you have for how I can continue to investigate this would be much appreciated!

[LinusU]

I did something very hacky for now 🙈

diff --git a/win32/src/machine_emu.rs b/win32/src/machine_emu.rs
index ad3a372a..7747725f 100644
--- a/win32/src/machine_emu.rs
+++ b/win32/src/machine_emu.rs
@@ -29,7 +29,7 @@ pub type Machine = MachineX<Emulator>;

 impl MachineX<Emulator> {
     pub fn new(host: Box<dyn host::Host>) -> Self {
-        let memory = Memory::new(MemImpl::new(256 << 20));
+        let memory = Memory::new(MemImpl::new(768 << 20));

         Machine {
             emu: Emulator {
diff --git a/win32/system/src/memory.rs b/win32/system/src/memory.rs
index 44bb233c..007a8f23 100644
--- a/win32/system/src/memory.rs
+++ b/win32/system/src/memory.rs
@@ -204,11 +204,11 @@ impl Memory {

     pub fn create_process_heap(&mut self) {
         debug_assert!(self.process_heap.addr == 0);
-        // Default process heap size is 1MB.  It can be adjusted with linker flags, so we might
-        // need to revisit this.  Unfortunately currently we need a process heap in place before
-        // we load the exe.
-        let size = 1 << 20;
-        let heap = self.new_heap(size, "process heap".into());
+        let size = 512 << 20;
+        let addr = 256 << 20;
+        let mapping = self.mappings.add(Mapping { addr, size, module: None, desc: "process heap".into(), flags: pe::IMAGE_SCN::empty() });
+        let heap = Rc::new(Heap::new(mapping.addr, mapping.size));
+        self.heaps.insert(mapping.addr, heap.clone());
         self.process_heap = heap;
     }

I increased the available memory from 256 MB to 768 MB, and then moved the heap to the 256 MB offset, which should give me a new 512 MB heap in space that previously wasn't available at all (so shouldn't conflict with anything?) 😅

The comment about linker flags makes me think that the correct thing to do might be to read the PE file which will contain information on how much heap it expects? Maybe... I don't know that much about how this normally works, so need to do some more research...