libraries/os/os_AddressSpaceManager.cpp

/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     os_AddressSpaceManager.cpp

  Copyright (C)2009 Nintendo Co., Ltd.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Rev: 17610 $
 *---------------------------------------------------------------------------*/

#include <nn/config.h>
#if NN_PLATFORM_HAS_MMU

#include "os_AddressSpaceManager.h"
#include <nn/os/os_MemoryBlock.h>

namespace nn {
    namespace os {

void AddressSpaceManager::Initialize(uptr begin, size_t size)
{
    m_Lock.Initialize();

    // CHECK: �������ς݂��ǂ������m�F���邱�Ƃ������܂��B

    m_SpaceBegin = begin;
    m_SpaceEnd   = begin + size;
    NN_MIN_TASSERT_(m_SpaceEnd, m_SpaceBegin);
}

uptr AddressSpaceManager::Allocate(MemoryBlockBase* pBlock, size_t size, size_t skipSize)
{
    NN_NULL_TASSERT_(pBlock);
    NN_ALIGN_TASSERT_(size, NN_OS_MEMORY_PAGE_SIZE);
    NN_ALIGN_TASSERT_(skipSize, NN_OS_MEMORY_PAGE_SIZE);

    Lock::ScopedLock scopedLock(m_Lock);

    MemoryBlockBase* pPrev = FindSpace(size, skipSize);
    uptr allocatedAddress;

    if( pPrev != NULL )
    {
        // pPrev �� GetNext(pPrev) �܂��� SpaceEnd �̊Ԃ̋�Ԃ������Ă���

        allocatedAddress = pPrev->GetAddress() + pPrev->GetSize() + skipSize;
        MemoryBlockBase* pNext = m_BlockList.GetNext(pPrev);

        if( pNext != NULL )
        {
            NN_MAX_TASSERT_(allocatedAddress + size + skipSize, pNext->GetAddress());

            m_BlockList.Insert(pNext, pBlock);
        }
        else
        {
            NN_MAX_TASSERT_(allocatedAddress + size + skipSize, m_SpaceEnd);

            m_BlockList.PushBack(pBlock);
        }
    }
    else
    {
        // SpaceBegin �� GetFront() �܂��� SpaceEnd �̊Ԃ̋�Ԃ������Ă���
        // �܂��́A�����Ă��Ȃ��B

        allocatedAddress = m_SpaceBegin;
        MemoryBlockBase* pNext = m_BlockList.GetFront();

        if( pNext != NULL )
        {
            const uptr allocatedEnd = allocatedAddress + size;
            const uptr nextBegin    = pNext->GetAddress();

            if( nextBegin < allocatedEnd + skipSize )
            {
                // �A�h���X��Ԃ̐擪���玟�̃������u���b�N�܂ł̊Ԃ� size ���̋������݂��܂���B
                return NULL;
            }

            m_BlockList.Insert(pNext, pBlock);
        }
        else
        {
            // �S��Ԃ����Ă����ꍇ
            const uptr allocatedEnd = allocatedAddress + size;

            if( m_SpaceEnd < allocatedEnd )
            {
                // �Ǘ����Ă���A�h���X��Ԃ̗̈�ł� size ���̋������݂��܂���B
                return NULL;
            }

            m_BlockList.PushBack(pBlock);
        }
    }

    pBlock->SetAddressAndSize(allocatedAddress, size);

    return allocatedAddress;
}

// �������u���b�N���A�h���X��Ԃɉ�����܂��B
void AddressSpaceManager::Free(MemoryBlockBase* pBlock)
{
    // TODO: pBlock��NULL�`�F�b�N���K�v�ł��B
    Lock::ScopedLock scopedLock(m_Lock);

    m_BlockList.Erase(pBlock);
    pBlock->SetAddressAndSize(NULL, 0);
}

// �������u���b�N�̏��� pFrom ���� pTo �Ɉڂ��܂��B
void AddressSpaceManager::Switch(MemoryBlockBase* pTo, MemoryBlockBase* pFrom)
{
    // TODO: pTo��NULL�`�F�b�N���K�v�ł��B
    // TODO: pFrom��NULL�`�F�b�N���K�v�ł��B
    Lock::ScopedLock scopedLock(m_Lock);

    pTo->SetAddressAndSize(pFrom->GetAddress(), pFrom->GetSize());
    m_BlockList.Insert(pFrom, pTo);

    pFrom->SetAddressAndSize(NULL, 0);
    m_BlockList.Erase(pFrom);
}

// �w�肵���T�C�Y+�y�[�W�T�C�Y���̋�������̈��T�����܂��B
MemoryBlockBase* AddressSpaceManager::FindSpace(size_t size, size_t skipSize)
{
    MemoryBlockBase* pItem = m_BlockList.GetBack();
    uptr end = m_SpaceEnd;
    NN_MIN_TASSERT_(end, m_SpaceBegin);

    while( pItem != NULL )
    {
        const uptr nextBegin = pItem->GetAddress();
        const uptr nextEnd   = nextBegin + pItem->GetSize();
        const size_t spaceSize = end - nextEnd;
        NN_MAX_TASSERT_(nextEnd, end);

        if( spaceSize >= size + skipSize )
        {
            // pItem �̌�낪�����Ă���
            return pItem;
        }

        end = nextBegin - skipSize;
        pItem = m_BlockList.GetPrevious(pItem);
    }

    // �S��Ԃ������Ă���
    // �܂��́A�擪�̋�Ԃ������Ă���
    // �܂��́A�����Ă��Ȃ�
    return NULL;
}

// �A�h���X��Ԃɑ��݂��郁�����u���b�N���X�g���f�o�b�O�o�͂��܂��B
void AddressSpaceManager::Dump()
{
    // CHECK: �_���v���ɑ��̃X���b�h���烊�X�g�̓��e���ύX����Ȃ��悤�Ƀ��b�N���邱�Ƃ������܂��B

    MemoryBlockBase* pItem = m_BlockList.GetFront();

    NN_TLOG_("  --------  %08x %08x\n", m_SpaceBegin, m_SpaceEnd);
    while( pItem != NULL )
    {
        NN_TLOG_("  %08x  %08x %08x\n", pItem, pItem->GetAddress(), pItem->GetAddress() + pItem->GetSize());
        pItem = m_BlockList.GetNext(pItem);
    }

    NN_TPANIC_("dump complete");
}

    }
}


