Ejemplos de free_AmigaMem en C++ (Cpp)

Ejemplo n.º 1

Archivo: pandora_mem.cpp Proyecto: GrethTom/uae4arm-rpi

void alloc_AmigaMem(void)
{
	int i;
	uae_u64 total;
	int max_allowed_mman;

  free_AmigaMem();

  // Get max. available size
	total = (uae_u64)sysconf (_SC_PHYS_PAGES) * (uae_u64)getpagesize();
  
  // Limit to max. 64 MB
	natmem_size = total;
	if (natmem_size > MAXAMIGAMEM)
		natmem_size = MAXAMIGAMEM;

  // We need at least 16 MB
	if (natmem_size < 16 * 1024 * 1024)
		natmem_size = 16 * 1024 * 1024;

	write_log("Total physical RAM %lluM. Attempting to reserve: %uM.\n", total >> 20, natmem_size >> 20);
	natmem_offset = (uae_u8*)valloc (natmem_size);

	if (!natmem_offset) {
		for (;;) {
			natmem_offset = (uae_u8*)valloc (natmem_size);
			if (natmem_offset)
				break;
			natmem_size -= 16 * 1024 * 1024;
			if (!natmem_size) {
				write_log("Can't allocate 16M of virtual address space!?\n");
        abort();
			}
		}
	}
	max_z3fastmem = natmem_size - 32 * 1024 * 1024;
	if(max_z3fastmem < 0)
	  max_z3fastmem = 0;
	write_log("Reserved: %p-%p (0x%08x %dM)\n", natmem_offset, (uae_u8*)natmem_offset + natmem_size,
		natmem_size, natmem_size >> 20);
}

Ejemplo n.º 2

Archivo: generic_mem.cpp Proyecto: lubomyr/uae4arm

void alloc_AmigaMem(void)
{
	int i;
	uae_u64 total;
	int max_allowed_mman;

  free_AmigaMem();
	set_expamem_z3_hack_mode(Z3MAPPING_AUTO);

  // First attempt: allocate 16 MB for all memory in 24-bit area 
  // and additional mem for Z3 and RTG at correct offset
  natmem_size = 16 * 1024 * 1024;
#ifdef ANDROID
  // address returned by valloc() too high for later mmap() calls. Use mmap() also for first area.
  regs.natmem_offset = (uae_u8*) mmap((void *)0x20000000, natmem_size + BARRIER,
    PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
#else
  regs.natmem_offset = (uae_u8*)valloc (natmem_size + BARRIER);
#endif
  max_z3fastmem = ADDITIONAL_MEMSIZE - (16 * 1024 * 1024);
	if (!regs.natmem_offset) {
		write_log("Can't allocate 16M of virtual address space!?\n");
    abort();
	}
  additional_mem = (uae_u8*) mmap(regs.natmem_offset + Z3BASE_REAL, ADDITIONAL_MEMSIZE + BARRIER,
    PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
  if(additional_mem != MAP_FAILED)
  {
    // Allocation successful -> we can use natmem_offset for entire memory access at real address
    changed_prefs.z3autoconfig_start = currprefs.z3autoconfig_start = Z3BASE_REAL;
    z3base_adr = Z3BASE_REAL;
    write_log("Allocated 16 MB for 24-bit area (0x%08x) and %d MB for Z3 and RTG at real address (0x%08x - 0x%08x)\n", 
      regs.natmem_offset, ADDITIONAL_MEMSIZE / (1024 * 1024), additional_mem, additional_mem + ADDITIONAL_MEMSIZE + BARRIER);
    set_expamem_z3_hack_mode(Z3MAPPING_REAL);
    return;
  }

  additional_mem = (uae_u8*) mmap(regs.natmem_offset + Z3BASE_UAE, ADDITIONAL_MEMSIZE + BARRIER,
    PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
  if(additional_mem != MAP_FAILED)
  {
    // Allocation successful -> we can use natmem_offset for entire memory access at fake address
    changed_prefs.z3autoconfig_start = currprefs.z3autoconfig_start = Z3BASE_UAE;
    z3base_adr = Z3BASE_UAE;
    write_log("Allocated 16 MB for 24-bit area (0x%08x) and %d MB for Z3 and RTG at fake address (0x%08x - 0x%08x)\n", 
      regs.natmem_offset, ADDITIONAL_MEMSIZE / (1024 * 1024), additional_mem, additional_mem + ADDITIONAL_MEMSIZE + BARRIER);
    set_expamem_z3_hack_mode(Z3MAPPING_UAE);
    return;
  }
#ifdef ANDROID
  munmap(regs.natmem_offset, natmem_size + BARRIER);
#else
  free(regs.natmem_offset);
#endif
  
  // Next attempt: allocate huge memory block for entire area
  natmem_size = ADDITIONAL_MEMSIZE + 256 * 1024 * 1024;
  regs.natmem_offset = (uae_u8*)valloc (natmem_size + BARRIER);
  if(regs.natmem_offset)
  {
    // Allocation successful
    changed_prefs.z3autoconfig_start = currprefs.z3autoconfig_start = Z3BASE_UAE;
    z3base_adr = Z3BASE_UAE;
    write_log("Allocated %d MB for entire memory\n", natmem_size / (1024 * 1024));
    return;
  }

  // No mem for Z3 or RTG at all
	natmem_size = 16 * 1024 * 1024;
	regs.natmem_offset = (uae_u8*)valloc (natmem_size + BARRIER);

	if (!regs.natmem_offset) {
		write_log("Can't allocate 16M of virtual address space!?\n");
    abort();
	}

  changed_prefs.z3autoconfig_start = currprefs.z3autoconfig_start = 0x00000000; // No mem for Z3
  z3base_adr = 0x00000000;
  max_z3fastmem = 0;

	write_log("Reserved: %p-%p (0x%08x %dM)\n", regs.natmem_offset, (uae_u8*)regs.natmem_offset + natmem_size,
		natmem_size, natmem_size >> 20);
}