C++ (Cpp) MEMFreeToExpHeapの例

コード例 #1

ファイル: console.c プロジェクト: SakataGintokiYT/decaf-emu

void
consoleFree()
{
   OSScreenShutdown();
   MEMHeapHandle mem1 = MEMGetBaseHeapHandle(MEM_BASE_HEAP_MEM2);
   MEMFreeToExpHeap(mem1, bufferTV);
   MEMFreeToExpHeap(mem1, bufferDRC);
}

コード例 #2

ファイル: coreinit_allocator.cpp プロジェクト: CarlKenner/decaf-emu

static void
allocatorExpHeapFree(MEMAllocator *allocator,
                     void *block)
{
   MEMFreeToExpHeap(reinterpret_cast<MEMExpHeap *>(allocator->heap.get()),
                    block);
}

コード例 #3

ファイル: coreinit_systemheap.cpp プロジェクト: exjam/decaf-emu

/**
 * Free memory to the system heap.
 *
 * \param ptr
 * The memory to free, this pointer must have previously be returned by
 * OSAllocFromSystem.
 */
void
OSFreeToSystem(virt_ptr<void> ptr)
{
   if (internal::isAppDebugLevelVerbose()) {
      internal::COSInfo(
         COSReportModule::Unknown2,
         fmt::format("SYSTEM_HEAP:{},FREE,=\"{}\",{}",
                     sSystemHeapData->numAllocs, ptr, 0));
      ++sSystemHeapData->numAllocs;
   }

   MEMFreeToExpHeap(sSystemHeapData->handle, ptr);
}

コード例 #4

ファイル: memory.c プロジェクト: joolswills/RetroArch

void _free_r(struct _reent *r, void *ptr)
{
   if (ptr) {
      MEMFreeToExpHeap(MEMGetBaseHeapHandle(MEM_BASE_HEAP_MEM2), ptr);
   }
}

コード例 #5

ファイル: memory.c プロジェクト: joolswills/RetroArch

void MEMBucket_free(void *ptr)
{
    MEMFreeToExpHeap(bucket_heap, ptr);
}

コード例 #6

ファイル: memory.c プロジェクト: joolswills/RetroArch

void MEM1_free(void *ptr)
{
    MEMFreeToExpHeap(mem1_heap, ptr);
}

コード例 #7

ファイル: memory.c プロジェクト: joolswills/RetroArch

void MEM2_free(void *ptr)
{
   if (ptr)
      MEMFreeToExpHeap(MEMGetBaseHeapHandle(MEM_BASE_HEAP_MEM2), ptr);
}

コード例 #8

ファイル: coreinit_dynload.cpp プロジェクト: jake-freeman/wiiu-emu

void MEM_DynLoad_DefaultFree(void *addr)
{
   auto heap = MEMGetBaseHeapHandle(BaseHeapType::MEM2);
   MEMFreeToExpHeap(reinterpret_cast<ExpandedHeap*>(heap), addr);
}

コード例 #9

ファイル: main.c プロジェクト: Maschell/wut

static void
CustomFreeToDefaultHeap(void* ptr)
{
   MEMFreeToExpHeap(sCustomHeap, ptr);
}

コード例 #10

ファイル: coreinit_dynload.cpp プロジェクト: goofwear/decaf-emu

/**
 * Default implementation for sMemFree
 */
static void
dynloadDefaultFree(void *addr)
{
   auto heap = MEMGetBaseHeapHandle(MEMBaseHeapType::MEM2);
   MEMFreeToExpHeap(reinterpret_cast<ExpandedHeap*>(heap), addr);
}

コード例 #11

ファイル: coreinit_memheap.cpp プロジェクト: jake-freeman/wiiu-emu

static void
sMEMFreeToDefaultHeap(p32<void> block)
{
   auto heap = MEMGetBaseHeapHandle(BaseHeapType::MEM2);
   return MEMFreeToExpHeap(reinterpret_cast<ExpandedHeap*>(heap), block);
}

コード例 #12