#include <new>
using namespace nn::os;

extern "C" {

void nnosAddressSpaceManagerInitialize(nnosAddressSpaceManager* p, uptr begin, size_t size)
{
    AddressSpaceManager* pThis = new (p) AddressSpaceManager();
    pThis->Initialize(begin, size);
}

uptr nnosAddressSpaceManagerAllocate(nnosAddressSpaceManager* p, nnosMemoryBlockBase* p2, size_t size, size_t skipSize)
{
    AddressSpaceManager* pThis = reinterpret_cast<AddressSpaceManager*>(p);
    MemoryBlockBase* pBlock = reinterpret_cast<MemoryBlockBase*>(p2);
    return pThis->Allocate(pBlock, size, skipSize);
}

void nnosAddressSpaceManagerFree(nnosAddressSpaceManager* p, nnosMemoryBlockBase* p2)
{
    AddressSpaceManager* pThis = reinterpret_cast<AddressSpaceManager*>(p);
    MemoryBlockBase* pBlock = reinterpret_cast<MemoryBlockBase*>(p2);
    pThis->Free(pBlock);
}

void nnosAddressSpaceManagerSwitch(nnosAddressSpaceManager* p, nnosMemoryBlockBase* p2, nnosMemoryBlockBase* p3)
{
    AddressSpaceManager* pThis = reinterpret_cast<AddressSpaceManager*>(p);
    MemoryBlockBase* pTo = reinterpret_cast<MemoryBlockBase*>(p2);
    MemoryBlockBase* pFrom = reinterpret_cast<MemoryBlockBase*>(p3);
    pThis->Switch(pTo, pFrom);
}

}


#endif  // if NN_PLATFORM_HAS_MMU