ファイル: frameheap_unaligned.c プロジェクト: decaf-emu/decaf-emu

int main(int argc, char **argv)
{
   MEMHeapHandle mem2 = MEMGetBaseHeapHandle(MEM_BASE_HEAP_MEM2);
   test_assert(mem2);

   test_report("Allocating %d bytes from default heap", HeapSize);
   void *heapAddr = MEMAllocFromExpHeapEx(mem2, HeapSize, 4);
   test_assert(heapAddr);

   // Unalign the frame heap base address
   void *frameHeapAddr = heapAddr + 1;
   test_report("Creating frame heap at %p", frameHeapAddr);
   MEMHeapHandle frameHeap = MEMCreateFrmHeapEx(frameHeapAddr, HeapSize, 0);
   test_report("Frame heap created at %p", frameHeap);
   test_assert(frameHeap);
   test_assert((((uint32_t)frameHeap) % 4) == 0);

   uint32_t freeSize1 = MEMGetAllocatableSizeForFrmHeapEx(frameHeap, 4);
   test_report("Free Size before allocation: %d", freeSize1);
   test_assert((freeSize1 % 4) == 0);

   {
      // Allocate an unaligned block from head with an unaligned size
      void *unalignedBlock = MEMAllocFromFrmHeapEx(frameHeap, 5, 1);
      uint32_t unalignedBlockAddress = (uint32_t)unalignedBlock;
      test_report("Unaligned head block allocated at %p", unalignedBlock);
      test_assert(unalignedBlock);

      // Allocate an aligned block from head and ensure it is aligned
      void *alignedBlock = MEMAllocFromFrmHeapEx(frameHeap, 1024, 512);
      uint32_t alignedBlockAddress = (uint32_t)alignedBlock;
      test_report("Aligned head block allocated at %p", alignedBlock);
      test_assert(alignedBlock);
      test_assert((((uint32_t)alignedBlock) % 512) == 0);
      test_assert(alignedBlockAddress - unalignedBlockAddress >= 5);
   }

   {
      // Allocate an unaligned block from tail with an unaligned size
      void *unalignedBlock = MEMAllocFromFrmHeapEx(frameHeap, 5, -1);
      uint32_t unalignedBlockAddress = (uint32_t)unalignedBlock;
      test_report("Unaligned tail block allocated at %p", unalignedBlock);
      test_assert(unalignedBlock);

      // Allocate an aligned block from tail and ensure it is aligned
      void *alignedBlock = MEMAllocFromFrmHeapEx(frameHeap, 1024, -512);
      uint32_t alignedBlockAddress = (uint32_t)alignedBlock;
      test_report("Aligned tail block allocated at %p", alignedBlock);
      test_assert(alignedBlock);
      test_assert((((uint32_t)alignedBlock) % 512) == 0);
      test_assert(unalignedBlockAddress - alignedBlockAddress >= 512);
   }

   // Free all memory
   MEMFreeToFrmHeap(frameHeap, MEM_FRM_HEAP_FREE_ALL);

   uint32_t freeSize3 = MEMGetAllocatableSizeForFrmHeapEx(frameHeap, 4);
   test_report("Free Size after free: %d", freeSize3);
   test_assert(freeSize1 == freeSize3);

   MEMDestroyFrmHeap(frameHeap);
   MEMFreeToExpHeap(mem2, heapAddr);
   return 0;
}

コード例 #13

ファイル: coreinit_memheap.cpp プロジェクト: goofwear/decaf-emu

void
defaultFreeToDefaultHeap(void *block)
{
   auto heap = MEMGetBaseHeapHandle(MEMBaseHeapType::MEM2);
   return MEMFreeToExpHeap(reinterpret_cast<ExpandedHeap*>(heap), block);
}

コード例 #14

ファイル: memory.c プロジェクト: Ezio-PS/RetroArch

void
__wrap_free(void *ptr) {
   if (ptr) {
      MEMFreeToExpHeap(MEMGetBaseHeapHandle(MEMORY_ARENA_2), ptr);
   }
}